@spec __descripex_modules__() :: [module()]

Return the list of modules registered with this library.

Add margin.

Parameters

• exchange - Exchange configuration struct (value)
• symbol - unified market symbol (TS: string) (value)
• amount - amount of margin to add (TS: number) (value)

Returns

{:ok, a [margin structure]{@link https://docs.ccxt.com/?id=margin-structure\}\} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<MarginModification>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value},
    symbol: %{description: "unified market symbol (TS: string)", kind: :value},
    amount: %{description: "amount of margin to add (TS: number)", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, a [margin structure]{@link https://docs.ccxt.com/?id=margin-structure}} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<MarginModification>)"
  }
}

Borrow cross margin.

Parameters

• exchange - Exchange configuration struct (value)
• code - code (TS: string) (value)
• amount - amount (TS: float) (value)

Returns

{:ok, a margin loan structure} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<MarginLoan>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    code: %{description: "code (TS: string)", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value},
    amount: %{description: "amount (TS: float)", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, a margin loan structure} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<MarginLoan>)"
  }
}

Borrow isolated margin.

Parameters

• exchange - Exchange configuration struct (value)
• symbol - symbol (value)
• code - code (value)
• amount - amount (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    code: %{description: "code", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value},
    symbol: %{description: "symbol", kind: :value},
    amount: %{description: "amount", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel all contract orders.

Parameters

• exchange - Exchange configuration struct (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel all open orders, optionally filtered by symbol.

Parameters

• exchange - Exchange configuration struct (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel all orders after.

Parameters

• exchange - Exchange configuration struct (value)
• timeout - timeout (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    timeout: %{description: "timeout", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel all spot orders.

Parameters

• exchange - Exchange configuration struct (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel all uta orders.

Parameters

• exchange - Exchange configuration struct (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel contract order.

Parameters

• exchange - Exchange configuration struct (value)
• id - id (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    id: %{description: "id", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel an existing order by ID.

Parameters

• exchange - Exchange configuration struct (value)
• id - order id (TS: string) (value)

Options

• order_filter - spot only 'Order' or 'StopOrder' or 'tpslOrder'
• stop - alias for trigger
• symbol - unified symbol of the market the order was made in (TS: Str)
• trigger - spot only whether the order is a trigger order

Returns

{:ok, Canceled-order acknowledgement.} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  opts: %{
    stop: %{description: "alias for trigger", kind: :value},
    symbol: %{
      description: "unified symbol of the market the order was made in (TS: Str)",
      kind: :value
    },
    trigger: %{
      description: "*spot only* whether the order is a trigger order",
      kind: :value
    },
    order_filter: %{
      description: "*spot only* 'Order' or 'StopOrder' or 'tpslOrder'",
      kind: :value
    }
  },
  params: %{
    id: %{description: "order id (TS: string)", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, Canceled-order acknowledgement.} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>)"
  }
}

Cancel orders.

Parameters

• exchange - Exchange configuration struct (value)
• ids - order ids (TS: string[]) (value)

Options

• client_order_ids - client order ids
• symbol - unified symbol of the market the order was made in (TS: Str)

Returns

{:ok, an list of [order structures]{@link https://docs.ccxt.com/?id=order-structure\}\} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order[]>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  opts: %{
    symbol: %{
      description: "unified symbol of the market the order was made in (TS: Str)",
      kind: :value
    },
    client_order_ids: %{description: "client order ids", kind: :value}
  },
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value},
    ids: %{description: "order ids (TS: string[])", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, an list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order[]>)"
  }
}

Cancel orders for symbols.

Parameters

• exchange - Exchange configuration struct (value)
• orders - orders (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value},
    orders: %{description: "orders", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel spot order.

Parameters

• exchange - Exchange configuration struct (value)
• id - id (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    id: %{description: "id", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel twap order.

Parameters

• exchange - Exchange configuration struct (value)
• id - id (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    id: %{description: "id", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel unified order.

Parameters

• exchange - Exchange configuration struct (value)
• id - id (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    id: %{description: "id", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel uta order.

Parameters

• exchange - Exchange configuration struct (value)
• id - id (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    id: %{description: "id", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Cancel uta orders.

Parameters

• exchange - Exchange configuration struct (value)
• ids - ids (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value},
    ids: %{description: "ids", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Close all positions.

Parameters

• exchange - Exchange configuration struct (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Close a derivative position for a symbol.

Parameters

• exchange - Exchange configuration struct (value)
• symbol - Unified CCXT market symbol (TS: string) (value)

Options

• auto_cxl - whether any pending orders for closing out needs to be automatically canceled when close position via a market order. false or true, the default is false
• client_order_id - a unique identifier for the order
• code - required in the case of closing cross MARGIN position for Single-currency margin margin currency EXCHANGE SPECIFIC PARAMETERS
• margin_mode - 'cross' or 'isolated', default is 'cross;
• side - 'buy' or 'sell', leave as undefined in net mode (TS: OrderSide)
• tag - order tag a combination of case-sensitive alphanumerics, all numbers, or all letters of up to 16 characters

Returns

{:ok, [A list of position structures]{@link https://docs.ccxt.com/?id=position-structure\}\} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  opts: %{
    code: %{
      description: "*required in the case of closing cross MARGIN position for Single-currency margin* margin currency  EXCHANGE SPECIFIC PARAMETERS",
      kind: :value
    },
    tag: %{
      description: "order tag a combination of case-sensitive alphanumerics, all numbers, or all letters of up to 16 characters",
      kind: :value
    },
    side: %{
      description: "'buy' or 'sell', leave as undefined in net mode (TS: OrderSide)",
      kind: :value
    },
    margin_mode: %{
      description: "'cross' or 'isolated', default is 'cross;",
      kind: :value
    },
    client_order_id: %{
      description: "a unique identifier for the order",
      kind: :value
    },
    auto_cxl: %{
      description: "whether any pending orders for closing out needs to be automatically canceled when close position via a market order. false or true, the default is false",
      kind: :value
    }
  },
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value},
    symbol: %{
      description: "Unified CCXT market symbol (TS: string)",
      kind: :value
    }
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, [A list of position structures]{@link https://docs.ccxt.com/?id=position-structure}} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>)"
  }
}

@spec config(Bourse.Exchange.t()) :: Bourse.Exchange.config()

Returns the derived config metadata (credentials/limits/status/routing/flags) for an exchange.

Parameters

• exchange - Exchange configuration struct (value)

Returns

Deterministic describe() config metadata, or an empty map when the spec predates the contract (map)

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  returns: %{
    type: :map,
    description: "Deterministic describe() config metadata, or an empty map when the spec predates the contract"
  }
}

Create account.

Parameters

• exchange - Exchange configuration struct (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Create contract order.

Parameters

• exchange - Exchange configuration struct (value)
• symbol - symbol (value)
• type - type (value)
• side - side (value)
• amount - amount (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    type: %{description: "type", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value},
    symbol: %{description: "symbol", kind: :value},
    amount: %{description: "amount", kind: :value},
    side: %{description: "side", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Create contract orders.

Parameters

• exchange - Exchange configuration struct (value)
• orders - orders (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value},
    orders: %{description: "orders", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Create convert trade.

Parameters

• exchange - Exchange configuration struct (value)
• id - the id of the trade that you want to make (TS: string) (value)
• from_code - from code (TS: string) (value)
• to_code - to code (TS: string) (value)
• amount - how much you want to trade in units of the from currency (TS: Num) (value)

Returns

{:ok, a [conversion structure]{@link https://docs.ccxt.com/?id=conversion-structure\}\} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Conversion>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    id: %{
      description: "the id of the trade that you want to make (TS: string)",
      kind: :value
    },
    exchange: %{description: "Exchange configuration struct", kind: :value},
    amount: %{
      description: "how much you want to trade in units of the from currency (TS: Num)",
      kind: :value
    },
    from_code: %{description: "from code (TS: string)", kind: :value},
    to_code: %{description: "to code (TS: string)", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, a [conversion structure]{@link https://docs.ccxt.com/?id=conversion-structure}} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Conversion>)"
  }
}

Create deposit address.

Parameters

• exchange - Exchange configuration struct (value)
• code - unified currency code of the currency for the deposit address (TS: string) (value)

Returns

{:ok, an [address structure]{@link https://docs.ccxt.com/?id=address-structure\}\} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<DepositAddress>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    code: %{
      description: "unified currency code of the currency for the deposit address (TS: string)",
      kind: :value
    },
    exchange: %{description: "Exchange configuration struct", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, an [address structure]{@link https://docs.ccxt.com/?id=address-structure}} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<DepositAddress>)"
  }
}

Create gift code.

Parameters

• exchange - Exchange configuration struct (value)
• code - code (value)
• amount - amount (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    code: %{description: "code", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value},
    amount: %{description: "amount", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Create market buy order with cost.

Parameters

• exchange - Exchange configuration struct (value)
• symbol - unified symbol of the market to create an order in (TS: string) (value)
• cost - how much you want to trade in units of the quote currency (TS: number) (value)

Returns

{:ok, an [order structure]{@link https://docs.ccxt.com/?id=order-structure\}\} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value},
    symbol: %{
      description: "unified symbol of the market to create an order in (TS: string)",
      kind: :value
    },
    cost: %{
      description: "how much you want to trade in units of the quote currency (TS: number)",
      kind: :value
    }
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, an [order structure]{@link https://docs.ccxt.com/?id=order-structure}} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>)"
  }
}

Create market order with cost.

Parameters

• exchange - Exchange configuration struct (value)
• symbol - symbol (value)
• side - side (value)
• cost - cost (value)

Returns

{:ok, map()} on success, {:error, Bourse.Error.t()} on failure (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value},
    symbol: %{description: "symbol", kind: :value},
    cost: %{description: "cost", kind: :value},
    side: %{description: "side", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, map()} on success, {:error, Bourse.Error.t()} on failure"
  }
}

Create market sell order with cost.

Parameters

• exchange - Exchange configuration struct (value)
• symbol - unified symbol of the market to create an order in (TS: string) (value)
• cost - how much you want to trade in units of the quote currency (TS: number) (value)

Returns

{:ok, an [order structure]{@link https://docs.ccxt.com/?id=order-structure\}\} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  params: %{
    exchange: %{description: "Exchange configuration struct", kind: :value},
    symbol: %{
      description: "unified symbol of the market to create an order in (TS: string)",
      kind: :value
    },
    cost: %{
      description: "how much you want to trade in units of the quote currency (TS: number)",
      kind: :value
    }
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, an [order structure]{@link https://docs.ccxt.com/?id=order-structure}} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>)"
  }
}

Create a new order on the exchange.

Parameters

• exchange - Exchange configuration struct (value)
• symbol - unified symbol of the market to create an order in (TS: string) (value)
• type - 'market' or 'limit' (TS: OrderType) (value)
• side - 'buy' or 'sell' (TS: OrderSide) (value)
• amount - how much of currency you want to trade in units of base currency (TS: number) (value)

Options

• hedged - contracts only true for hedged mode, false for one way mode, default is false
• is_leverage - unified spot only false then spot trading true then margin trading
• mmp - option only market maker protection
• position_idx - contracts only 0 for one-way mode, 1 buy side of hedged mode, 2 sell side of hedged mode
• post_only - true or false whether the order is post-only
• price - the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders (TS: Num)
• reduce_only - true or false whether the order is reduce-only
• stop_loss - stopLoss object in params containing the triggerPrice at which the attached stop loss order will be triggered
• stop_loss/trigger_price - stop loss trigger price
• stop_loss_limit_price - The limit price for a stoploss order (only when used in OCO with takeProfitPrice)
• stop_loss_price - The price at which a stop loss order is triggered at
• take_profit - takeProfit object in params containing the triggerPrice at which the attached take profit order will be triggered
• take_profit/trigger_price - take profit trigger price
• take_profit_limit_price - The limit price for a takeprofit order (only when used in OCO combination with stopLossPrice)
• take_profit_price - The price at which a take profit order is triggered at
• time_in_force - "GTC", "IOC", "FOK"
• tpsl_mode - contract only 'Full' or 'Partial'
• trading_stop_endpoint - whether to enforce using the tradingStop (https://bybit-exchange.github.io/docs/v5/position/trading-stop) endpoint, makes difference when submitting single tp/sl order
• trailing_amount - the quote amount to trail away from the current market price
• trailing_trigger_price - the price to trigger a trailing order, default uses the price argument
• trigger_direction - contract only the direction for trigger orders, 'ascending' or 'descending'
• trigger_price - The price at which a trigger order is triggered at

Returns

{:ok, Unified accepted paper order.} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>) (result_tuple)

Errors

• :not_supported
• :authentication_error
• :rate_limit_exceeded
• :network_error

# descripex:contract
%{
  opts: %{
    price: %{
      description: "the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders (TS: Num)",
      kind: :value
    },
    time_in_force: %{description: "\"GTC\", \"IOC\", \"FOK\"", kind: :value},
    trigger_price: %{
      description: "The price at which a trigger order is triggered at",
      kind: :value
    },
    take_profit_price: %{
      description: "The price at which a take profit order is triggered at",
      kind: :value
    },
    stop_loss_price: %{
      description: "The price at which a stop loss order is triggered at",
      kind: :value
    },
    reduce_only: %{
      description: "true or false whether the order is reduce-only",
      kind: :value
    },
    post_only: %{
      description: "true or false whether the order is post-only",
      kind: :value
    },
    hedged: %{
      description: "*contracts only* true for hedged mode, false for one way mode, default is false",
      kind: :value
    },
    is_leverage: %{
      description: "*unified spot only* false then spot trading true then margin trading",
      kind: :value
    },
    mmp: %{description: "*option only* market maker protection", kind: :value},
    position_idx: %{
      description: "*contracts only* 0 for one-way mode, 1 buy side of hedged mode, 2 sell side of hedged mode",
      kind: :value
    },
    stop_loss: %{
      description: "*stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered",
      kind: :value
    },
    "stop_loss/trigger_price": %{
      description: "stop loss trigger price",
      kind: :value
    },
    stop_loss_limit_price: %{
      description: "The limit price for a stoploss order (only when used in OCO with takeProfitPrice)",
      kind: :value
    },
    take_profit: %{
      description: "*takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered",
      kind: :value
    },
    "take_profit/trigger_price": %{
      description: "take profit trigger price",
      kind: :value
    },
    take_profit_limit_price: %{
      description: "The limit price for a takeprofit order (only when used in OCO combination with stopLossPrice)",
      kind: :value
    },
    tpsl_mode: %{
      description: "*contract only* 'Full' or 'Partial'",
      kind: :value
    },
    trading_stop_endpoint: %{
      description: "whether to enforce using the tradingStop (https://bybit-exchange.github.io/docs/v5/position/trading-stop) endpoint, makes difference when submitting single tp/sl order",
      kind: :value
    },
    trailing_amount: %{
      description: "the quote amount to trail away from the current market price",
      kind: :value
    },
    trailing_trigger_price: %{
      description: "the price to trigger a trailing order, default uses the price argument",
      kind: :value
    },
    trigger_direction: %{
      description: "*contract only* the direction for trigger orders, 'ascending' or 'descending'",
      kind: :value
    }
  },
  params: %{
    type: %{description: "'market' or 'limit' (TS: OrderType)", kind: :value},
    exchange: %{description: "Exchange configuration struct", kind: :value},
    symbol: %{
      description: "unified symbol of the market to create an order in (TS: string)",
      kind: :value
    },
    amount: %{
      description: "how much of currency you want to trade in units of base currency (TS: number)",
      kind: :value
    },
    side: %{description: "'buy' or 'sell' (TS: OrderSide)", kind: :value}
  },
  errors: [:not_supported, :authentication_error, :rate_limit_exceeded,
   :network_error],
  returns: %{
    type: :result_tuple,
    description: "{:ok, Unified accepted paper order.} on success, {:error, Bourse.Error.t()} on failure (TS: Promise<Order>)"
  }
}