Class Client

Example

// for spidex.private.createApiKey and all other API.
const spidex = new Client({
  provider,
  currentAccount: '0xB725C34A30f3637B396dA2046d72ae3a4bd78xxx' // user address
});

// for other API, you can also use the following:
const spidex = new Client();

// or
const spidex = Client.getInstance()

Hierarchy

Client

Index

Constructors

constructor

new Client(options?: IClientConfig): Client
Constructor
Parameters
- options: IClientConfig = ...
  
  config params
Returns Client
- Defined in src/client.ts:124

Properties

api

api: {
    baseApi: (() => string);
    baseRpcApi: (() => string);
    cosmosRestApi: (() => string);
    cosmosRpcApi: (() => string);
    explorerGraphqlApi: (() => string);
    explorerRestApi: (() => string);
    explorerWebsocketApi: (() => string);
    osmosisRestApi: (() => string);
    osmosisRpcApi: (() => string);
    websocketApi: (() => string);
} = ...

api

Type declaration

baseApi: (() => string)
- - (): string
  - base api
    
    Returns string
baseRpcApi: (() => string)
- - (): string
  - base rpc api
    
    Returns string
cosmosRestApi: (() => string)
- - (): string
  - cosmosRestApi
    
    Returns string
cosmosRpcApi: (() => string)
- - (): string
  - cosmosRpcApi
    
    Returns string
explorerGraphqlApi: (() => string)
- - (): string
  - explorerGraphqlApi
    
    Returns string
explorerRestApi: (() => string)
- - (): string
  - explorerRest
    
    Returns string
explorerWebsocketApi: (() => string)
- - (): string
  - explorerWebsocketApi
    
    Returns string
osmosisRestApi: (() => string)
- - (): string
  - osmosisRestApi
    
    Returns string
osmosisRpcApi: (() => string)
- - (): string
  - osmosisRpcApi
    
    Returns string
websocketApi: (() => string)
- - (): string
  - websocket api
    
    Returns string

auth

auth: {
    createApiKey: ((params: {
        SPIDEX-ADDRESS: string;
        SPIDEX-SIGNATURE: string;
        SPIDEX-TIMESTAMP?: string;
    }) => Promise<{
        key: string;
        passphrase: string;
        secret: string;
    }>);
    onBoarding: ((params: {
        derived_pub: string;
        referee_address?: string;
    }, headers: IHeadersParams2) => Promise<{
        key: string;
        passphrase: string;
        secret: string;
    }>);
} = ...

Spidex authentication

Type declaration

createApiKey: ((params: {
    SPIDEX-ADDRESS: string;
    SPIDEX-SIGNATURE: string;
    SPIDEX-TIMESTAMP?: string;
}) => Promise<{
    key: string;
    passphrase: string;
    secret: string;
}>)

(params: {
    SPIDEX-ADDRESS: string;
    SPIDEX-SIGNATURE: string;
    SPIDEX-TIMESTAMP?: string;
}): Promise<{
    key: string;
    passphrase: string;
    secret: string;
}>

Create API Key

Create an API key to authorize access to private APIs.

Example

const timestamp = spidex.utils.getTimestamp();
spidex.initConfig({
  web3Provider: provider,
  currentAccount: yourAccount
});
const signature = await spidex.utils.sign({
  provider: spidex.config.web3Provider, // or provider
  signer: spidex.config.currentAccount, // or yourAccount
  primaryType: IPrimaryType.createApiKey,
  message: {
    method: 'POST',
    requestPath: IRequestPath.createApiKey,
    timestamp = '',
  }
});
await spidex.private.createApiKey({
  'SPIDEX-TIMESTAMP': timestamp = '',
  'SPIDEX-ADDRESS': spidex.config.currentAccount,
  'SPIDEX-SIGNATURE': signature.substr(2),
})

Parameters

params: {
    SPIDEX-ADDRESS: string;
    SPIDEX-SIGNATURE: string;
    SPIDEX-TIMESTAMP?: string;
}
- SPIDEX-ADDRESS: string
- SPIDEX-SIGNATURE: string
- Optional SPIDEX-TIMESTAMP?: string

Returns Promise<{
    key: string;
    passphrase: string;
    secret: string;
}>

onBoarding: ((params: {
    derived_pub: string;
    referee_address?: string;
}, headers: IHeadersParams2) => Promise<{
    key: string;
    passphrase: string;
    secret: string;
}>)
- - (params: {
        derived_pub: string;
        referee_address?: string;
    }, headers: IHeadersParams2): Promise<{
        key: string;
        passphrase: string;
        secret: string;
    }>
  - on boarding
    
    Example
```
await spidex.private.onBoarding({
  derived_pub: '',
}, {
  'SPIDEX-ADDRESS': '',
  'SPIDEX-SIGNATURE': '',
})
```
    Parameters
    - params: {
      derived_pub: string;
      referee_address?: string;
      }
      
      derived_pub: string
      
      Optional referee_address?: string
    - headers: IHeadersParams2
    Returns Promise<{
        key: string;
        passphrase: string;
        secret: string;
    }>

config

config: IClientConfig

Spidex config data

cosmos

cosmos: {
rest: ((options: ICosmosRESTOptions) => Promise<any>);
rpc: ((options: ICosmosRPCOptions) => Promise<IRPCResponse>);
} = ...

Spidex Cosmos rpc api

Type declaration

rest: ((options: ICosmosRESTOptions) => Promise<any>)
- - (options: ICosmosRESTOptions): Promise<any>
  - Parameters
    - options: ICosmosRESTOptions
    Returns Promise<any>
rpc: ((options: ICosmosRPCOptions) => Promise<IRPCResponse>)
- - (options: ICosmosRPCOptions): Promise<IRPCResponse>
  - Parameters
    - options: ICosmosRPCOptions
    Returns Promise<IRPCResponse>

osmosis

osmosis: {
rest: ((options: IOsmosisRESTOptions) => Promise<any>);
rpc: ((options: IOsmosisRPCOptions) => Promise<IRPCResponse>);
} = ...

Spidex Osmosis rpc api

Type declaration

rest: ((options: IOsmosisRESTOptions) => Promise<any>)
- - (options: IOsmosisRESTOptions): Promise<any>
  - Parameters
    - options: IOsmosisRESTOptions
    Returns Promise<any>
rpc: ((options: IOsmosisRPCOptions) => Promise<IRPCResponse>)
- - (options: IOsmosisRPCOptions): Promise<IRPCResponse>
  - Parameters
    - options: IOsmosisRPCOptions
    Returns Promise<IRPCResponse>

private

