@ocap/client 1.6.3 → 1.6.10

package/lib/extension.js

@@ -1,17 +1,27 @@
 'use strict';
 
+/* eslint-disable prefer-object-spread */
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable object-curly-newline */
 const get = require('lodash/get');
+const omit = require('lodash/omit');
+const cloneDeep = require('lodash/cloneDeep');
 const camelCase = require('lodash/camelCase');
-const snakeCase = require('lodash/snakeCase');
-const padStart = require('lodash/padStart');
-const errorCodes = require('@ocap/proto/lib/gen/status-code.json');
-const { isValid: isValidDID, toTypeInfo } = require('@arcblock/did');
-const { toDelegateAddress, toSwapAddress, toAssetAddress } = require('@arcblock/did-util');
-const { transactions, typeUrls, multiSignTxs } = require('@ocap/proto');
-const { createMessage, getMessageType, decodeAny } = require('@ocap/message');
+const { toTypeInfo, isValid } = require('@arcblock/did');
+const { transactions, typeUrls, multiSignTxs, multiSignV2Txs } = require('@ocap/proto');
+const { createMessage, getMessageType, toTypeUrl } = require('@ocap/message');
 const { bytesToHex, toBase58, toBase64, toHex, toBuffer, fromTokenToUnit, fromUnitToToken } = require('@ocap/util');
+const { DEFAULT_TOKEN_DECIMAL } = require('@ocap/util/lib/constant');
+const { formatFactoryState, preMintFromFactory, isValidFactory } = require('@ocap/asset');
+const {
+  toDelegateAddress,
+  toAssetAddress,
+  toFactoryAddress,
+  toTokenAddress,
+  toStakeAddress,
+  toRollupAddress
+} = require('@arcblock/did-util');
+
 const debug = require('debug')(require('../package.json').name);
 
 /**
@@ -22,6 +32,14 @@ const debug = require('debug')(require('../package.json').name);
  * @param {object} [{ encodeTxAsBase64 = false }={}]
  */
 const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
+  Object.defineProperty(client, 'ctx', {
+    value: {
+      loading: false,
+      ready: false,
+      callbacks: []
+    }
+  });
+
   /**
    * Format big number presentation amount to token number
    *
@@ -32,7 +50,7 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
    * @returns {string}
    */
   client.fromUnitToToken = async value => {
-    const { token } = await client._ensureContext();
+    const { token } = await client.getContext();
     return fromUnitToToken(value, token.decimal);
   };
 
@@ -46,36 +64,13 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
    * @returns {BN}
    */
   client.fromTokenToUnit = async amount => {
-    const { token } = await client._ensureContext();
+    const { token } = await client.getContext();
     return fromTokenToUnit(amount, token.decimal);
   };
 
-  /**
-   * Converts a relative locktime to absolute locktime
-   *
-   * @memberof GraphQLClient
-   * @function
-   * @name GraphQLClient#toLocktime
-   * @param {number} number - number of blocks want to lock
-   * @param {object} [options={}] - options to underlying methods
-   * @returns {number}
-   */
-  client.toLocktime = async number => {
-    const result = await client.doRawQuery(`{
-      getChainInfo {
-        code
-        info {
-          blockHeight
-        }
-      }
-    }`);
-
-    return +get(result, 'getChainInfo.info.blockHeight', 0) + number;
-  };
-
   /**
    * List all transaction send methods
-   * Each method can send one kind of transactions supported by forge core, such as `DeclareTx`, `PokeTx`
+   * Each method can send one kind of transactions supported by forge core, such as `DeclareTx`
    *
    * @memberof GraphQLClient
    * @function
@@ -112,7 +107,7 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
    * @name GraphQLClient#getTxMultiSignMethods
    * @returns {Array<string>} method name list
    */
-  client.getTxMultiSignMethods = () => multiSignTxs.map(x => camelCase(`multi_sign_${x}`));
+  client.getTxMultiSignMethods = () => multiSignTxs.concat(multiSignV2Txs).map(x => camelCase(`multi_sign_${x}`));
 
   /**
    * Get protobuf message class by name, only supports forge-built-in types
@@ -139,17 +134,6 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
     return Transaction.deserializeBinary(toBuffer(input)).toObject();
   };
 
-  if (typeof client._createResponseError !== 'function') {
-    client._createResponseError = (code, method) => {
-      const type = snakeCase(method);
-      const message = (errorCodes[code][type] || errorCodes[code].default || code).trim();
-      const error = new Error(`${code}: ${message}`);
-      error.code = code;
-      error.type = type;
-      return error;
-    };
-  }
-
   /**
    * Ensure a connection is bootstrapped with some meta info fetched from chain node
    *
@@ -157,50 +141,97 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
    * @param {string} [conn=undefined]
    * @returns {object}
    */
