@equilab/api

    1.8.3 • Public • Published

    EQUILIBRIUM API

    API bindings to access Equilibruim substrate queries and transactions
    NOTE Typescript bindings included

    Equilibrium node list

    • Mainnet node: wss://node.equilibrium.io
    • Testnet node: wss://testnet.equilibrium.io (this node implements latest features)

    Genshiro node list

    • Testnet node: wss://testnet.genshiro.io (this node implements latest features)

    Getting started

    $ npm i --save @equilab/api     # if you are using npm or  
    $ yarn add @equilab/api         # for yarn package manager  
    
    ## Usage
    
    ### API Init  
    
    Use *getApiCreator(nodeSpec: "Eq" | "EqNext" | "Genshiro")* factory from __@equilab/api__ package  
    ```typescript
    import { getApiCreator } from "@equilab/api";  
    
    (async () => { // async/await usage
      /*
       * nodeSpec can be either 
       * "Eq" for mainnet node,
       * or "EqNext" for testnet node,
       * or "Gens" for genshiro nodes
       */
    
      // Connect to mainnet node with websocket
      const api = await getApiCreator("Eq")("wss://node.equilibrium.io");
      // do the interaction below
      const balance = await api.getBalance("YOUR_ADDRESS", "EQ"); // get EQ tokens
      console.log(balance.toJSON());
    })();
    
    createApi("wss://tge.equilibrium.io:9944")
      .then(api => api.getBalance("YOUR_ADDRESS", "EQ"))
      .then(balance => console.log(balance.toJSON())); // Promise usage

    Types

    type UserGroup = "Unknown" | "Balances" | "Bailsmen" | "Borrowers" | "Lenders";
    type UnsubscribePromise = Promise<() => void /* call this func to unsubscribe */>;
    
    interface SignedBalance {
      readonly isPositive: boolean;
      readonly asPositive: Balance;
      readonly isNegative: boolean;
      readonly asNegative: Balance;
    }
    
    interface DataPoint {
      price: u64;
      account_id: AccountId;
      block_number: BlockNumber;
      timestamp: u64;
    }
    
    interface PricePoint {
      block_number: BlockNumber;
      timestamp: u64;
      price: u64;
      data_points: Vec<DataPoint>;
    }
    
    /**
     * In order to get asset:
     * 
     * import { tokenToAsset } from "@equilab/api";
     * const asset = tokenToAsset("Btc");
     */
    
    interface Asset {
      0: u64;
    }
    
    /**
     * Use Currency only on current version of mainnet
     * 
     * @deprecated
     */
    type Currency = "Unknown" | "Usd" | "EQ" | "Eth" | "Btc" | "Eos" | "Dot";

    API Methods

    getAccounts(): Promise<string[]>

    Fetch list of addresses in system

    getBlockHash(blockNumber: number): Promise<Hash>

    Fetch hash of block by its number

    subscribeNewBlockHeads(blockHandler: (header: BlockHeader) => Promise<void> | void): UnsubscribePromise

    Retrieves the best finalized header via subscription

    setSigner(signer: Signer): void

    Sets transaction signer, can be used with injected wallet

    multi(calls: QueryableStorageMultiArg<"promise">[], callback: (result: Codec[]) => void | Promise<void>): UnsubscribePromise

    Allows for the querying of multiple storage entries and the combination thereof into a single result. This is a very optimal way to make multiple queries since it only makes a single connection to the node and retrieves the data over one subscription. Refer to multiple queries section of polkadot.js api docs

    getNonce(address: string): Promise<Index>

    Fetch next available nonce for this address

    API Storage queries

    Storage queries are compliant with Polkadot.JS storage interfaces

    getBalance(key1: AccountId, key2: Asset): Promise<SignedBalance>

    Pallet storage - balances for all accounts

    getRate(key: Asset): Promise<PricePoint>

    Pallet storage for added price points

    getVested(key: AccountId): Promise<BalanceOf>

    Pallet storage: information about already vested balances for given account

    getVesting(key: AccountId): Promise<VestingInfo>

    Pallet storage: information regarding the vesting of a given account

    getClaim(key: EthereumAddress): Promise<BalanceOf>

    Pallet storage - stores amount to be claimed by each EthereumAddress

    getClaimSigning(key: EthereumAddress): Promise<bool>

    Pallet storage - stores Ethereum addresses from which additional statement
    singing is required

    getClaimVesting(key: EthereumAddress): Promise<(BalanceOf,BalanceOf,BlockNumber)>

    Pallet storage - vesting schedule for a claim.
    First balance is the total amount that should be held for vesting.
    Second balance is how much should be unlocked per block.
    The block number is when the vesting should start.

    getTotalClaim(): Promise<BalanceOf>

    Pallet storage - total Claims amount

    hasGroup(key1: UserGroup, key2: AccountId): Promise<bool>

    aggregatesByGroup(key1: UserGroup, key2: Asset): Promise<TotalAggregates>

    Pallet storage - stores aggregates for each user group

    getAddress(key1: AccountId, key2: SubAccType): Promise<AccountId>

    Pallet storage - double map storing subaccounts as AccountId where
    user's main AccountId and SubAccType used as keys

    getOwner(key: AccountId): Promise<(AccountId,SubAccType)>

    Pallet storage - a map storing a tuple (AccountId, SubAccType)
    for each existing subaccount. First element in stored tuple is
    AccountId of main user account, owning the subaccount and second
    is SubAccType of key subaccount

    getMetrics(): Promise<FinancialMetrics>

    Financial metrics for all known assets.

    getLocks(key: AccountId): Promise<Balance>

    Pallet storage - accounts locks

    getLockTime(): Promise<u64>

    Pallet storage - start of lock program.
    Value is UnixTime timestamp in seconds

    getPool(key: PoolId): Promise<PoolInfo>

    Existing pools

    API Transaction methods

    Transaction methods are compliant with Polkadot.JS transaction interfaces

    batch(calls: Vec,): SubmittableExtrinsic

    Send a batch of dispatch calls.

    May be called from any origin.

    • calls: The calls to be dispatched from the same origin.

    If origin is root then call are dispatch without checking origin filter. (This includes
    bypassing frame_system::Config::BaseCallFilter).

    • Complexity: O(C) where C is the number of calls to be batched.

    This will return Ok in all circumstances. To determine the success of the batch, an
    event is deposited. If a call failed and the batch was interrupted, then the
    BatchInterrupted event is deposited, along with the number of successful calls made
    and the error of the failed call. If all were successful, then the BatchCompleted
    event is deposited.

    sudo(call: Call,): SubmittableExtrinsic

    Authenticates the sudo key and dispatches a function call with Root origin.

    The dispatch origin for this call must be Signed.

    • O(1).
    • Limited storage reads.
    • One DB write (event).
    • Weight of derivative call execution + 10,000.

    setPrice(asset: Asset,price: FixedI64,): SubmittableExtrinsic

    Adds new DataPoint containing asset price information. It
    would be used for PricePoint calculation. Only whitelisted
    accounts can add DataPoints

    vest(): SubmittableExtrinsic

    Unlock any vested funds of the sender account.

    The dispatch origin for this call must be Signed and the sender must have funds still
    locked under this module.

    Emits either VestingCompleted or VestingUpdated.

    vestTo(target: LookupSource,): SubmittableExtrinsic

    Unlock any vested funds of a target account.

    The dispatch origin for this call must be Signed.

    • target: The account whose vested funds should be unlocked. Must have funds still
      locked under this module.

    Emits either VestingCompleted or VestingUpdated.

    claim(dest: AccountId,ethereum_signature: EcdsaSignature,): SubmittableExtrinsic

    Make a claim to collect your currency.

    The dispatch origin for this call must be None.

    Unsigned Validation:
    A call to claim is deemed valid if the signature provided matches
    the expected signed message of:

    Ethereum Signed Message:
    (configured prefix string)(address)

    and address matches the dest account.

    Parameters:

    • dest: The destination account to payout the claim.
    • ethereum_signature: The signature of an ethereum signed message
      matching the format described above.

    claimAttest(dest: AccountId,ethereum_signature: EcdsaSignature,statement: Bytes,): SubmittableExtrinsic

    Make a claim to collect your currency by signing a statement.

    The dispatch origin for this call must be None.

    Unsigned Validation:
    A call to claim_attest is deemed valid if the signature provided matches
    the expected signed message of:

    Ethereum Signed Message:
    (configured prefix string)(address)(statement)

    and address matches the dest account; the statement must match that which is
    expected according to your purchase arrangement.

    Parameters:

    • dest: The destination account to payout the claim.
    • ethereum_signature: The signature of an ethereum signed message
      matching the format described above.
    • statement: The identity of the statement which is being attested to in the signature.

    withdrawExternal(amount: Balance,recipient: Bytes,dest_id: ChainId,resource_id: ResourceId,): SubmittableExtrinsic

    Transfers some amount of the native token to some recipient on a (whitelisted) destination chain.
    Charges fee and accumulates it on the special account.

    lockdrop(amount: Balance,): SubmittableExtrinsic

    Lock amount of Eq for lock

    curveExchange(pool_id: PoolId,i: PoolTokenIndex,j: PoolTokenIndex,dx: Balance,min_dy: Balance,): SubmittableExtrinsic

    Perform an exchange between two coins.
    i - index value of the coin to send,
    j - index value of the coin to recieve,
    dx - amount of i being exchanged,
    min_dy - minimum amount of j to receive.

    curveAdd(pool_id: PoolId,amounts: Vec,min_mint_amount: Balance,): SubmittableExtrinsic

    Deposit coins into the pool
    amounts - list of amounts of coins to deposit,
    min_mint_amount - minimum amout of LP tokens to mint from the deposit.

    curveRemove(pool_id: PoolId,amount: Balance,min_amounts: Vec,): SubmittableExtrinsic

    Withdraw coins from the pool.
    Withdrawal amount are based on current deposit ratios.
    amount - quantity of LP tokens to burn in the withdrawal,
    min_amounts - minimum amounts of underlying coins to receive.

    curveRemoveImbalance(pool_id: PoolId,amounts: Vec,max_burn_amount: Balance,): SubmittableExtrinsic

    Withdraw coins from the pool in an imbalanced amount.
    amounts - list of amounts of underlying coins to withdraw,
    max_burn_amount - maximum amount of LP token to burn in the withdrawal.

    curveRemoveOne(pool_id: PoolId,token_amount: Balance,i: PoolTokenIndex,min_amount: Balance,): SubmittableExtrinsic

    Withdraw a single coin from the pool.
    token_amount - amount of LP tokens to burn in the withdrawal,
    i - index value of the coin to withdraw,
    min_amount - minimum amount of coin to receive.

    Keywords

    none

    Install

    npm i @equilab/api

    DownloadsWeekly Downloads

    233

    Version

    1.8.3

    License

    MIT

    Unpacked Size

    2.54 MB

    Total Files

    219

    Last publish

    Collaborators

    • eosdtadmin