private: {
    account: ((params: {
        address: string;
    }, headers?: IHeadersParams) => Promise<IAccoutResponse>);
    cancelOrder: ((params: {
        order_hash: string;
    }, headers?: IHeadersParams) => Promise<any>);
    createApiKey: ((params: {
        SPIDEX-ADDRESS: string;
        SPIDEX-SIGNATURE: string;
        SPIDEX-TIMESTAMP?: string;
    }) => Promise<{
        key: string;
        passphrase: string;
        secret: string;
    }>);
    createOrder: ((params: {
        amount: string;
        expiration: number;
        price: string;
        salt: number;
        side: string;
        signature: string;
        symbol: string;
        timestamp?: string;
        type: string;
        vault_address?: string;
    }, headers?: IHeadersParams) => Promise<Record<string, unknown>>);
    deleteApiKeys: ((headers?: {
        SPIDEX-ADDRESS: string;
        SPIDEX-SIGNATURE: string;
        SPIDEX-TIMESTAMP: string;
    }) => Promise<string>);
    depositMargin: ((params: {
        amount: string;
        pos_address: string;
        salt: number;
        signature: string;
        symbol: string;
        timestamp: string;
    }, headers?: IHeadersParams) => Promise<{
        tx_hash: string;
    }>);
    fundingRecords: ((params?: {
        limit?: number;
        offset?: number;
        pos_address: string;
        symbol?: string;
    }, headers?: IHeadersParams) => Promise<IFundingRecordsResponse[]>);
    getApiKeys: ((headers?: IHeadersParams) => Promise<string[]>);
    getMarginTransfers: ((params: {
        limit?: number;
        offset?: number;
        pos_address: string;
    }, headers?: IHeadersParams) => Promise<IResponseMarginTransfer[]>);
    getOrder: ((params: {
        hash: string;
    }, headers?: IHeadersParams) => Promise<IOrderResponse>);
    getOrders: ((params: {
        limit?: number;
        maker_address?: string;
        offset?: number;
        side?: string;
        status?: string | string[];
        symbol?: string;
        vault_address?: string;
    }, headers?: IHeadersParams) => Promise<IOrderResponse[]>);
    getPosition: ((params: {
        pos_address: string;
        symbol: string;
    }, headers?: IHeadersParams) => Promise<IResponsePosition>);
    getTrades: ((params: {
        limit?: number;
        maker_address?: string;
        offset?: number;
        vault_address?: string;
    }, headers?: IHeadersParams) => Promise<ITradeResponse[]>);
    onBoarding: ((params: {
        derived_pub: string;
        referee_address?: string;
    }, headers: IHeadersParams2) => Promise<{
        key: string;
        passphrase: string;
        secret: string;
    }>);
    withdrawMargin: ((params: {
        amount: string;
        pos_address: string;
        salt: number;
        signature: string;
        symbol: string;
        timestamp: string;
    }, headers?: IHeadersParams) => Promise<{
        tx_hash: string;
    }>);
} = ...

Spidex private api

Remarks

All Private APIs need to be accessed by using the API KEY. Please create api key first!

Type declaration

account: ((params: {
address: string;
}, headers?: IHeadersParams) => Promise<IAccoutResponse>)
- - (params: {
    address: string;
    }, headers?: IHeadersParams): Promise<IAccoutResponse>
  - Get account
    
    Example
```
await spidex.private.account({
 address,
})
```
    Parameters
    - params: {
      address: string;
      }
      
      address: string
    - Optional headers: IHeadersParams
    Returns Promise<IAccoutResponse>
cancelOrder: ((params: {
order_hash: string;
}, headers?: IHeadersParams) => Promise<any>)
- - (params: {
    order_hash: string;
    }, headers?: IHeadersParams): Promise<any>
  - Cancel Order
    
    Cancel pending order.
    
    Example
```
await spidex.private.cancelOrder({
  order_hash
})
```
    Parameters
    - params: {
      order_hash: string;
      }
      
      order_hash: string
    - Optional headers: IHeadersParams
    Returns Promise<any>

createApiKey: ((params: {
    SPIDEX-ADDRESS: string;
    SPIDEX-SIGNATURE: string;
    SPIDEX-TIMESTAMP?: string;
}) => Promise<{
    key: string;
    passphrase: string;
    secret: string;
}>)

(params: {
    SPIDEX-ADDRESS: string;
    SPIDEX-SIGNATURE: string;
    SPIDEX-TIMESTAMP?: string;
}): Promise<{
    key: string;
    passphrase: string;
    secret: string;
}>

Create API Key

Create an API key to authorize access to private APIs.

Example

const timestamp = spidex.utils.getTimestamp();
spidex.initConfig({
  web3Provider: provider,
  currentAccount: yourAccount
});
const signature = await spidex.utils.sign({
  provider: spidex.config.web3Provider, // or provider
  signer: spidex.config.currentAccount, // or yourAccount
  primaryType: IPrimaryType.createApiKey,
  message: {
    method: 'POST',
    requestPath: IRequestPath.createApiKey,
    timestamp = '',
  }
});
await spidex.private.createApiKey({
  'SPIDEX-TIMESTAMP': timestamp = '',
  'SPIDEX-ADDRESS': spidex.config.currentAccount,
  'SPIDEX-SIGNATURE': signature.substr(2),
})

Parameters

params: {
    SPIDEX-ADDRESS: string;
    SPIDEX-SIGNATURE: string;
    SPIDEX-TIMESTAMP?: string;
}
- SPIDEX-ADDRESS: string
- SPIDEX-SIGNATURE: string
- Optional SPIDEX-TIMESTAMP?: string

Returns Promise<{
    key: string;
    passphrase: string;
    secret: string;
}>

createOrder: ((params: {
    amount: string;
    expiration: number;
    price: string;
    salt: number;
    side: string;
    signature: string;
    symbol: string;
    timestamp?: string;
    type: string;
    vault_address?: string;
}, headers?: IHeadersParams) => Promise<Record<string, unknown>>)
- - (params: {
        amount: string;
        expiration: number;
        price: string;
        salt: number;
        side: string;
        signature: string;
        symbol: string;
        timestamp?: string;
        type: string;
        vault_address?: string;
    }, headers?: IHeadersParams): Promise<Record<string, unknown>>
  - Create Order
    
    Initiate transactions, go long/short/close long/close short, all through this interface.
    
    Example
```
await spidex.private.createOrder({
  vault_address: '0x239721212121....',
  symbol: 'BTCUSDC',
  side: 'BUY',
  price: '1000',
  amount: '2000',
  salt: 100,
  expiration: Date.now() + 3600 * 24 * 30 * 1000,
  signature: 'asx239da1212121...', // eip712Signature spidex.tools.sign
  timestamp: '', // of signature timestamp
})
```
    Parameters
    - params: {
          amount: string;
          expiration: number;
          price: string;
          salt: number;
          side: string;
          signature: string;
          symbol: string;
          timestamp?: string;
          type: string;
          vault_address?: string;
      }
      
      amount: string
      
      expiration: number
      
      price: string
      
      salt: number
      
      side: string
      
      signature: string
      
      symbol: string
      
      Optional timestamp?: string
      
      type: string
      
      Optional vault_address?: string
    - Optional headers: IHeadersParams
    Returns Promise<Record<string, unknown>>
deleteApiKeys: ((headers?: {
    SPIDEX-ADDRESS: string;
    SPIDEX-SIGNATURE: string;
    SPIDEX-TIMESTAMP: string;
}) => Promise<string>)
- - (headers?: {
        SPIDEX-ADDRESS: string;
        SPIDEX-SIGNATURE: string;
        SPIDEX-TIMESTAMP: string;
    }): Promise<string>
  - delete apiKeys
    
    Example
```
await spidex.private.deleteApiKeys({
 // ...
})
```
    Parameters
    - Optional headers: {
          SPIDEX-ADDRESS: string;
          SPIDEX-SIGNATURE: string;
          SPIDEX-TIMESTAMP: string;
      }
      
      SPIDEX-ADDRESS: string
      
      SPIDEX-SIGNATURE: string
      
      SPIDEX-TIMESTAMP: string
    Returns Promise<string>
depositMargin: ((params: {
    amount: string;
    pos_address: string;
    salt: number;
    signature: string;
    symbol: string;
    timestamp: string;
}, headers?: IHeadersParams) => Promise<{
    tx_hash: string;
}>)
- - (params: {
        amount: string;
        pos_address: string;
        salt: number;
        signature: string;
        symbol: string;
        timestamp: string;
    }, headers?: IHeadersParams): Promise<{
        tx_hash: string;
    }>
  - Deposit Margin
    
    Add margin to a position
    
    Example
```
await spidex.private.depositMargin({
  // ...params
})
```
    Parameters
    - params: {
          amount: string;
          pos_address: string;
          salt: number;
          signature: string;
          symbol: string;
          timestamp: string;
      }
      
      amount: string
      
      pos_address: string
      
      salt: number
      
      signature: string
      
      symbol: string
      
      timestamp: string
    - Optional headers: IHeadersParams
    Returns Promise<{
    tx_hash: string;
    }>