-  client._ensureContext = async () => {
-    if (!client.context) {
-      if (encodeTxAsBase64) {
-        const result = await client.doRawQuery(`{
-          getChainInfo {
-            code
-            info {
-              network
-            }
+  client.getContext = async () => {
+    if (client.ctx.ready) {
+      return client.context;
+    }
+
+    if (client.ctx.loading) {
+      return new Promise(resolve => {
+        client.ctx.callbacks.push(() => resolve(client.context));
+      });
+    }
+
+    client.ctx.loading = true;
+    const result = await client.doRawQuery(`{
+      getChainInfo {
+        code
+        info {
+          network
+          consensusVersion
+        }
+      }
+      getForgeState {
+        code
+        state {
+          token {
+            decimal
+            symbol
           }
-          getForgeState {
-            code
-            state {
-              token {
-                decimal
-                symbol
-              }
-              txConfig {
-                poke {
-                  amount
-                  dailyLimit
-                  enabled
-                }
-              }
+          txConfig {
+            txFee {
+              fee
+              typeUrl
             }
           }
-        }`);
+        }
+      }
+    }`);
+
+    client.context = {
+      chainId: get(result, 'getChainInfo.info.network'),
+      consensus: get(result, 'getChainInfo.info.consensusVersion'),
+      token: get(result, 'getForgeState.state.token'),
+      txConfig: get(result, 'getForgeState.state.txConfig'),
+      tokenStateMap: new Map()
+    };
 
-        client.context = {
-          chainId: get(result, 'getChainInfo.info.network'),
-          token: get(result, 'getForgeState.state.token'),
-          poke: get(result, 'getForgeState.state.txConfig.poke')
-        };
+    client.ctx.ready = true;
+    client.ctx.loading = false;
+    client.ctx.callbacks.forEach(cb => cb());
+    debug('context ready');
+
+    return client.context;
+  };
+
+  client.getTokenStateMap = async addressList => {
+    const result = new Map();
+    const notExistAddressList = [];
+    addressList.forEach(address => {
+      if (client.context.tokenStateMap.has(address)) {
+        result.set(address, client.context.tokenStateMap.get(address));
       } else {
-        const [{ state }, { info }] = await Promise.all([client.getForgeState(), client.getChainInfo()]);
-        client.context = {
-          chainId: info.network,
-          token: state.token,
-          poke: state.txConfig.poke
-        };
+        notExistAddressList.push(address);
       }
+    });
+
+    if (result.size === addressList.length) {
+      return result;
     }
 
-    return client.context;
+    const getTokenState = async address => {
+      const {
+        getTokenState: { code, state }
+      } = await client.doRawQuery(`{
+        getTokenState(address: "${address}") {
+          code
+          state {
+            decimal
+          }
+        }
+      }`);
+
+      if (code !== 'OK') {
+        throw new Error(`get token ${address} state failed`);
+      }
+
+      result.set(address, state);
+      client.context.tokenStateMap.set(address, state);
+    };
+
+    await Promise.all(notExistAddressList.map(address => getTokenState(address)));
+
+    return result;
   };
 
   // Unify a client wallet | forge managed wallet
@@ -214,7 +245,7 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
 
     if (typeof wallet.toAddress === 'function') {
       return {
-        address: wallet.toAddress(),
+        address: wallet.address,
         publicKey: wallet.publicKey
       };
     }
@@ -236,14 +267,15 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
      * @param {object} [input.tx.from] - the sender address, can be derived from wallet
      * @param {object} [input.tx.nonce] - the tx nonce, defaults to Date.now if not set
      * @param {object} [input.tx.chainId] - the chainId
-     * @param {object} [input.tx.signature] - the chainId
-     * @param {object} [input.tx.signatures] - the chainId
-     * @param {object} input.wallet - the wallet used to sign the transaction, either a forge managed wallet or user managed wallet
+     * @param {object} [input.tx.signature] - the signature
+     * @param {object} [input.tx.signatures] - the signature list
+     * @param {object} input.wallet - the wallet used to sign the transaction
      * @param {object} input.delegator - the wallet address that delegated permissions to the `input.wallet` address
      * @returns Promise
      */
     const txEncodeFn = async ({ tx, wallet, delegator }) => {
       const w = getWallet(wallet);
+      const context = await client.getContext();
 
       // Determine sender address
       const address = tx.from || w.address;
@@ -251,9 +283,8 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
 
       // Determine chainId & nonce, only attach new one when not exist
       const nonce = typeof tx.nonce === 'undefined' ? Date.now() : tx.nonce;
-      let chainId = tx.chainId || (client.context ? client.context.chainId : '');
+      let chainId = tx.chainId || '';
       if (!chainId) {
-        const context = await client._ensureContext();
         // eslint-disable-next-line prefer-destructuring
         chainId = context.chainId;
       }
@@ -277,6 +308,9 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
         itx = { type: x, value: tx.itx };
       }
 
+      const type = itx.typeUrl || toTypeUrl(itx.type);
+      const feeConfig = get(context, 'txConfig.txFee', []).find(t => t.typeUrl === type);
+
       const txObj = createMessage('Transaction', {
         from: tx.delegator ? address : delegator || address,
         nonce,
@@ -285,7 +319,8 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
         signature: tx.signature || Buffer.from([]),
         signatures,
         delegator: tx.delegator || (delegator ? address : ''),
-        itx
+        itx,
+        serviceFee: feeConfig ? feeConfig.fee : '0'
       });
       const txToSignBytes = txObj.serializeBinary();
 
@@ -346,16 +381,6 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
             resolve(hash);
           }
         } catch (err) {
-          if (Array.isArray(err.errors)) {
-            const code = err.errors[0].message;
-            if (errorCodes[code]) {
-              const error = client._createResponseError(code, x);
-              error.errors = err.errors;
-              reject(error);
-              return;
-            }
-          }
-
           reject(err);
         }
       });
@@ -410,13 +435,13 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
           tx.signaturesList.unshift({
             pk: wallet.publicKey,
             signer: delegator,
-            delegator: wallet.toAddress(),
+            delegator: wallet.address,
             data
           });
         } else {
           tx.signaturesList.unshift({
             pk: wallet.publicKey,
-            signer: wallet.toAddress(),
+            signer: wallet.address,
             delegator: '',
             data
           });
@@ -430,6 +455,31 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
       txMultiSignFn.__tx__ = multiSignMethod;
       client[multiSignMethod] = txMultiSignFn;
     }
+
+    if (multiSignV2Txs.includes(x)) {
+      const txMultiSignFn = async ({ tx, wallet, encoding = '' }) => {
+        if (typeof wallet.toAddress !== 'function') {
+          throw new Error('Multisig requires a valid wallet');
+        }
+
+        const signer = wallet.address;
+        const signatures = cloneDeep(tx.signatures || tx.signaturesList || []);
+        const item = signatures.find(s => s.signer === signer || s.delegator === signer);
+        if (!item) {
+          throw new Error('Signer not in the list');
+        }
+
+        tx.signaturesList = signatures.map(s => omit(s, ['signature']));
+        const { object, buffer } = await txEncodeFn({ tx, wallet });
+
+        item.signature = wallet.sign(bytesToHex(buffer));
+        object.signaturesList = signatures;
+        return _formatEncodedTx(object, encoding);
+      };
+      const multiSignMethod = camelCase(`multi_sign_${x}`);
+      txMultiSignFn.__tx__ = multiSignMethod;
+      client[multiSignMethod] = txMultiSignFn;
+    }
   });
 
   /**
@@ -450,9 +500,8 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
     let itxData = data;
 
     // If there is no data attached to the account, we can attach wallet type by default
-    const typeData = wallet.type;
-    if (!itxData && typeData) {
-      itxData = { typeUrl: 'json', value: toTypeInfo(typeData, true) };
+    if (!itxData) {
+      itxData = { typeUrl: 'json', value: toTypeInfo(wallet.address, true) };
     }
 
     return client.sendDeclareTx({
@@ -463,53 +512,6 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
     }, extra);
   };
 
-  /**
-   * Prepare an declare transaction when the chain has enabled restricted declare
-   *
-   * @memberof GraphQLClient
-   * @function
-   * @name GraphQLClient#prepareDeclare
-   * @param {object} params
-   * @param {string} params.moniker - account moniker
-   * @param {string} params.issuer - issuer address
-   * @param {string} params.delegator - the delegator address
-   * @param {WalletObject} params.wallet - the wallet that want to do the declare
-   * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `transaction` object once resolved
-   */
-  client.prepareDeclare = async ({ moniker, issuer, wallet, data, delegator = '' }, extra) => client.signDeclareTx({
-    tx: {
-      itx: {
-        moniker,
-        issuer,
-        data
-      }
-    },
-    delegator,
-    wallet
-  }, extra);
-
-  /**
-   * Finalize an declare transaction using the issuer's account
-   *
-   * @memberof GraphQLClient
-   * @function
-   * @name GraphQLClient#finalizeExchange
-   * @param {object} params
-   * @param {object} params.tx - the transaction object from `prepareExchange`
-   * @param {string} params.delegator - who authorized this transaction
-   * @param {object} params.data - extra data in the multi sig
-   * @param {WalletObject} params.wallet - issuer's wallet
-   * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `transaction` object once resolved
-   */
-  client.finalizeDeclare = ({ tx, delegator = '', data, wallet }, extra) => client.multiSignDeclareTx({
-    tx,
-    delegator,
-    data,
-    wallet
-  }, extra);
-
   /**
    * Migrate current account to a new account
    *
@@ -525,7 +527,7 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
   client.migrateAccount = ({ from, to }, extra) => client.sendAccountMigrateTx({
     tx: {
       itx: {
-        address: to.toAddress(),
+        address: to.address,
         pk: to.publicKey,
         type: to.type
       }
@@ -562,12 +564,12 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
       throw new Error('Invalid type url provided for delegation');
     }
 
-    const address = toDelegateAddress(from.toAddress(), to.toAddress());
+    const address = toDelegateAddress(from.address, to.address);
     const hash = await client.sendDelegateTx({
       tx: {
         itx: {
           address,
-          to: to.toAddress(),
+          to: to.address,
           ops
         }
       },
@@ -593,8 +595,8 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
   client.revokeDelegate = ({ from, to, privileges }, extra) => client.sendRevokeDelegateTx({
     tx: {
       itx: {
-        address: toDelegateAddress(from.toAddress(), to.toAddress()),
-        to: to.toAddress(),
+        address: toDelegateAddress(from.address, to.address),
+        to: to.address,
         typeUrls: privileges.filter(Boolean).map(x => x.toString())
       }
     },
@@ -614,13 +616,28 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
    * @param {number} params.ttl - ttl after first consumption
    * @param {boolean} params.readonly - whether the asset can be updated after creation
    * @param {boolean} params.transferrable - whether the asset can be transferred to another account
+   * @param {object} params.display - the display of the asset
+   * @param {object} params.endpoint - the endpoint of the asset
+   * @param {string} params.tags - the tag list of the asset
    * @param {string} params.delegator - who authorized this transaction
    * @param {WalletObject} params.wallet - the initial owner of the asset
    * @param {object} extra - other param to underlying client implementation
    * @returns {Promise} the `[transactionHash, assetAddress]` once resolved
    */