fundingRecords: ((params?: {
    limit?: number;
    offset?: number;
    pos_address: string;
    symbol?: string;
}, headers?: IHeadersParams) => Promise<IFundingRecordsResponse[]>)
- - (params?: {
        limit?: number;
        offset?: number;
        pos_address: string;
        symbol?: string;
    }, headers?: IHeadersParams): Promise<IFundingRecordsResponse[]>
  - Query Funding Records
    
    Example
```
await spidex.public.fundingRecords({
  symbol,
  limit,
  offset
})
```
    Parameters
    - Optional params: {
          limit?: number;
          offset?: number;
          pos_address: string;
          symbol?: string;
      }
      
      Optional limit?: number
      
      Optional offset?: number
      
      pos_address: string
      
      Optional symbol?: string
    - Optional headers: IHeadersParams
    Returns Promise<IFundingRecordsResponse[]>
getApiKeys: ((headers?: IHeadersParams) => Promise<string[]>)
- - (headers?: IHeadersParams): Promise<string[]>
  - get apiKeys
    
    Example
```
await spidex.private.getApiKeys({
 // ...
})
```
    Parameters
    - Optional headers: IHeadersParams
    Returns Promise<string[]>
getMarginTransfers: ((params: {
    limit?: number;
    offset?: number;
    pos_address: string;
}, headers?: IHeadersParams) => Promise<IResponseMarginTransfer[]>)
- - (params: {
        limit?: number;
        offset?: number;
        pos_address: string;
    }, headers?: IHeadersParams): Promise<IResponseMarginTransfer[]>
  - Query margin transfers
    
    Example
```
await spidex.private.getMarginTransfers({
  // ...headers
})
```
    Parameters
    - params: {
          limit?: number;
          offset?: number;
          pos_address: string;
      }
      
      Optional limit?: number
      
      Optional offset?: number
      
      pos_address: string
    - Optional headers: IHeadersParams
    Returns Promise<IResponseMarginTransfer[]>
getOrder: ((params: {
hash: string;
}, headers?: IHeadersParams) => Promise<IOrderResponse>)
- - (params: {
    hash: string;
    }, headers?: IHeadersParams): Promise<IOrderResponse>
  - Query Order
    
    Query the specified order according to the order hash
    
    Example
```
await spidex.private.getOrder({
  hash
})
```
    Parameters
    - params: {
      hash: string;
      }
      
      hash: string
    - Optional headers: IHeadersParams
    Returns Promise<IOrderResponse>
getOrders: ((params: {
    limit?: number;
    maker_address?: string;
    offset?: number;
    side?: string;
    status?: string | string[];
    symbol?: string;
    vault_address?: string;
}, headers?: IHeadersParams) => Promise<IOrderResponse[]>)
- - (params: {
        limit?: number;
        maker_address?: string;
        offset?: number;
        side?: string;
        status?: string | string[];
        symbol?: string;
        vault_address?: string;
    }, headers?: IHeadersParams): Promise<IOrderResponse[]>
  - Query Orders
    
    Query the historical pending orders of the current user
    
    Example
```
await spidex.private.getOrders({
  // ...params
})
```
    Parameters
    - params: {
          limit?: number;
          maker_address?: string;
          offset?: number;
          side?: string;
          status?: string | string[];
          symbol?: string;
          vault_address?: string;
      }
      
      Optional limit?: number
      
      Optional maker_address?: string
      
      Optional offset?: number
      
      Optional side?: string
      
      Optional status?: string | string[]
      
      Optional symbol?: string
      
      Optional vault_address?: string
    - Optional headers: IHeadersParams
    Returns Promise<IOrderResponse[]>
getPosition: ((params: {
pos_address: string;
symbol: string;
}, headers?: IHeadersParams) => Promise<IResponsePosition>)
- - (params: {
    pos_address: string;
    symbol: string;
    }, headers?: IHeadersParams): Promise<IResponsePosition>
  - Query Position
    
    Query the current user's position information
    
    Example
```
await spidex.private.getPosition({
  // ...params
})
```
    Parameters
    - params: {
      pos_address: string;
      symbol: string;
      }
      
      pos_address: string
      
      symbol: string
    - Optional headers: IHeadersParams
    Returns Promise<IResponsePosition>
getTrades: ((params: {
    limit?: number;
    maker_address?: string;
    offset?: number;
    vault_address?: string;
}, headers?: IHeadersParams) => Promise<ITradeResponse[]>)
- - (params: {
        limit?: number;
        maker_address?: string;
        offset?: number;
        vault_address?: string;
    }, headers?: IHeadersParams): Promise<ITradeResponse[]>
  - Query Latest Trades
    
    Example
```
await spidex.private.getTrades({
  // ...params
})
```
    Parameters
    - params: {
          limit?: number;
          maker_address?: string;
          offset?: number;
          vault_address?: string;
      }
      
      Optional limit?: number
      
      Optional maker_address?: string
      
      Optional offset?: number
      
      Optional vault_address?: string
    - Optional headers: IHeadersParams
    Returns Promise<ITradeResponse[]>
onBoarding: ((params: {
    derived_pub: string;
    referee_address?: string;
}, headers: IHeadersParams2) => Promise<{
    key: string;
    passphrase: string;
    secret: string;
}>)
- - (params: {
        derived_pub: string;
        referee_address?: string;
    }, headers: IHeadersParams2): Promise<{
        key: string;
        passphrase: string;
        secret: string;
    }>
  - on boarding
    
    Example
```
await spidex.private.onBoarding({
  derived_pub: '',
}, {
  'SPIDEX-ADDRESS': '',
  'SPIDEX-SIGNATURE': '',
})
```
    Parameters
    - params: {
      derived_pub: string;
      referee_address?: string;
      }
      
      derived_pub: string
      
      Optional referee_address?: string
    - headers: IHeadersParams2
    Returns Promise<{
        key: string;
        passphrase: string;
        secret: string;
    }>
withdrawMargin: ((params: {
    amount: string;
    pos_address: string;
    salt: number;
    signature: string;
    symbol: string;
    timestamp: string;
}, headers?: IHeadersParams) => Promise<{
    tx_hash: string;
}>)
- - (params: {
        amount: string;
        pos_address: string;
        salt: number;
        signature: string;
        symbol: string;
        timestamp: string;
    }, headers?: IHeadersParams): Promise<{
        tx_hash: string;
    }>
  - Withdraw Margin
    
    Withdraw margin to a position
    
    Example
```
await spidex.private.withdrawMargin({
  // ...params
})
```
    Parameters
    - params: {
          amount: string;
          pos_address: string;
          salt: number;
          signature: string;
          symbol: string;
          timestamp: string;
      }
      
      amount: string
      
      pos_address: string
      
      salt: number
      
      signature: string
      
      symbol: string
      
      timestamp: string
    - Optional headers: IHeadersParams
    Returns Promise<{
    tx_hash: string;
    }>

public