-  client.createAsset = async ({ moniker, parent = '', ttl = 0, data, readonly = false, transferrable = true, delegator = '', wallet }, extra) => {
-    const payload = { moniker, parent, ttl, readonly, transferrable, data };
+  client.createAsset = async ({
+    moniker,
+    parent = '',
+    ttl = 0,
+    data,
+    readonly = false,
+    transferrable = true,
+    display,
+    endpoint,
+    tags = [],
+    delegator = '',
+    wallet
+  }, extra) => {
+    const payload = { moniker, parent, ttl, readonly, transferrable, data, display, endpoint, tags };
     const address = toAssetAddress(payload);
     payload.address = address;
     const hash = await client.sendCreateAssetTx({
@@ -641,12 +658,11 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
    * @param {string} params.address - asset address
    * @param {string} params.moniker - asset name
    * @param {object} params.data - asset data payload
-   * @param {string} params.delegator - who authorized this transaction
    * @param {WalletObject} params.wallet - the wallet to sign the transaction
    * @param {object} extra - other param to underlying client implementation
    * @returns {Promise} the `transactionHash` once resolved
    */
-  client.updateAsset = ({ address, moniker, data, delegator, wallet }, extra) => client.sendUpdateAssetTx({
+  client.updateAsset = ({ address, moniker, data, wallet }, extra) => client.sendUpdateAssetTx({
     tx: {
       itx: {
         moniker,
@@ -654,344 +670,369 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
         data
       }
     },
-    delegator,
     wallet
   }, extra);
 
   /**
-   * Prepare a transaction that consumes an asset (non-fungible-token)
+   * Create an asset factory that can be used to mint new assets in future transactions
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#prepareConsumeAsset
+   * @name GraphQLClient#createAssetFactory
    * @param {object} params
-   * @param {string} params.issuer - issuer address
-   * @param {string} params.address - parent address
-   * @param {object} params.data - extra data payload
-   * @param {string} params.delegator - who authorized this transaction
-   * @param {WalletObject} params.wallet - the wallet to sign the transaction
+   * @param {string} params.factory - asset factory
+   * @param {WalletObject} params.wallet - the initial owner of the asset
    * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `transactionHash` once resolved
+   * @returns {Promise} the `[transactionHash, factoryAddress]` once resolved
    */
-  client.prepareConsumeAsset = ({ issuer = '', address = '', delegator = '', data, wallet }, extra) => client.signConsumeAssetTx({
-    tx: {
-      itx: {
-        issuer,
-        address,
-        data
-      }
-    },
-    delegator,
-    wallet
-  }, extra);
+  client.createAssetFactory = async ({ factory, wallet }, extra) => {
+    const itx = {
+      name: factory.name,
+      description: factory.description,
+      settlement: factory.settlement || 'instant',
+      limit: factory.limit || 0,
+      trustedIssuers: factory.trustedIssuers || [],
+      input: factory.input,
+      output: factory.output,
+      data: factory.data || null,
+      hooks: factory.hooks || [],
+      display: factory.display || null
+    };
+
+    isValidFactory(itx, true);
+
+    itx.address = toFactoryAddress(itx);
+
+    const hash = await client.sendCreateFactoryTx({ tx: { itx }, wallet }, extra);
+    return [hash, itx.address];
+  };
 
   /**
-   * Prepare a transaction that consumes an asset (non-fungible-token)
+   * Prepare an acquire_asset itx
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#finalizeConsumeAsset
+   * @name GraphQLClient#preMintAsset
    * @param {object} params
-   * @param {object} params.tx - transaction to finalize, should be result from `prepareConsumeAsset`
-   * @param {string} params.address - asset address to be consumed
-   * @param {string} params.delegator - who authorized this transaction
-   * @param {WalletObject} params.wallet - the wallet to sign the transaction
-   * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `transactionHash` once resolved
+   * @param {string} params.factory - asset factory address
+   * @param {object} params.inputs - factory inputs
+   * @param {string} params.owner - who will own the asset
+   * @param {WalletObject} params.wallet - the wallet of the asset issuer
+   * @param {object} extra - other param to merge into the itx
+   * @returns {Promise} the `[transactionHash, factoryAddress]` once resolved
    */
-  client.finalizeConsumeAsset = ({ tx, address, delegator, wallet }, extra) => {
-    if (isValidDID(address) === false) {
-      throw new Error('Please provide valid asset address to consume');
+  client.preMintAsset = async ({ factory, inputs = {}, owner, wallet, extra = {} }) => {
+    const options = { ignoreFields: ['context.genesisTx', 'context.renaissanceTx'] };
+    const [{ state: factoryState }, { state: issuerState }] = await Promise.all([client.getFactoryState({ address: factory }, options), client.getAccountState({ address: wallet.address }, options)]);
+
+    if (!factoryState) {
+      throw new Error('Factory does not exist on chain');
     }
 
-    return client.multiSignConsumeAssetTx({
-      tx,
-      wallet,
-      delegator,
-      data: {
-        typeUrl: 'fg:x:address',
-        value: Uint8Array.from(Buffer.from(address))
-      }
-    }, extra);
+    if (!issuerState) {
+      throw new Error('Issuer does not exist on chain');
+    }
+
+    const { asset, address, issuer, variables } = preMintFromFactory({
+      factory: formatFactoryState(factoryState),
+      inputs,
+      owner,
+      issuer: { wallet, name: issuerState.moniker }
+    });
+
+    return Object.assign({}, extra, {
+      asset: Object.assign({ address, owner, parent: factory }, asset),
+      factory,
+      address,
+      variables: Object.entries(variables).map(([key, value]) => ({ name: key, value })),
+      issuer,
+      owner
+    });
   };
 
   /**
-   * Send a transaction that consumes an asset (non-fungible-token)
+   * Acquire an asset from factory
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#consumeAsset
+   * @name GraphQLClient#acquireAsset
    * @param {object} params
-   * @param {object} params.tx - transaction to send, should be result from `finalizeConsumeAsset`
-   * @param {WalletObject} params.wallet - the wallet to sign the transaction
+   * @param {AcquireAssetV2Tx} params.itx - result from preMintAsset
+   * @param {string} params.delegator - who authorized this transaction
+   * @param {WalletObject} params.wallet - the initial owner of the asset
    * @param {object} extra - other param to underlying client implementation
    * @returns {Promise} the `transactionHash` once resolved
    */
-  client.consumeAsset = ({ tx, wallet }, extra) => client.sendConsumeAssetTx({ tx, wallet }, extra);
+  client.acquireAsset = ({ itx, delegator = '', wallet }, extra) => client.sendAcquireAssetV2Tx({ tx: { itx }, delegator, wallet }, extra);
 
   /**
-   * Create an asset factory that can be used to produce multiple assets in a transaction
+   * Mint an asset from factory
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#createAssetFactory
+   * @name GraphQLClient#mintAsset
    * @param {object} params
-   * @param {string} params.moniker - asset name
-   * @param {object} params.factory - asset factory attributes
-   * @param {string} params.factory.description - asset factory name
-   * @param {number} params.factory.limit - how many assets can be generated from this factory
-   * @param {price} params.factory.price - how much should charge user when acquire asset
-   * @param {string} params.factory.template - mustache compatible
-   * @param {Array} params.factory.templateVariables - list of allowed template variables
-   * @param {string} params.factory.assetName - protobuf type known to forge that can be used to create this asset
-   * @param {string} params.factory.attributes - attributes for assets that are generated from this factory
-   * @param {boolean} params.readonly - whether the asset can be updated after creation
-   * @param {boolean} params.transferrable - whether the asset can be transferred to another account
-   * @param {string} params.delegator - who authorized this transaction
+   * @param {MintAssetTx} params.itx - result from preMintAsset
    * @param {WalletObject} params.wallet - the initial owner of the asset
    * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `[transactionHash, factoryAddress]` once resolved
+   * @returns {Promise} the `transactionHash` once resolved
    */
-  client.createAssetFactory = async ({ moniker, factory, readonly = false, transferrable = true, delegator = '', wallet }, extra) => {
-    const payload = {
-      moniker,
-      readonly,
-      transferrable,
-      data: {
-        type: 'AssetFactory',
-        value: {
-          description: factory.description,
-          limit: factory.limit,
-          price: await client.fromTokenToUnit(factory.price),
-          template: factory.template,
-          allowedSpecArgs: factory.templateVariables,
-          assetName: factory.assetName,
-          // eslint-disable-next-line prefer-object-spread
-          attributes: Object.assign({ ttl: 0, transferrable: true }, factory.attributes || {})
-        }
-      }
-    };
-    const factoryAddress = toAssetAddress(payload);
-    payload.address = factoryAddress;
-
-    const hash = await client.sendCreateAssetTx({
-      tx: {
-        itx: payload
-      },
-      delegator,
-      wallet
-    }, extra);
-    return [hash, factoryAddress];
-  };
+  client.mintAsset = ({ itx, wallet }, extra) => client.sendMintAssetTx({ tx: { itx }, wallet }, extra);
 
   /**
-   * Acquire an asset from factory
+   * Transfer token or assets to another account
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#acquireAsset
+   * @name GraphQLClient#transfer
    * @param {object} params
-   * @param {string} params.assetFactory - Asset factory address
-   * @param {Array} params.assetVariables - list of asset variables that can be populated into asset factory template
-   * @param {boolean} params.readonly - whether the asset can be updated after creation, should match factory settings
-   * @param {boolean} params.transferrable - whether the asset can be transferred to another account, should match factory settings
-   * @param {number} params.ttl - asset expire
+   * @param {number} params.token - how much token can be transferred
+   * @param {Array} params.assets - which assets should be transferred
+   * @param {string} params.to - who receive the transfer
+   * @param {string} params.memo - transaction note
    * @param {string} params.delegator - who authorized this transaction
-   * @param {WalletObject} params.wallet - the initial owner of the asset
+   * @param {WalletObject} params.wallet - the wallet to sign the transaction
    * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `[transactionHash, [assetAddress]]` once resolved
+   * @returns {Promise} the `transactionHash` once resolved
    */
-  client.acquireAsset = async ({ assetFactory, assetVariables, delegator = '', wallet }, extra) => {
-    if (!assetFactory) {
-      throw new Error('Must specify asset factory address');
+  client.transfer = async ({ token = 0, assets = [], tokens = [], to = '', memo = '', delegator = '', wallet }, extra) => {
+    if (isValid(to) === false) {
+      throw new Error('Can not transfer without valid recipient');
     }
-    if (!Array.isArray(assetVariables)) {
-      throw new Error('Must specify at least on asset template variable');
+    if (!token && tokens.length === 0 && assets.length === 0) {
+      throw new Error('Can not transfer without payload');
     }
 
-    const { state } = await client.getAssetState({ address: assetFactory }, extra);
-    if (!state) {
-      throw new Error('Asset factory address does not exist on chain');
-    }
+    const { token: contextToken } = await client.getContext();
 
-    const decoded = decodeAny(state.data);
-    if (!decoded) {
-      throw new Error('Asset factory state cannot be decoded');
+    let tmpTokens = [];
+    if (tokens.length > 0) {
+      const tokensMap = await client.getTokenStateMap(tokens.map(t => t.address));
+      tmpTokens = tokens.map(t => {
+        t.value = fromTokenToUnit(t.value, tokensMap.get(t.address).decimal).toString();
+        return t;
+      });
     }
 
-    const factory = decoded.value;
-    debug('acquireAsset.factory', factory);
-
-    const assets = assetVariables.map(x => {
-      const payload = {
-        readonly: true,
-        transferrable: factory.attributes.transferrable,
-        ttl: factory.attributes.ttl,
-        parent: assetFactory,
-        data: {
-          type: factory.assetName,
-          value: x
-        }
-      };
-
-      const address = toAssetAddress(payload);
-
-      return { address, data: JSON.stringify(x) };
-    });
-
-    const hash = await client.sendAcquireAssetTx({
+    return client.sendTransferV2Tx({
       tx: {
         itx: {
-          to: assetFactory,
-          specs: assets
+          to,
+          value: fromTokenToUnit(token, contextToken.decimal),
+          assets,
+          tokens: tmpTokens,
+          data: {
+            typeUrl: 'json',
+            value: memo || 'empty'
+          }
         }
       },
       delegator,
       wallet
     }, extra);
-
-    return [hash, assets.map(x => x.address)];
   };
 
   /**
-   * Do an on-chain upgrade, should be used with forge-cli
+   * Stake token or assets for another account
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#upgradeNode
+   * @name GraphQLClient#stake
    * @param {object} params
-   * @param {number} params.height - at which height should the chain stop to perform the upgrade
-   * @param {string} params.version - to which version should upgrade to
-   * @param {string} params.delegator - who authorized this transaction
+   * @param {Array} params.assets - which assets to stake
+   * @param {Array} params.tokens - which tokens to stake
+   * @param {string} params.to - who receive the stake
+   * @param {string} params.locked - is the stake locked on creation
+   * @param {string} params.message - stake note
    * @param {WalletObject} params.wallet - the wallet to sign the transaction
    * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `transactionHash` once resolved
+   * @returns {Promise} the `transactionHash` and `stakeAddress` once resolved
    */
-  client.upgradeNode = ({ height, version, delegator, wallet }, extra) => client.sendUpgradeNodeTx({
-    tx: { itx: { height, version, override: true } },
-    delegator,
-    wallet
-  }, extra);
-
-  /**
-   * Setup a swap that's used to accomplish cross-chain operations
-   *
-   * @memberof GraphQLClient
-   * @function
-   * @name GraphQLClient#setupSwap
-   * @param {object} params
-   * @param {number} params.token - how much token to offer
-   * @param {Array} params.assets - how much assets to offer
-   * @param {string} params.receiver - who can retrieve this swap
-   * @param {string} params.hashlock - sha3 from hashkey
-   * @param {string} params.delegator - who authorized this transaction
-   * @param {number} [params.locktime=1000] - how much block height to lock the swap before it can be revoked
-   * @param {WalletObject} params.wallet - the wallet to sign the transaction
-   * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `[transactionHash, swapAddress]` once resolved
-   */
-  client.setupSwap = async ({
-    token = 0,
-    assets = [],
-    receiver = '',
-    hashlock = '',
-    locktime = 1000,
-    isLocktimeAbsolute = false,
-    delegator = '',
-    wallet
-  }, extra) => {
-    let finalLocktime = await client.toLocktime(locktime);
-    if (isLocktimeAbsolute) {
-      finalLocktime = locktime;
+  client.stake = async ({ assets = [], tokens = [], to = '', locked = false, message = '', wallet }, extra) => {
+    let tmpTokens = [];
+    if (tokens.length > 0) {
+      const tokensMap = await client.getTokenStateMap(tokens.map(t => t.address));
+      tmpTokens = tokens.map(t => {
+        t.value = fromTokenToUnit(t.value, tokensMap.get(t.address).decimal).toString();
+        return t;
+      });
     }
-    const hash = await client.sendSetupSwapTx({
+
+    const from = wallet.address;
+    const address = toStakeAddress(from, to);
+    let tx = await client.multiSignStakeTx({
       tx: {
         itx: {
-          value: await client.fromTokenToUnit(token),
-          assets,
-          receiver,
-          hashlock: toBuffer(hashlock),
-          locktime: finalLocktime
-        }
+          address,
+          receiver: to,
+          locked,
+          message,
+          inputs: [{
+            owner: from,
+            assets,
+            tokens: tmpTokens
+          }]
+        },
+        signatures: [{
+          signer: from,
+          pk: wallet.publicKey
+        }]
       },
-      delegator,
       wallet
     }, extra);
 
-    const address = toSwapAddress(`0x${hash}`);
+    tx = await client.signStakeTx({ tx, wallet });
+    const hash = await client.sendStakeTx({ tx, wallet }, extra);
     return [hash, address];
   };
 
   /**
-   * Retrieve a swap during an atomic-swap process
+   * Revoke token or assets from some stake
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#retrieveSwap
+   * @name GraphQLClient#revokeStake
    * @param {object} params
-   * @param {string} params.address - the swap address to retrieve
-   * @param {string} params.hashkey - the hashkey to unlock the swap
-   * @param {string} params.delegator - who authorized this transaction
+   * @param {Array} params.assets - which assets to stake
+   * @param {Array} params.tokens - which tokens to stake
+   * @param {string} params.from - stake address
    * @param {WalletObject} params.wallet - the wallet to sign the transaction
    * @param {object} extra - other param to underlying client implementation
    * @returns {Promise} the `transactionHash` once resolved
    */
-  client.retrieveSwap = ({ address, hashkey, delegator, wallet }, extra) => client.sendRetrieveSwapTx({
-    tx: { itx: { address, hashkey: toBuffer(hashkey) } },
-    delegator,
-    wallet
-  }, extra);
+  client.revokeStake = async ({ assets = [], tokens = [], from = '', wallet }, extra) => {
+    let tmpTokens = [];
+    if (tokens.length > 0) {
+      const tokensMap = await client.getTokenStateMap(tokens.map(t => t.address));
+      tmpTokens = tokens.map(t => {
+        t.value = fromTokenToUnit(t.value, tokensMap.get(t.address).decimal).toString();
+        return t;
+      });
+    }
+
+    return client.sendRevokeStakeTx({
+      tx: {
+        itx: {
+          address: from,
+          outputs: [{
+            owner: wallet.address,
+            assets,
+            tokens: tmpTokens
+          }]
+        }
+      },
+      wallet
+    }, extra);
+  };
 
   /**
-   * Revoke a swap during an atomic-swap process
+   * Claim revoked token or assets from stake
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#revokeSwap
+   * @name GraphQLClient#claimStake
    * @param {object} params
-   * @param {string} params.address - the swap address to revoke
-   * @param {string} params.delegator - who authorized this transaction
+   * @param {string} params.from - stake address
+   * @param {Array} params.evidence - which revoke tx hash to use
    * @param {WalletObject} params.wallet - the wallet to sign the transaction
    * @param {object} extra - other param to underlying client implementation
    * @returns {Promise} the `transactionHash` once resolved
    */
-  client.revokeSwap = ({ address, delegator, wallet }, extra) => client.sendRevokeSwapTx({
-    tx: { itx: { address } },
-    delegator,
-    wallet
-  }, extra);
+  client.claimStake = async ({ from, evidence, wallet }, extra) => {
+    if (!evidence) {
+      throw new Error('Can not claim stake without valid evidence tx hash');
+    }
+    if (!from) {
+      throw new Error('Can not claim stake without stake address');
+    }
+
+    return client.sendClaimStakeTx({
+      tx: {
+        itx: {
+          address: from,
+          evidence: { hash: evidence }
+        }
+      },
+      wallet
+    }, extra);
+  };
 
   /**
-   * Transfer token or assets to another account
+   * Create an rollup (sub-chain that lives in ocap)
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#transfer
+   * @name GraphQLClient#createRollup
    * @param {object} params
-   * @param {number} params.token - how much token can be transferred
-   * @param {Array} params.assets - which assets should be transferred
-   * @param {string} params.to - who receive the transfer
-   * @param {string} params.memo - transaction note
-   * @param {string} params.delegator - who authorized this transaction
-   * @param {WalletObject} params.wallet - the wallet to sign the transaction
+   * @param {string} params.tokenAddress - ocap token address
+   * @param {string} params.contractAddress - rollup contract address
+   * @param {string} params.minStakeAmount
+   * @param {string} params.maxStakeAmount
+   * @param {number} params.minSignerCount
+   * @param {number} params.maxSignerCount
+   * @param {number} params.minBlockSize
+   * @param {number} params.maxBlockSize
+   * @param {number} params.minBlockInterval - in seconds
+   * @param {number} params.minBlockConfirmation
+   * @param {number} params.leaveWaitingPeriod
+   * @param {number} params.publishWaitingPeriod
+   * @param {number} params.publishSlashRate
+   * @param {Array} params.seedValidators - list of seed validators
+   * @param {object} params.data - data payload
+   * @param {WalletObject} params.wallet - the initial owner of the asset
    * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `transactionHash` once resolved
+   * @returns {Promise} the `[transactionHash, rollupAddress]` once resolved
    */
-  client.transfer = async ({ token = 0, assets = [], to = '', memo = '', delegator = '', wallet }, extra) => client.sendTransferTx({
-    tx: {
-      itx: {
-        to,
-        value: await client.fromTokenToUnit(token),
-        assets,
-        data: {
-          typeUrl: 'json',
-          value: memo || 'empty'
-        }
+  client.createRollup = async (props, extra) => {
+    const requiredProps = ['tokenAddress', 'contractAddress', 'seedValidators', 'minStakeAmount'];
+    for (const key of requiredProps) {
+      if (!props[key]) {
+        throw new Error(`Missing required property: ${key} when creating rollup`);
       }
-    },
-    delegator,
-    wallet
-  }, extra);
+    }
+
+    const { state } = await client.getTokenState({ address: props.tokenAddress });
+    if (!state) {
+      throw new Error(`Token ${props.tokenAddress} not found when creating rollup`);
+    }
+    if (!state.foreignToken) {
+      throw new Error(`Token ${props.tokenAddress} does not have foreignToken attached`);
+    }
+
+    const toBNStr = n => fromTokenToUnit(n, state.decimal).toString(10);
+    const itx = Object.assign({
+      maxStakeAmount: props.minStakeAmount,
+      minSignerCount: 3,
+      maxSignerCount: 5,
+      minBlockSize: 1,
+      maxBlockSize: 10,
+      minBlockInterval: 1 * 60, // 1 minute
+      minBlockConfirmation: 3,
+      minDepositAmount: toBNStr(100),
+      maxDepositAmount: toBNStr(1000000),
+      minWithdrawAmount: toBNStr(100),
+      maxWithdrawAmount: toBNStr(1000000),
+      depositFeeRate: 100, // 1%
+      withdrawFeeRate: 100, // 1%
+      publisherFeeShare: 6000, // 60%
+      proposerFeeShare: 3000, // 30%
+      // validatorFeeShare: 1000, // 10%
+      minDepositFee: toBNStr(1),
+      maxDepositFee: toBNStr(10000),
+      minWithdrawFee: toBNStr(1),
+      maxWithdrawFee: toBNStr(10000),
+      leaveWaitingPeriod: 60 * 60, // 1 hour
+      publishWaitingPeriod: 60 * 60, // 1 hour
+      publishSlashRate: 10 // 0.1%
+    }, props);
+
+    const address = toRollupAddress(itx);
+    itx.address = address;
+
+    const hash = await client.sendCreateRollupTx({ tx: { itx }, wallet: props.wallet }, extra);
+
+    return [hash, address];
+  };
 
   /**
    * Prepare an exchange transaction between multiple accounts
@@ -1016,31 +1057,49 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
     offerAssets = [],
     demandToken = 0,
     demandAssets = [],
+    offerTokens = [],
+    demandTokens = [],
     receiver = '',
     memo = '',
     delegator = '',
     wallet
-  }, extra) => client.signExchangeTx({
-    tx: {
-      itx: {
-        to: receiver,
-        sender: {
-          value: await client.fromTokenToUnit(offerToken),
-          assets: Array.isArray(offerAssets) ? offerAssets : []
-        },
-        receiver: {
-          value: await client.fromTokenToUnit(demandToken),
-          assets: Array.isArray(demandAssets) ? demandAssets : []
-        },
-        data: {
-          typeUrl: 'json',
-          value: memo || 'empty'
+  }, extra) => {
+    const { token } = await client.getContext();
+    const tokensMap = await client.getTokenStateMap([...offerTokens, ...demandTokens].map(t => t.address));
+
+    const tmpOfferTokens = offerTokens.map(t => {
+      t.value = fromTokenToUnit(t.value, tokensMap.get(t.address).decimal).toString();
+      return t;
+    });
+    const tmpDemandTokens = demandTokens.map(t => {
+      t.value = fromTokenToUnit(t.value, tokensMap.get(t.address).decimal).toString();
+      return t;
+    });
+
+    return client.signExchangeV2Tx({
+      tx: {
+        itx: {
+          to: receiver,
+          sender: {
+            value: fromTokenToUnit(offerToken, token.decimal),
+            assets: Array.isArray(offerAssets) ? offerAssets : [],
+            tokens: tmpOfferTokens
+          },
+          receiver: {
+            value: fromTokenToUnit(demandToken, token.decimal),
+            assets: Array.isArray(demandAssets) ? demandAssets : [],
+            tokens: tmpDemandTokens
+          },
+          data: {
+            typeUrl: 'json',
+            value: memo || 'empty'
+          }
         }
-      }
-    },
-    delegator,
-    wallet
-  }, extra);
+      },
+      delegator,
+      wallet
+    }, extra);
+  };
 
   /**
    * Finalize an exchange transaction between multiple accounts
@@ -1056,12 +1115,7 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
    * @param {object} extra - other param to underlying client implementation
    * @returns {Promise} the `transaction` object once resolved
    */
-  client.finalizeExchange = ({ tx, delegator = '', data, wallet }, extra) => client.multiSignExchangeTx({
-    tx,
-    delegator,
-    data,
-    wallet
-  }, extra);
+  client.finalizeExchange = ({ tx, delegator = '', data, wallet }, extra) => client.multiSignExchangeV2Tx({ tx, delegator, data, wallet }, extra);
 
   /**
    * Send an exchange transaction
@@ -1075,65 +1129,51 @@ const createExtensionMethods = (client, { encodeTxAsBase64 = false } = {}) => {
    * @param {object} extra - other param to underlying client implementation
    * @returns {Promise} the `transactionHash` once resolved
    */
-  client.exchange = ({ tx, wallet }, extra) => client.sendExchangeTx({ tx, wallet }, extra);
+  client.exchange = ({ tx, wallet }, extra) => client.sendExchangeV2Tx({ tx, wallet }, extra);
 
   /**
-   * Send a poke transaction to get some token for free
+   * Create an new token
    *
    * @memberof GraphQLClient
    * @function
-   * @name GraphQLClient#checkin
+   * @name GraphQLClient#createToken
    * @param {object} params
-   * @param {WalletObject} params.wallet - the wallet to sign the transaction, also who will get the token
+   * @param {string} params.name
+   * @param {string} params.description
+   * @param {string} params.symbol
+   * @param {string} params.unit
+   * @param {string} params.icon
+   * @param {number} params.totalSupply
+   * @param {number} params.initialSupply
+   * @param {number} params.foreignToken
+   * @param {object} params.data - asset data payload
+   * @param {WalletObject} params.wallet - the initial owner of the asset
    * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `transactionHash` once resolved
+   * @returns {Promise} the `[transactionHash, assetAddress]` once resolved
    */
-  client.checkin = ({ wallet }, extra) => {
-    const date = new Date();
-    const year = date.getUTCFullYear();
-    const month = date.getUTCMonth() + 1;
-    const day = date.getUTCDate();
-
-    return client.sendPokeTx({
-      tx: {
-        nonce: 0,
-        itx: {
-          date: `${year}-${padStart(month, 2, '0')}-${padStart(day, 2, '0')}`,
-          address: 'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz'
-        }
-      },
-      wallet
-    }, extra);
-  };
+  client.createToken = async ({ name, description, symbol, unit, decimal, icon, totalSupply, initialSupply, foreignToken, data, wallet }, extra) => {
+    const tokenDecimal = typeof decimal === 'undefined' ? DEFAULT_TOKEN_DECIMAL : decimal;
 
-  /**
-   * Send a refuel transaction to get some gas
-   *
-   * @memberof GraphQLClient
-   * @function
-   * @name GraphQLClient#refuel
-   * @param {object} params
-   * @param {WalletObject} params.wallet - the wallet to sign the transaction, also who will get the token
-   * @param {object} params.data - extra data to put in itx
-   * @param {object} extra - other param to underlying client implementation
-   * @returns {Promise} the `transactionHash` once resolved
-   */
-  client.refuel = ({ wallet, data }, extra) => {
-    const date = new Date();
-    const year = date.getUTCFullYear();
-    const month = date.getUTCMonth() + 1;
-    const day = date.getUTCDate();
+    const payload = {
+      name,
+      description,
+      symbol,
+      unit,
+      decimal: tokenDecimal,
+      icon,
+      totalSupply: fromTokenToUnit(totalSupply, tokenDecimal).toString(),
+      initialSupply: fromTokenToUnit(initialSupply || totalSupply, tokenDecimal).toString(),
+      foreignToken: foreignToken || null,
+      data
+    };
 
-    return client.sendRefuelTx({
-      tx: {
-        nonce: 0,
-        itx: {
-          date: `${year}-${padStart(month, 2, '0')}-${padStart(day, 2, '0')}`,
-          data
-        }
-      },
+    const address = toTokenAddress(payload);
+    payload.address = address;
+    const hash = await client.sendCreateTokenTx({
+      tx: { itx: payload },
       wallet
     }, extra);
+    return [hash, address];
   };
 };