public: {
    account: ((params: {
        address: string;
    }, headers?: IHeadersParams) => Promise<IAccoutResponse>);
    compileDsl: ((params: {
        dsl_code: string;
    }) => Promise<ICompileDSLResponse>);
    getDeals: ((params: {
        limit?: number;
        symbol: string;
    }) => Promise<IDealResponse[]>);
    getDepth: ((params: {
        address?: string;
        symbol: string;
        type?: string;
    }) => Promise<IDepthData>);
    getKlines: ((params: {
        endTime?: string;
        interval: IIterval;
        limit?: number;
        startTime?: string;
        symbol: string;
    }) => Promise<IKlineDataItem[]>);
    getMarket: ((params: {
        symbol: string;
    }) => Promise<IMarketInfo>);
    getMarkets: (() => Promise<IMarketsInfo>);
    getTradeVolumes: ((params: {
        limit?: number;
    }) => Promise<ITradeVolumesResponse[]>);
    getVaultIncomes: ((params: {
        address: string;
        interval: string;
        limit?: number;
    }) => Promise<IVaultIncomesResponse[]>);
    getVaultInfo: ((params: {
        address: string;
    }) => Promise<IVaultInfoResponse>);
    getVaultPurchases: ((params: {
        limit?: number;
        offset?: number;
        user_address?: string;
        vault_address?: string;
    }) => Promise<IVaultPurchasesResponse[]>);
    getVaultRedeems: ((params: {
        limit?: number;
        offset?: number;
        user_address?: string;
        vault_address?: string;
    }) => Promise<IVaultRedeemsResponse[]>);
    getVaults: ((params?: {
        owner: string;
    }) => Promise<IVaultResponse[]>);
    indexPrice: ((params: {
        symbol: string;
    }) => Promise<IIndexPriceResponse>);
    liquidablePositions: ((params: {
        symbol?: string;
    }) => Promise<ILiquidableAblePositionsResponse[]>);
    liquidated: ((params: {
        address?: string;
        limit?: number;
        offset?: number;
    }) => Promise<ILiquidatedResponse[]>);
    liquidator: ((params: {
        address?: string;
        limit?: number;
        offset?: number;
    }) => Promise<ILiquidatorResponse[]>);
    specs: (() => Promise<ISpecResponse[]>);
    vaultShare: ((params: {
        user_address: string;
        vault_address: string;
    }) => Promise<IVaultShareResponse>);
    vaultShares: ((params: {
        limit?: number;
        offset?: number;
        user_address?: string;
        vault_address?: string;
    }) => Promise<IVaultShareResponse[]>);
} = ...

Spidex public api

Type declaration

account: ((params: {
address: string;
}, headers?: IHeadersParams) => Promise<IAccoutResponse>)
- - (params: {
    address: string;
    }, headers?: IHeadersParams): Promise<IAccoutResponse>
  - Get account
    
    Example
```
await spidex.private.account({
 address,
})
```
    Parameters
    - params: {
      address: string;
      }
      
      address: string
    - Optional headers: IHeadersParams
    Returns Promise<IAccoutResponse>
compileDsl: ((params: {
dsl_code: string;
}) => Promise<ICompileDSLResponse>)
- - (params: {
    dsl_code: string;
    }): Promise<ICompileDSLResponse>
  - Compile DSL
    
    Compile DSL script into contract binary
    
    Example
```
await spidex.public.compileDsl({
  dsl_code: '',
})
```
    Parameters
    - params: {
      dsl_code: string;
      }
      
      dsl_code: string
    Returns Promise<ICompileDSLResponse>
getDeals: ((params: {
limit?: number;
symbol: string;
}) => Promise<IDealResponse[]>)
- - (params: {
    limit?: number;
    symbol: string;
    }): Promise<IDealResponse[]>
  - Query Latest Deals
    
    Example
```
await spidex.public.getDeals({
  // ...params
})
```
    Parameters
    - params: {
      limit?: number;
      symbol: string;
      }
      
      Optional limit?: number
      
      symbol: string
    Returns Promise<IDealResponse[]>
getDepth: ((params: {
    address?: string;
    symbol: string;
    type?: string;
}) => Promise<IDepthData>)
- - (params: {
        address?: string;
        symbol: string;
        type?: string;
    }): Promise<IDepthData>
  - Query Depth
    
    Query market depth
    
    Example
```
await spidex.public.getDepth({
  symbol: 'BTCUSDC',
  address?: spidex.config.currentAccount,
})
```
    Parameters
    - params: {
          address?: string;
          symbol: string;
          type?: string;
      }
      
      Optional address?: string
      
      symbol: string
      
      Optional type?: string
    Returns Promise<IDepthData>
getKlines: ((params: {
    endTime?: string;
    interval: IIterval;
    limit?: number;
    startTime?: string;
    symbol: string;
}) => Promise<IKlineDataItem[]>)
- - (params: {
        endTime?: string;
        interval: IIterval;
        limit?: number;
        startTime?: string;
        symbol: string;
    }): Promise<IKlineDataItem[]>
  - Query KLines
    
    Query the market K line
    
    Example
```
await spidex.public.getKlines({
  // ...params
})
```
    Parameters
    - params: {
          endTime?: string;
          interval: IIterval;
          limit?: number;
          startTime?: string;
          symbol: string;
      }
      
      Optional endTime?: string
      
      interval: IIterval
      
      Optional limit?: number
      
      Optional startTime?: string
      
      symbol: string
    Returns Promise<IKlineDataItem[]>
getMarket: ((params: {
symbol: string;
}) => Promise<IMarketInfo>)
- - (params: {
    symbol: string;
    }): Promise<IMarketInfo>
  - Query Market Info
    
    Query market transaction information
    
    Example
```
await spidex.public.getMarket({
  symbol
})
```
    Parameters
    - params: {
      symbol: string;
      }
      
      symbol: string
    Returns Promise<IMarketInfo>
getMarkets: (() => Promise<IMarketsInfo>)
- - (): Promise<IMarketsInfo>
  - Query Markets Info
    
    Example
```
await spidex.public.getMarkets()
```
    Returns Promise<IMarketsInfo>
getTradeVolumes: ((params: {
limit?: number;
}) => Promise<ITradeVolumesResponse[]>)
- - (params: {
    limit?: number;
    }): Promise<ITradeVolumesResponse[]>
  - Query Trade Volumes
    
    Example
```
await spidex.public.getTradeVolumes({
 limit
})
```
    Parameters
    - params: {
      limit?: number;
      }
      
      Optional limit?: number
    Returns Promise<ITradeVolumesResponse[]>
getVaultIncomes: ((params: {
    address: string;
    interval: string;
    limit?: number;
}) => Promise<IVaultIncomesResponse[]>)
- - (params: {
        address: string;
        interval: string;
        limit?: number;
    }): Promise<IVaultIncomesResponse[]>
  - Query Vault Incomes
    
    Example
```
await spidex.public.getVaultIncomes({
  address: '',
  interval: '1h',
  limit: 100,
})
```
    Parameters
    - params: {
          address: string;
          interval: string;
          limit?: number;
      }
      
      address: string
      
      interval: string
      
      Optional limit?: number
    Returns Promise<IVaultIncomesResponse[]>
getVaultInfo: ((params: {
address: string;
}) => Promise<IVaultInfoResponse>)
- - (params: {
    address: string;
    }): Promise<IVaultInfoResponse>
  - Query Vault Detail
    
    Example
```
await spidex.public.getVaultInfo({
  address: ''
})
```
    Parameters
    - params: {
      address: string;
      }
      
      address: string
    Returns Promise<IVaultInfoResponse>
getVaultPurchases: ((params: {
    limit?: number;
    offset?: number;
    user_address?: string;
    vault_address?: string;
}) => Promise<IVaultPurchasesResponse[]>)
- - (params: {
        limit?: number;
        offset?: number;
        user_address?: string;
        vault_address?: string;
    }): Promise<IVaultPurchasesResponse[]>
  - Query vault purchases
    
    Example
```
await spidex.public.getVaultDeposits({
  vault_address: '',
  user_address: '',
  offset: 0,
  limit: 10,
})
```
    Parameters
    - params: {
          limit?: number;
          offset?: number;
          user_address?: string;
          vault_address?: string;
      }
      
      Optional limit?: number
      
      Optional offset?: number
      
      Optional user_address?: string
      
      Optional vault_address?: string
    Returns Promise<IVaultPurchasesResponse[]>
getVaultRedeems: ((params: {
    limit?: number;
    offset?: number;
    user_address?: string;
    vault_address?: string;
}) => Promise<IVaultRedeemsResponse[]>)
- - (params: {
        limit?: number;
        offset?: number;
        user_address?: string;
        vault_address?: string;
    }): Promise<IVaultRedeemsResponse[]>
  - Query vault redeems
    
    Example
```
await spidex.public.getVaultRedeems({
  vault_address: '',
  user_address: '',
  offset: 0,
  limit: 10,
})
```
    Parameters
    - params: {
          limit?: number;
          offset?: number;
          user_address?: string;
          vault_address?: string;
      }
      
      Optional limit?: number
      
      Optional offset?: number
      
      Optional user_address?: string
      
      Optional vault_address?: string
    Returns Promise<IVaultRedeemsResponse[]>
getVaults: ((params?: {
owner: string;
}) => Promise<IVaultResponse[]>)
- - (params?: {
    owner: string;
    }): Promise<IVaultResponse[]>
  - Query Vaults Info
    
    Query transaction vault information
    
    Example
```
await spidex.public.getVaults({
  // ...params
})
```
    Parameters
    - Optional params: {
      owner: string;
      }
      
      owner: string
    Returns Promise<IVaultResponse[]>
indexPrice: ((params: {
symbol: string;
}) => Promise<IIndexPriceResponse>)
- - (params: {
    symbol: string;
    }): Promise<IIndexPriceResponse>
  - Query symbol index price
    
    Example
```
await spidex.public.indexPrice({
  symbol: '',
})
```
    Parameters
    - params: {
      symbol: string;
      }
      
      symbol: string
    Returns Promise<IIndexPriceResponse>
liquidablePositions: ((params: {
symbol?: string;
}) => Promise<ILiquidableAblePositionsResponse[]>)
- - (params: {
    symbol?: string;
    }): Promise<ILiquidableAblePositionsResponse[]>
  - Query liquidable able positions
    
    Example
```
await spidex.public.liquidablePositions({
  symbol,
})
```
    Parameters
    - params: {
      symbol?: string;
      }
      
      Optional symbol?: string
    Returns Promise<ILiquidableAblePositionsResponse[]>
liquidated: ((params: {
    address?: string;
    limit?: number;
    offset?: number;
}) => Promise<ILiquidatedResponse[]>)
- - (params: {
        address?: string;
        limit?: number;
        offset?: number;
    }): Promise<ILiquidatedResponse[]>
  - Query liquidated
    
    Example
```
await spidex.public.liquidated({
  address,
  limit,
  offset
})
```
    Parameters
    - params: {
          address?: string;
          limit?: number;
          offset?: number;
      }
      
      Optional address?: string
      
      Optional limit?: number
      
      Optional offset?: number
    Returns Promise<ILiquidatedResponse[]>
liquidator: ((params: {
    address?: string;
    limit?: number;
    offset?: number;
}) => Promise<ILiquidatorResponse[]>)
- - (params: {
        address?: string;
        limit?: number;
        offset?: number;
    }): Promise<ILiquidatorResponse[]>
  - Query liquidator
    
    Example
```
await spidex.public.liquidator({
  address,
  limit,
  offset
})
```
    Parameters
    - params: {
          address?: string;
          limit?: number;
          offset?: number;
      }
      
      Optional address?: string
      
      Optional limit?: number
      
      Optional offset?: number
    Returns Promise<ILiquidatorResponse[]>
specs: (() => Promise<ISpecResponse[]>)
- - (): Promise<ISpecResponse[]>
  - Get specs
    
    Example
```
await spidex.public.specs()
```
    Returns Promise<ISpecResponse[]>
vaultShare: ((params: {
user_address: string;
vault_address: string;
}) => Promise<IVaultShareResponse>)
- - (params: {
    user_address: string;
    vault_address: string;
    }): Promise<IVaultShareResponse>
  - Get vault shares
    
    Example
```
await spidex.public.vaultShare({
  vault_address,
  user_address,
})
```
    Parameters
    - params: {
      user_address: string;
      vault_address: string;
      }
      
      user_address: string
      
      vault_address: string
    Returns Promise<IVaultShareResponse>
vaultShares: ((params: {
    limit?: number;
    offset?: number;
    user_address?: string;
    vault_address?: string;
}) => Promise<IVaultShareResponse[]>)
- - (params: {
        limit?: number;
        offset?: number;
        user_address?: string;
        vault_address?: string;
    }): Promise<IVaultShareResponse[]>
  - Get vault shares
    
    Example
```
await spidex.public.vaultShares({
  vault_address,
  offset,
  limit
})
```
    Parameters
    - params: {
          limit?: number;
          offset?: number;
          user_address?: string;
          vault_address?: string;
      }
      
      Optional limit?: number
      
      Optional offset?: number
      
      Optional user_address?: string
      
      Optional vault_address?: string
    Returns Promise<IVaultShareResponse[]>

rpc

rpc: ((options: IRPCOptions) => Promise<IRPCResponse>) = getRpc

Type declaration

- (options: IRPCOptions): Promise<IRPCResponse>
- Spidex rpc api
  Parameters
  - options: IRPCOptions
  Returns Promise<IRPCResponse>

utils

utils: {
    ABIdecode: {
        abiFuncParams: ((inputs: any, circle?: boolean) => string | string[]);
        addABI: ((abiArray: any[] | ConcatArray<never>) => void);
        decodeAddressLogs: ((address: string) => Promise<any[]>);
        decodeLog: ((logItem: {
            addressHash: string;
            data: string;
            firstTopic: string;
            fourthTopic?: string;
            secondTopic?: string;
            thirdTopic?: string;
        }) => any);
        decodeLogs: ((logs: any[]) => any[]);
        decodeMethod: ((data: string) => undefined | {
            data: any;
            inputs: string | string[];
            name: any;
            outputs: any;
            params: any;
        });
        decodeTopic: ((abi: any[], data: string, topics: string[]) => {
            [key: string]: string;
        });
        getABIs: (() => any);
        getMethodIDs: (() => any);
        removeABI: ((abiArray: any[]) => void);
    };
    decimal: typeof DecimalUtil;
    ethToSpx: ((ethAddress: string, prefix?: string) => string);
    getHeadersParams: ((method: ISignMethod, requestPath: IRequestPath, params: any, timestamp?: string) => IHeadersParams);
    getPrivateKey: ((options: {
        domainData?: IDomainData;
        provider: provider;
        signer: string;
    }) => Promise<string>);
    getTimestamp: (() => string);
    isValidBech32Address: ((bech32Prefix: string, address: string) => boolean);
    pickData: ((data: undefined | string | Record<string, any>) => undefined | string | Record<string, any>);
    sign: ((options: {
        contract?: string;
        domainData?: IDomainData;
        message: string | Record<string, any>;
        primaryType: IPrimaryType;
        provider?: provider;
        signer?: string;
        signingMethod?: ISigningTypeMethod;
    }) => Promise<string>);
    signHmac: ((timestamp: string, method: ISignMethod, requestPath: IRequestPath, data: string | Record<string, any>, secret?: string) => string);
    signKey: ((options: {
        contract?: string;
        domainData?: IDomainData;
        message: string | Record<string, any>;
        primaryType: IPrimaryType;
        provider?: provider;
        signer: string;
        version?: SignTypedDataVersion;
    }) => string);
    spxToEth: ((spxAddress: string, prefix?: string) => any);
    uuid: ((len: number, radix?: number) => string);
} = ...

Spidex utils

Type declaration

ABIdecode: {
    abiFuncParams: ((inputs: any, circle?: boolean) => string | string[]);
    addABI: ((abiArray: any[] | ConcatArray<never>) => void);
    decodeAddressLogs: ((address: string) => Promise<any[]>);
    decodeLog: ((logItem: {
        addressHash: string;
        data: string;
        firstTopic: string;
        fourthTopic?: string;
        secondTopic?: string;
        thirdTopic?: string;
    }) => any);
    decodeLogs: ((logs: any[]) => any[]);
    decodeMethod: ((data: string) => undefined | {
        data: any;
        inputs: string | string[];
        name: any;
        outputs: any;
        params: any;
    });
    decodeTopic: ((abi: any[], data: string, topics: string[]) => {
        [key: string]: string;
    });
    getABIs: (() => any);
    getMethodIDs: (() => any);
    removeABI: ((abiArray: any[]) => void);
}
- abiFuncParams: ((inputs: any, circle?: boolean) => string | string[])
  - - (inputs: any, circle?: boolean): string | string[]
    - Parameters
      
      inputs: any
      
      circle: boolean = false
      Returns string | string[]
- addABI: ((abiArray: any[] | ConcatArray<never>) => void)
  - - (abiArray: any[] | ConcatArray<never>): void
    - Parameters
      
      abiArray: any[] | ConcatArray<never>
      Returns void
- decodeAddressLogs: ((address: string) => Promise<any[]>)
  - - (address: string): Promise<any[]>
    - Parameters
      
      address: string
      Returns Promise<any[]>
- decodeLog: ((logItem: {
      addressHash: string;
      data: string;
      firstTopic: string;
      fourthTopic?: string;
      secondTopic?: string;
      thirdTopic?: string;
  }) => any)
  - - (logItem: {
          addressHash: string;
          data: string;
          firstTopic: string;
          fourthTopic?: string;
          secondTopic?: string;
          thirdTopic?: string;
      }): any
    - Parameters
      
      logItem: {
          addressHash: string;
          data: string;
          firstTopic: string;
          fourthTopic?: string;
          secondTopic?: string;
          thirdTopic?: string;
      }
      
      addressHash: string
      
      data: string
      
      firstTopic: string
      
      Optional fourthTopic?: string
      
      Optional secondTopic?: string
      
      Optional thirdTopic?: string
      Returns any
- decodeLogs: ((logs: any[]) => any[])
  - - (logs: any[]): any[]
    - Parameters
      
      logs: any[]
      Returns any[]
- decodeMethod: ((data: string) => undefined | {
      data: any;
      inputs: string | string[];
      name: any;
      outputs: any;
      params: any;
  })
  - - (data: string): undefined | {
          data: any;
          inputs: string | string[];
          name: any;
          outputs: any;
          params: any;
      }
    - Parameters
      
      data: string
      Returns undefined | {
          data: any;
          inputs: string | string[];
          name: any;
          outputs: any;
          params: any;
      }
- decodeTopic: ((abi: any[], data: string, topics: string[]) => {
  [key: string]: string;
  })
  - - (abi: any[], data: string, topics: string[]): {
      [key: string]: string;
      }
    - Parameters
      
      abi: any[]
      
      data: string
      
      topics: string[]
      Returns {
      [key: string]: string;
      }
      - [key: string]: string
- getABIs: (() => any)
  - - (): any
    - Returns any
- getMethodIDs: (() => any)
  - - (): any
    - Returns any
- removeABI: ((abiArray: any[]) => void)
  - - (abiArray: any[]): void
    - Parameters
      
      abiArray: any[]
      Returns void
decimal: typeof DecimalUtil
ethToSpx: ((ethAddress: string, prefix?: string) => string)
- - (ethAddress: string, prefix?: string): string
  - Parameters
    - ethAddress: string
    - prefix: string = 'spx'
    Returns string
getHeadersParams: ((method: ISignMethod, requestPath: IRequestPath, params: any, timestamp?: string) => IHeadersParams)
- - (method: ISignMethod, requestPath: IRequestPath, params: any, timestamp?: string): IHeadersParams
  - Parameters
    - method: ISignMethod
    - requestPath: IRequestPath
    - params: any
    - Optional timestamp: string
    Returns IHeadersParams
getPrivateKey: ((options: {
    domainData?: IDomainData;
    provider: provider;
    signer: string;
}) => Promise<string>)
- - (options: {
        domainData?: IDomainData;
        provider: provider;
        signer: string;
    }): Promise<string>
  - Parameters
    - options: {
          domainData?: IDomainData;
          provider: provider;
          signer: string;
      }
      
      Optional domainData?: IDomainData
      
      provider: provider
      
      signer: string
    Returns Promise<string>
getTimestamp: (() => string)
- - (): string
  - Returns string
isValidBech32Address: ((bech32Prefix: string, address: string) => boolean)
- - (bech32Prefix: string, address: string): boolean
  - Parameters
    - bech32Prefix: string
    - address: string
    Returns boolean
pickData: ((data: undefined | string | Record<string, any>) => undefined | string | Record<string, any>)
- - (data: undefined | string | Record<string, any>): undefined | string | Record<string, any>
  - Get the value is not '' 、 undefined or null of object.
    
    Returns
    Parameters
    - data: undefined | string | Record<string, any>
    Returns undefined | string | Record<string, any>
sign: ((options: {
    contract?: string;
    domainData?: IDomainData;
    message: string | Record<string, any>;
    primaryType: IPrimaryType;
    provider?: provider;
    signer?: string;
    signingMethod?: ISigningTypeMethod;
}) => Promise<string>)
- - (options: {
        contract?: string;
        domainData?: IDomainData;
        message: string | Record<string, any>;
        primaryType: IPrimaryType;
        provider?: provider;
        signer?: string;
        signingMethod?: ISigningTypeMethod;
    }): Promise<string>
  - Parameters
    - options: {
          contract?: string;
          domainData?: IDomainData;
          message: string | Record<string, any>;
          primaryType: IPrimaryType;
          provider?: provider;
          signer?: string;
          signingMethod?: ISigningTypeMethod;
      }
      
      Optional contract?: string
      
      Optional domainData?: IDomainData
      
      message: string | Record<string, any>
      
      primaryType: IPrimaryType
      
      Optional provider?: provider
      
      Optional signer?: string
      
      Optional signingMethod?: ISigningTypeMethod
    Returns Promise<string>
signHmac: ((timestamp: string, method: ISignMethod, requestPath: IRequestPath, data: string | Record<string, any>, secret?: string) => string)
- - (timestamp: string, method: ISignMethod, requestPath: IRequestPath, data: string | Record<string, any>, secret?: string): string
  - Parameters
    - timestamp: string
    - method: ISignMethod
    - requestPath: IRequestPath
    - data: string | Record<string, any>
    - secret: string = ''
    Returns string
signKey: ((options: {
    contract?: string;
    domainData?: IDomainData;
    message: string | Record<string, any>;
    primaryType: IPrimaryType;
    provider?: provider;
    signer: string;
    version?: SignTypedDataVersion;
}) => string)
- - (options: {
        contract?: string;
        domainData?: IDomainData;
        message: string | Record<string, any>;
        primaryType: IPrimaryType;
        provider?: provider;
        signer: string;
        version?: SignTypedDataVersion;
    }): string
  - Parameters
    - options: {
          contract?: string;
          domainData?: IDomainData;
          message: string | Record<string, any>;
          primaryType: IPrimaryType;
          provider?: provider;
          signer: string;
          version?: SignTypedDataVersion;
      }
      
      Optional contract?: string
      
      Optional domainData?: IDomainData
      
      message: string | Record<string, any>
      
      primaryType: IPrimaryType
      
      Optional provider?: provider
      
      signer: string
      
      Optional version?: SignTypedDataVersion
    Returns string
spxToEth: ((spxAddress: string, prefix?: string) => any)
- - (spxAddress: string, prefix?: string): any
  - Parameters
    - spxAddress: string
    - prefix: string = 'spx'
    Returns any
uuid: ((len: number, radix?: number) => string)
- - (len: number, radix?: number): string
  - Parameters
    - len: number
    - radix: number = 62
    Returns string

web3

web3: {
getRevertReason: ((txHash: string) => Promise<undefined | string>);
} = ...

web3 tools

Type declaration

getRevertReason: ((txHash: string) => Promise<undefined | string>)
- - (txHash: string): Promise<undefined | string>
  - Parameters
    - txHash: string
    Returns Promise<undefined | string>

ws

ws: (() => string) = websocket

Type declaration

- (): string
- Spidex websocket
  
  Returns string

Accessors

app

get app(): {
link: undefined | string;
name: undefined | string;
}
app info

Returns {
link: undefined | string;
name: undefined | string;
}
- link: undefined | string
- name: undefined | string
- Defined in src/client.ts:135

chain

get chain(): {
osmosis: any;
spidex: any;
}
osmosis and spidex chain config

Returns {
osmosis: any;
spidex: any;
}
- osmosis: any
- spidex: any
- Defined in src/client.ts:373

client

get client(): any
spidex ignite client

Returns any
- Defined in src/client.ts:359

configs

get configs(): {
    dev: {
        apiUrl: string;
        appLink: string;
        cluster: string;
        cosmosChainId: string;
        cosmosRest: string;
        cosmosRpc: string;
        explorerGraphql: string;
        explorerRest: string;
        explorerUrl: string;
        explorerWebsocket: string;
        faucetUrl: string;
        grpcRpc: string;
        name: string;
        osmosisRest: string;
        osmosisRpc: string;
        rpcApi: string;
        spidexChainId: string;
        websocketApi: string;
    };
    devnet: {
        apiUrl: string;
        appLink: string;
        cluster: string;
        cosmosChainId: string;
        cosmosRest: string;
        cosmosRpc: string;
        explorerGraphql: string;
        explorerRest: string;
        explorerUrl: string;
        explorerWebsocket: string;
        faucetUrl: string;
        grpcRpc: string;
        name: string;
        osmosisRest: string;
        osmosisRpc: string;
        rpcApi: string;
        spidexChainId: string;
        websocketApi: string;
    };
    mainnet: {
        apiUrl: string;
        appLink: string;
        cluster: string;
        cosmosChainId: string;
        cosmosRest: string;
        cosmosRpc: string;
        explorerGraphql: string;
        explorerRest: string;
        explorerUrl: string;
        explorerWebsocket: string;
        faucetUrl: string;
        grpcRpc: string;
        name: string;
        osmosisRest: string;
        osmosisRpc: string;
        rpcApi: string;
        spidexChainId: string;
        websocketApi: string;
    };
    testnet: {
        apiUrl: string;
        appLink: string;
        cluster: string;
        cosmosChainId: string;
        cosmosRest: string;
        cosmosRpc: string;
        explorerGraphql: string;
        explorerRest: string;
        explorerUrl: string;
        explorerWebsocket: string;
        faucetUrl: string;
        grpcRpc: string;
        name: string;
        osmosisRest: string;
        osmosisRpc: string;
        rpcApi: string;
        spidexChainId: string;
        websocketApi: string;
    };
}
spidex configs

Returns {
    dev: {
        apiUrl: string;
        appLink: string;
        cluster: string;
        cosmosChainId: string;
        cosmosRest: string;
        cosmosRpc: string;
        explorerGraphql: string;
        explorerRest: string;
        explorerUrl: string;
        explorerWebsocket: string;
        faucetUrl: string;
        grpcRpc: string;
        name: string;
        osmosisRest: string;
        osmosisRpc: string;
        rpcApi: string;
        spidexChainId: string;
        websocketApi: string;
    };
    devnet: {
        apiUrl: string;
        appLink: string;
        cluster: string;
        cosmosChainId: string;
        cosmosRest: string;
        cosmosRpc: string;
        explorerGraphql: string;
        explorerRest: string;
        explorerUrl: string;
        explorerWebsocket: string;
        faucetUrl: string;
        grpcRpc: string;
        name: string;
        osmosisRest: string;
        osmosisRpc: string;
        rpcApi: string;
        spidexChainId: string;
        websocketApi: string;
    };
    mainnet: {
        apiUrl: string;
        appLink: string;
        cluster: string;
        cosmosChainId: string;
        cosmosRest: string;
        cosmosRpc: string;
        explorerGraphql: string;
        explorerRest: string;
        explorerUrl: string;
        explorerWebsocket: string;
        faucetUrl: string;
        grpcRpc: string;
        name: string;
        osmosisRest: string;
        osmosisRpc: string;
        rpcApi: string;
        spidexChainId: string;
        websocketApi: string;
    };
    testnet: {
        apiUrl: string;
        appLink: string;
        cluster: string;
        cosmosChainId: string;
        cosmosRest: string;
        cosmosRpc: string;
        explorerGraphql: string;
        explorerRest: string;
        explorerUrl: string;
        explorerWebsocket: string;
        faucetUrl: string;
        grpcRpc: string;
        name: string;
        osmosisRest: string;
        osmosisRpc: string;
        rpcApi: string;
        spidexChainId: string;
        websocketApi: string;
    };
}
- dev: {
      apiUrl: string;
      appLink: string;
      cluster: string;
      cosmosChainId: string;
      cosmosRest: string;
      cosmosRpc: string;
      explorerGraphql: string;
      explorerRest: string;
      explorerUrl: string;
      explorerWebsocket: string;
      faucetUrl: string;
      grpcRpc: string;
      name: string;
      osmosisRest: string;
      osmosisRpc: string;
      rpcApi: string;
      spidexChainId: string;
      websocketApi: string;
  }
  - apiUrl: string
  - appLink: string
  - cluster: string
  - cosmosChainId: string
  - cosmosRest: string
  - cosmosRpc: string
  - explorerGraphql: string
  - explorerRest: string
  - explorerUrl: string
  - explorerWebsocket: string
  - faucetUrl: string
  - grpcRpc: string
  - name: string
  - osmosisRest: string
  - osmosisRpc: string
  - rpcApi: string
  - spidexChainId: string
  - websocketApi: string
- devnet: {
      apiUrl: string;
      appLink: string;
      cluster: string;
      cosmosChainId: string;
      cosmosRest: string;
      cosmosRpc: string;
      explorerGraphql: string;
      explorerRest: string;
      explorerUrl: string;
      explorerWebsocket: string;
      faucetUrl: string;
      grpcRpc: string;
      name: string;
      osmosisRest: string;
      osmosisRpc: string;
      rpcApi: string;
      spidexChainId: string;
      websocketApi: string;
  }
  - apiUrl: string
  - appLink: string
  - cluster: string
  - cosmosChainId: string
  - cosmosRest: string
  - cosmosRpc: string
  - explorerGraphql: string
  - explorerRest: string
  - explorerUrl: string
  - explorerWebsocket: string
  - faucetUrl: string
  - grpcRpc: string
  - name: string
  - osmosisRest: string
  - osmosisRpc: string
  - rpcApi: string
  - spidexChainId: string
  - websocketApi: string
- mainnet: {
      apiUrl: string;
      appLink: string;
      cluster: string;
      cosmosChainId: string;
      cosmosRest: string;
      cosmosRpc: string;
      explorerGraphql: string;
      explorerRest: string;
      explorerUrl: string;
      explorerWebsocket: string;
      faucetUrl: string;
      grpcRpc: string;
      name: string;
      osmosisRest: string;
      osmosisRpc: string;
      rpcApi: string;
      spidexChainId: string;
      websocketApi: string;
  }
  - apiUrl: string
  - appLink: string
  - cluster: string
  - cosmosChainId: string
  - cosmosRest: string
  - cosmosRpc: string
  - explorerGraphql: string
  - explorerRest: string
  - explorerUrl: string
  - explorerWebsocket: string
  - faucetUrl: string
  - grpcRpc: string
  - name: string
  - osmosisRest: string
  - osmosisRpc: string
  - rpcApi: string
  - spidexChainId: string
  - websocketApi: string
- testnet: {
      apiUrl: string;
      appLink: string;
      cluster: string;
      cosmosChainId: string;
      cosmosRest: string;
      cosmosRpc: string;
      explorerGraphql: string;
      explorerRest: string;
      explorerUrl: string;
      explorerWebsocket: string;
      faucetUrl: string;
      grpcRpc: string;
      name: string;
      osmosisRest: string;
      osmosisRpc: string;
      rpcApi: string;
      spidexChainId: string;
      websocketApi: string;
  }
  - apiUrl: string
  - appLink: string
  - cluster: string
  - cosmosChainId: string
  - cosmosRest: string
  - cosmosRpc: string
  - explorerGraphql: string
  - explorerRest: string
  - explorerUrl: string
  - explorerWebsocket: string
  - faucetUrl: string
  - grpcRpc: string
  - name: string
  - osmosisRest: string
  - osmosisRpc: string
  - rpcApi: string
  - spidexChainId: string
  - websocketApi: string
- Defined in src/client.ts:331

contracts

get contracts(): IContracts
contracts

Returns IContracts
- Defined in src/client.ts:383

store

get store(): Store
Spidex store for Node.js and Browser.

Returns Store
- Defined in src/client.ts:366

Methods

getIgnite

getIgnite(): any
Returns any
- Defined in src/client.ts:335

initConfig

initConfig(options: IClientConfig): void
The spidex.initConfig is required by spidex.utils.sign for spidex.private POST APIs.
Parameters
- options: IClientConfig
Returns void
- Defined in src/client.ts:392

`Static` getInstance

getInstance(): Client
Returns Client
- Defined in src/client.ts:320

Class Client

Example

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

options: IClientConfig = ...

Returns Client

Properties

api

Type declaration

baseApi: (() => string)

Returns string

baseRpcApi: (() => string)

Returns string

cosmosRestApi: (() => string)

Returns string

cosmosRpcApi: (() => string)

Returns string

explorerGraphqlApi: (() => string)

Returns string

explorerRestApi: (() => string)

Returns string

explorerWebsocketApi: (() => string)

Returns string

osmosisRestApi: (() => string)

Returns string

osmosisRpcApi: (() => string)

Returns string

websocketApi: (() => string)

Returns string

auth

Type declaration

createApiKey: ((params: { SPIDEX-ADDRESS: string; SPIDEX-SIGNATURE: string; SPIDEX-TIMESTAMP?: string; }) => Promise<{ key: string; passphrase: string; secret: string; }>)

Example

Parameters

params: { SPIDEX-ADDRESS: string; SPIDEX-SIGNATURE: string; SPIDEX-TIMESTAMP?: string; }

SPIDEX-ADDRESS: string

SPIDEX-SIGNATURE: string

Optional SPIDEX-TIMESTAMP?: string

Returns Promise<{ key: string; passphrase: string; secret: string; }>

onBoarding: ((params: { derived_pub: string; referee_address?: string; }, headers: IHeadersParams2) => Promise<{ key: string; passphrase: string; secret: string; }>)

Example

Parameters

params: { derived_pub: string; referee_address?: string; }

derived_pub: string

Optional referee_address?: string

headers: IHeadersParams2

Returns Promise<{ key: string; passphrase: string; secret: string; }>

config

cosmos

Type declaration

rest: ((options: ICosmosRESTOptions) => Promise<any>)

Parameters

options: ICosmosRESTOptions

Returns Promise<any>

rpc: ((options: ICosmosRPCOptions) => Promise<IRPCResponse>)

Parameters

options: ICosmosRPCOptions

Returns Promise<IRPCResponse>

osmosis

Type declaration

rest: ((options: IOsmosisRESTOptions) => Promise<any>)

Parameters

options: IOsmosisRESTOptions

Returns Promise<any>

rpc: ((options: IOsmosisRPCOptions) => Promise<IRPCResponse>)

Parameters

options: IOsmosisRPCOptions

Returns Promise<IRPCResponse>

private

Remarks

Type declaration

account: ((params: { address: string; }, headers?: IHeadersParams) => Promise<IAccoutResponse>)

Example

createApiKey: ((params: {
SPIDEX-ADDRESS: string;
SPIDEX-SIGNATURE: string;
SPIDEX-TIMESTAMP?: string;
}) => Promise<{
key: string;
passphrase: string;
secret: string;
}>)

params: {
SPIDEX-ADDRESS: string;
SPIDEX-SIGNATURE: string;
SPIDEX-TIMESTAMP?: string;
}

`Optional` SPIDEX-TIMESTAMP?: string

Returns Promise<{
key: string;
passphrase: string;
secret: string;
}>

onBoarding: ((params: {
derived_pub: string;
referee_address?: string;
}, headers: IHeadersParams2) => Promise<{
key: string;
passphrase: string;
secret: string;
}>)

params: {
derived_pub: string;
referee_address?: string;
}

`Optional` referee_address?: string

Returns Promise<{
key: string;
passphrase: string;
secret: string;
}>

account: ((params: {
address: string;
}, headers?: IHeadersParams) => Promise<IAccoutResponse>)

params: {
address: string;
}

`Optional` headers: IHeadersParams

cancelOrder: ((params: {
order_hash: string;
}, headers?: IHeadersParams) => Promise<any>)

params: {
order_hash: string;
}

`Optional` headers: IHeadersParams

createApiKey: ((params: {
SPIDEX-ADDRESS: string;
SPIDEX-SIGNATURE: string;
SPIDEX-TIMESTAMP?: string;
}) => Promise<{
key: string;
passphrase: string;
secret: string;
}>)

params: {
SPIDEX-ADDRESS: string;
SPIDEX-SIGNATURE: string;
SPIDEX-TIMESTAMP?: string;
}

`Optional` SPIDEX-TIMESTAMP?: string

Returns Promise<{
key: string;
passphrase: string;
secret: string;
}>

createOrder: ((params: {
amount: string;
expiration: number;
price: string;
salt: number;
side: string;
signature: string;
symbol: string;
timestamp?: string;
type: string;
vault_address?: string;
}, headers?: IHeadersParams) => Promise<Record<string, unknown>>)

params: {
amount: string;
expiration: number;
price: string;
salt: number;
side: string;
signature: string;
symbol: string;
timestamp?: string;
type: string;
vault_address?: string;
}

`Optional` timestamp?: string

`Optional` vault_address?: string

`Optional` headers: IHeadersParams

deleteApiKeys: ((headers?: {
SPIDEX-ADDRESS: string;
SPIDEX-SIGNATURE: string;
SPIDEX-TIMESTAMP: string;
}) => Promise<string>)

`Optional` headers: {
SPIDEX-ADDRESS: string;
SPIDEX-SIGNATURE: string;
SPIDEX-TIMESTAMP: string;
}

depositMargin: ((params: {
amount: string;
pos_address: string;
salt: number;
signature: string;
symbol: string;
timestamp: string;
}, headers?: IHeadersParams) => Promise<{
tx_hash: string;
}>)

params: {
amount: string;
pos_address: string;
salt: number;
signature: string;
symbol: string;
timestamp: string;
}

`Optional` headers: IHeadersParams

Returns Promise<{
tx_hash: string;
}>

fundingRecords: ((params?: {
limit?: number;
offset?: number;
pos_address: string;
symbol?: string;
}, headers?: IHeadersParams) => Promise<IFundingRecordsResponse[]>)

`Optional` params: {
limit?: number;
offset?: number;
pos_address: string;
symbol?: string;
}

`Optional` limit?: number

`Optional` offset?: number

`Optional` symbol?: string

`Optional` headers: IHeadersParams

`Optional` headers: IHeadersParams