@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/src/contract/methods.ts

@@ -0,0 +1,118 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * Contract module - routines to interact with the æternity contract
+ *
+ * High level documentation of the contracts are available at
+ * https://github.com/aeternity/protocol/tree/master/contracts and
+ */
+
+import { AensName } from '../tx/builder/schema'
+import { decode, produceNameId } from '../tx/builder/helpers'
+import { concatBuffers } from '../utils/other'
+import { EncodedData, EncodingType } from '../utils/encoder'
+import AccountBase from '../account/Base'
+import Node from '../Node'
+export { default as getContractInstance } from './aci'
+
+/**
+ * Utility method to create a delegate signature for a contract
+ * @param ids - The list of id's to prepend
+ * @param opt - Options
+ * @param opt.onNode - Node to use
+ * @param opt.onAccount - Account to use
+ * @returns Signature in hex representation
+ */
+async function delegateSignatureCommon (
+  ids: Array<EncodedData<EncodingType>> = [],
+  { onAccount, onNode, ...opt }:
+  { onAccount: AccountBase, onNode: Node } & Parameters<AccountBase['sign']>[1]
+): Promise<string> {
+  const signature = await onAccount.sign(
+    concatBuffers([
+      Buffer.from((await onNode.getStatus()).networkId),
+      ...ids.map(e => decode(e))
+    ]),
+    opt
+  )
+  return Buffer.from(signature).toString('hex')
+}
+
+/**
+ * Helper to generate a signature to delegate pre-claim/claim/transfer/revoke of a name to
+ * a contract.
+ * @param contractId - Contract Id
+ * @param opt - Options
+ * @param opt.name - The name
+ * @returns Signature for delegation
+ * @example
+ * ```js
+ * const aeSdk = new AeSdk({ ... })
+ * const contractId = 'ct_asd2ks...' // contract address
+ * const name = 'example.chain' // AENS name
+ * const onAccount = await aeSdk.address() // Sign with a specific account
+ * // Preclaim signature
+ * const preclaimSig = await aeSdk.createAensDelegationSignature(contractId, { onAccount: current })
+ * // Claim, transfer and revoke signature
+ * const aensDelegationSig = await contract.createAensDelegationSignature(
+ *   contractId, { name, onAccount: current }
+ * )
+ * ```
+ */
+export async function createAensDelegationSignature (
+  contractId: EncodedData<'ct'>,
+  opt: Parameters<AccountBase['address']>[0] & Parameters<typeof delegateSignatureCommon>[1] &
+  { name?: AensName }
+): Promise<string> {
+  return await delegateSignatureCommon(
+    [
+      await opt.onAccount.address(opt),
+      ...opt.name != null ? [produceNameId(opt.name)] : [],
+      contractId
+    ],
+    opt
+  )
+}
+
+/**
+ * Helper to generate a signature to delegate register/extend/respond of a Oracle to a contract.
+ * @param contractId - Contract Id
+ * @param opt - Options
+ * @param opt.queryId - Oracle Query Id
+ * @returns Signature for delegation
+ * @example
+ * ```js
+ * const aeSdk = new AeSdk({ ... })
+ * const contractId = 'ct_asd2ks...' // contract address
+ * const queryId = 'oq_...' // Oracle Query Id
+ * const onAccount = await aeSdk.address() // Sign with a specific account
+ * // Oracle register and extend signature
+ * const oracleDelegationSig = await aeSdk.createOracleDelegationSignature(contractId)
+ * // Oracle respond signature
+ * const respondSig = await aeSdk.createOracleDelegationSignature(contractId, { queryId })
+ * ```
+ */
+export async function createOracleDelegationSignature (
+  contractId: EncodedData<'ct'>,
+  opt: Parameters<AccountBase['address']>[0] & Parameters<typeof delegateSignatureCommon>[1] &
+  { queryId?: EncodedData<'oq'> }
+): Promise<string> {
+  return await delegateSignatureCommon(
+    [opt.queryId ?? await opt.onAccount.address(opt), contractId], opt
+  )
+}

package/src/index.ts

@@ -0,0 +1,51 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+
+export * from './chain'
+export * from './utils/crypto'
+export * from './utils/keystore'
+export * from './utils/bytes'
+export * from './tx'
+export * from './tx/builder'
+export * from './tx/builder/helpers'
+export * from './tx/builder/schema'
+export * from './utils/amount-formatter'
+export * from './utils/hd-wallet'
+export * from './aens'
+export * from './contract/methods'
+export * from './oracle'
+export * from './spend'
+export * from './contract/ga'
+
+export { default as AeSdkBase } from './AeSdkBase'
+export { default as AeSdk } from './AeSdk'
+export { default as AeSdkAepp } from './AeSdkAepp'
+export { default as AeSdkWallet } from './AeSdkWallet'
+export { default as Node } from './Node'
+export { default as verifyTransaction } from './tx/validator'
+export { default as calculateMinFee } from './tx/min-fee'
+export { default as AccountBase } from './account/Base'
+export { default as MemoryAccount } from './account/Memory'
+export { default as Compiler } from './contract/Compiler'
+export { default as Channel } from './channel'
+
+export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy'
+export * from './aepp-wallet-communication/schema'
+export { default as walletDetector } from './aepp-wallet-communication/wallet-detector'
+export { default as BrowserRuntimeConnection } from './aepp-wallet-communication/connection/BrowserRuntime'
+export { default as BrowserWindowMessageConnection } from './aepp-wallet-communication/connection/BrowserWindowMessage'
+export * from './utils/errors'

package/src/oracle.ts

@@ -0,0 +1,342 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * Oracle methods - routines to interact with the æternity oracle system
+ *
+ * The high-level description of the oracle system is
+ * https://github.com/aeternity/protocol/blob/master/ORACLE.md in the protocol
+ * repository.
+ */
+
+import { send, SendOptions } from './spend'
+import { mapObject, pause } from './utils/other'
+import { oracleQueryId, decode, encode } from './tx/builder/helpers'
+import { unpackTx } from './tx/builder'
+import {
+  ORACLE_TTL,
+  ORACLE_TTL_TYPES,
+  QUERY_FEE,
+  QUERY_TTL,
+  RESPONSE_TTL,
+  TX_TYPE
+} from './tx/builder/schema'
+import { RequestTimedOutError } from './utils/errors'
+import { EncodedData } from './utils/encoder'
+import { _getPollInterval } from './chain'
+import { _buildTx, BuildTxOptions } from './tx'
+import Node from './Node'
+import BigNumber from 'bignumber.js'
+import AccountBase from './account/Base'
+
+type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries']
+
+/**
+ * Constructor for Oracle Object (helper object for using Oracle)
+ * @param oracleId - Oracle public key
+ * @param options - Options
+ * @returns Oracle object
+ */
+export async function getOracleObject (
+  oracleId: EncodedData<'ok'>, options: { onNode: Node, onAccount: AccountBase }
+): Promise<GetOracleObjectReturnType> {
+  return {
+    ...await options.onNode.getOracleByPubkey(oracleId),
+    queries: (await options.onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries,
+    ...mapObject<Function, Function>(
+      {
+        pollQueries: pollForQueries,
+        postQuery: postQueryToOracle,
+        respondToQuery,
+        extendOracle: extendOracleTtl,
+        getQuery: getQueryObject
+      },
+      ([name, handler]) => [
+        name,
+        function (...args: any) {
+          const lastArg = args[args.length - 1]
+          if (lastArg != null && typeof lastArg === 'object' && lastArg.constructor === Object) {
+            Object.assign(lastArg, { ...options, ...lastArg })
+          } else args.push(options)
+          return handler(oracleId, ...args)
+        }
+      ])
+  } as any
+}
+
+interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleByPubkey']>> {
+  id: EncodedData<'ok'>
+  queries: OracleQueries
+  // TODO: replace getOracleObject with a class
+  pollQueries: (cb: Parameters<typeof pollForQueries>[1]) => ReturnType<typeof pollForQueries>
+  postQuery: Function
+  respondToQuery: Function
+  extendOracle: Function
+  getQuery: Function
+}
+
+/**
+ * Poll for oracle queries
+ * @param oracleId - Oracle public key
+ * @param onQuery - OnQuery callback
+ * @param options - Options object
+ * @param options.interval - Poll interval(default: 5000)
+ * @param options.onNode - Node to use
+ * @returns Callback to stop polling function
+ */
+export function pollForQueries (
+  oracleId: EncodedData<'ok'>,
+  onQuery: (queries: OracleQueries) => void,
+  { interval, onNode, ...options }: { interval?: number, onNode: Node }
+  & Parameters<typeof _getPollInterval>[1]
+): () => void {
+  interval ??= _getPollInterval('microblock', options)
+  const knownQueryIds = new Set()
+  const checkNewQueries = async (): Promise<void> => {
+    const queries = ((await onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries ?? [])
+      .filter(({ id }) => !knownQueryIds.has(id))
+    queries.forEach(({ id }) => knownQueryIds.add(id))
+    if (queries.length > 0) onQuery(queries)
+  }
+
+  let stopped = false;
+
+  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+  (async () => {
+    while (!stopped) { // eslint-disable-line no-unmodified-loop-condition
+      // TODO: allow to handle this error somehow
+      await checkNewQueries().catch(console.error)
+      await pause(interval)
+    }
+  })()
+  return () => { stopped = true }
+}
+
+/**
+ * Constructor for OracleQuery Object (helper object for using OracleQuery)
+ * @param oracleId - Oracle public key
+ * @param queryId - Oracle Query id
+ * @param options - Options
+ * @returns OracleQuery object
+ */
+export async function getQueryObject (
+  oracleId: EncodedData<'ok'>,
+  queryId: EncodedData<'oq'>,
+  options: RespondToQueryOptions & Parameters<typeof pollForQueryResponse>[2]
+): Promise<GetQueryObjectReturnType> {
+  const record = await options.onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId)
+  return {
+    ...record,
+    decodedQuery: decode(record.query as EncodedData<'oq'>).toString(),
+    decodedResponse: decode(record.response as EncodedData<'or'>).toString(),
+    respond: async (response, opt) =>
+      await respondToQuery(oracleId, queryId, response, { ...options, ...opt }),
+    pollForResponse: async (opt) =>
+      await pollForQueryResponse(oracleId, queryId, { ...options, ...opt })
+  }
+}
+
+interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
+  decodedQuery: string
+  decodedResponse: string
+  respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) =>
+  ReturnType<typeof respondToQuery>
+  pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) =>
+  ReturnType<typeof pollForQueryResponse>
+}
+
+/**
+ * Poll for oracle query response
+ * @param oracleId - Oracle public key
+ * @param queryId - Oracle Query id
+ * @param options - Options object
+ * @param options.attempts - Poll attempts
+ * @param options.interval - Poll interval
+ * @param options.onNode - Node to use
+ * @returns OracleQuery object
+ */
+export async function pollForQueryResponse (
+  oracleId: EncodedData<'ok'>,
+  queryId: EncodedData<'oq'>,
+  { attempts = 20, interval, onNode, ...options }:
+  { attempts?: number, interval?: number, onNode: Node } & Parameters<typeof _getPollInterval>[1]
+): Promise<string> {
+  interval ??= _getPollInterval('microblock', options)
+  for (let i = 0; i < attempts; i++) {
+    if (i > 0) await pause(interval)
+    const { response } = await onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId)
+    const responseBuffer = decode(response as EncodedData<'or'>)
+    if (responseBuffer.length > 0) return responseBuffer.toString()
+  }
+  throw new RequestTimedOutError((attempts - 1) * interval)
+}
+
+/**
+ * Register oracle
+ * @param queryFormat - Format of query
+ * @param responseFormat - Format of query response
+ * @param options - Options
+ * @param options.queryFee - Oracle query Fee
+ * @param options - Options object
+ * @param options.abiVersion - Always 0 (do not use virtual machine)
+ * @param options.fee - Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @returns Oracle object
+ */
+export async function registerOracle (
+  queryFormat: string, responseFormat: string, options: RegisterOracleOptions
+): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
+  const accountId = await options.onAccount.address(options)
+  const oracleRegisterTx = await _buildTx(TX_TYPE.oracleRegister, {
+    queryFee: QUERY_FEE,
+    oracleTtlValue: ORACLE_TTL.value,
+    oracleTtlType: ORACLE_TTL.type,
+    ...options,
+    accountId,
+    queryFormat,
+    responseFormat
+  })
+  return {
+    ...await send(oracleRegisterTx, options),
+    ...await getOracleObject(encode(decode(accountId), 'ok'), options)
+  }
+}
+
+type RegisterOracleOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+& BuildTxOptions<TX_TYPE.oracleRegister, 'accountId' | 'queryFormat' | 'responseFormat' | 'queryFee' | 'oracleTtlType' | 'oracleTtlValue'>
+& {
+  queryFee?: number | string | BigNumber
+  oracleTtlType?: ORACLE_TTL_TYPES
+  oracleTtlValue?: number
+}
+interface RegisterOracleOptions extends RegisterOracleOptionsType {}
+
+/**
+ * Post query to oracle
+ * @param oracleId - Oracle public key
+ * @param query - Oracle query object
+ * @param options - Options object
+ * @param options.queryTtl - queryTtl Oracle query time to leave
+ * @param options.responseTtl - queryFee Oracle query response time to leave
+ * @param options.queryFee - queryFee Oracle query fee
+ * @param options.fee - fee Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @returns Query object
+ */
+export async function postQueryToOracle (oracleId: EncodedData<'ok'>,
+  query: string, options: PostQueryToOracleOptions
+): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>> {
+  options.queryFee ??= (await options.onNode.getOracleByPubkey(oracleId)).queryFee.toString()
+  const senderId = await options.onAccount.address(options)
+
+  const oracleQueryTx = await _buildTx(TX_TYPE.oracleQuery, {
+    queryTtlType: QUERY_TTL.type,
+    queryTtlValue: QUERY_TTL.value,
+    responseTtlType: RESPONSE_TTL.type,
+    responseTtlValue: RESPONSE_TTL.value,
+    ...options,
+    oracleId,
+    senderId,
+    query
+  })
+  const nonce = unpackTx(oracleQueryTx, TX_TYPE.oracleQuery).tx.nonce
+  const queryId = oracleQueryId(senderId, nonce, oracleId)
+  return {
+    ...await send(oracleQueryTx, options),
+    ...await getQueryObject(oracleId, queryId, options)
+  }
+}
+
+type PostQueryToOracleOptionsType = Parameters<typeof send>[1]
+& Parameters<typeof getQueryObject>[2]
+& BuildTxOptions<TX_TYPE.oracleQuery, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'>
+& {
+  queryTtlType?: ORACLE_TTL_TYPES
+  queryTtlValue?: number
+  responseTtlType?: ORACLE_TTL_TYPES
+  responseTtlValue?: number
+}
+interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {}
+
+/**
+ * Extend oracle ttl
+ * @param oracleId - Oracle public key
+ * @param options - Options object
+ * @param options.fee - fee Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @param options.oracleTtlType - Oracle time to leave for extend
+ * @param options.oracleTtlValue - Oracle time to leave for extend
+ * @returns Oracle object
+ */
+export async function extendOracleTtl (
+  oracleId: EncodedData<'ok'>,
+  options: ExtendOracleTtlOptions
+): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
+  const oracleExtendTx = await _buildTx(TX_TYPE.oracleExtend, {
+    oracleTtlType: ORACLE_TTL.type,
+    oracleTtlValue: ORACLE_TTL.value,
+    ...options,
+    callerId: await options.onAccount.address(options),
+    oracleId
+  })
+  return {
+    ...await send(oracleExtendTx, options),
+    ...await getOracleObject(oracleId, options)
+  }
+}
+
+type ExtendOracleTtlOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+& BuildTxOptions<TX_TYPE.oracleExtend, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'>
+& { oracleTtlType?: ORACLE_TTL_TYPES, oracleTtlValue?: number }
+interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
+
+/**
+ * Extend oracle ttl
+ * @param oracleId - Oracle public key
+ * @param queryId - Oracle query id
+ * @param response - Oracle query response
+ * @param options - Options object
+ * @param options.responseTtl - responseTtl Query response time to leave
+ * @param options.fee - Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @returns Oracle object
+ */
+export async function respondToQuery (
+  oracleId: EncodedData<'ok'>,
+  queryId: EncodedData<'oq'>,
+  response: string,
+  options: RespondToQueryOptions
+): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
+  const oracleRespondTx = await _buildTx(TX_TYPE.oracleResponse, {
+    responseTtlType: RESPONSE_TTL.type,
+    responseTtlValue: RESPONSE_TTL.value,
+    ...options,
+    callerId: await options.onAccount.address(options),
+    oracleId,
+    queryId,
+    response
+  })
+  return {
+    ...await send(oracleRespondTx, options),
+    ...await getOracleObject(oracleId, options)
+  }
+}
+
+type RespondToQueryOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+& BuildTxOptions<TX_TYPE.oracleResponse, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'>
+& { responseTtlType?: ORACLE_TTL_TYPES, responseTtlValue?: number }
+interface RespondToQueryOptions extends RespondToQueryOptionsType {}

package/src/spend.ts

@@ -0,0 +1,152 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+import { sendTransaction, getAccount, getBalance, resolveName } from './chain'
+import { _buildTx, BuildTxOptions } from './tx'
+import { buildTxHash, unpackTx } from './tx/builder'
+import BigNumber from 'bignumber.js'
+import { ArgumentError } from './utils/errors'
+import { EncodedData } from './utils/encoder'
+import { createMetaTx } from './contract/ga'
+import { TX_TYPE, AensName } from './tx/builder/schema'
+import AccountBase from './account/Base'
+
+/**
+ * Sign and post a transaction to the chain
+ * @param tx - Transaction
+ * @param options - Options
+ * @param options.verify - Verify transaction before broadcast, throw error if not
+ * valid
+ * @returns Transaction
+ */
+export async function send (tx: EncodedData<'tx'>, options: SendOptions): Promise<SendReturnType> {
+  const { contractId, authFun = undefined } = options.innerTx === true
+    ? { contractId: null }
+    : await getAccount(await options.onAccount.address(options), options)
+
+  const signed = contractId != null
+    // TODO: not required arguments become required depending on account type, can ga be extracted?
+    ? await signUsingGA(tx, { authData: {}, ...options, authFun: authFun as string })
+    : await options.onAccount.signTransaction(tx, options)
+
+  return options.innerTx === true
+    ? { hash: buildTxHash(signed), rawTx: signed }
+    : await sendTransaction(signed, options)
+}
+
+type SendOptionsType = Parameters<AccountBase['signTransaction']>[1] & Parameters<typeof sendTransaction>[1]
+& Partial<Omit<Parameters<typeof signUsingGA>[1], 'onAccount' | 'onCompiler'>>
+& Pick<Parameters<typeof signUsingGA>[1], 'onAccount' | 'onCompiler'>
+export interface SendOptions extends SendOptionsType {}
+interface SendReturnType extends Awaited<ReturnType<typeof sendTransaction>> {}
+
+export async function signUsingGA (
+  tx: EncodedData<'tx'>,
+  { authData, authFun, ...options }: {
+    authData: Parameters<typeof createMetaTx>[1]
+    authFun: Parameters<typeof createMetaTx>[2]
+  } & Parameters<typeof createMetaTx>[3]
+): Promise<EncodedData<'tx'>> {
+  return await createMetaTx(tx, authData, authFun, options)
+}
+
+/**
+ * Send coins to another account
+ * @param amount - Amount to spend
+ * @param recipientIdOrName - Address or name of recipient account
+ * @param options - Options
+ * @returns Transaction
+ */
+export async function spend (
+  amount: number | string,
+  recipientIdOrName: EncodedData<'ak'> | AensName,
+  options: SpendOptions
+): ReturnType<typeof send> {
+  return await send(
+    await _buildTx(TX_TYPE.spend, {
+      ...options,
+      senderId: await options.onAccount.address(options),
+      recipientId: await resolveName(recipientIdOrName, 'account_pubkey', options),
+      amount
+    }),
+    options
+  )
+}
+
+type SpendOptionsType = BuildTxOptions<TX_TYPE.spend, 'senderId' | 'recipientId' | 'amount'>
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions
+interface SpendOptions extends SpendOptionsType {}
+
+// TODO: Rename to spendFraction
+/**
+ * Send a fraction of coin balance to another account
+ * @param fraction - Fraction of balance to spend (between 0 and 1)
+ * @param recipientIdOrName - Address or name of recipient account
+ * @param options - Options
+ * @returns Transaction
+ */
+export async function transferFunds (
+  fraction: number | string,
+  recipientIdOrName: AensName | EncodedData<'ak'>,
+  options: TransferFundsOptions
+): ReturnType<typeof send> {
+  if (fraction < 0 || fraction > 1) {
+    throw new ArgumentError('fraction', 'a number between 0 and 1', fraction)
+  }
+  const recipientId = await resolveName<'ak'>(recipientIdOrName, 'account_pubkey', options)
+  const senderId = await options.onAccount.address(options)
+  const balance = new BigNumber(
+    await getBalance.bind(options.onAccount)(senderId, options)
+  )
+  const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP)
+  const { tx: { fee } } = unpackTx(
+    await _buildTx(TX_TYPE.spend, { ...options, senderId, recipientId, amount: desiredAmount }),
+    TX_TYPE.spend
+  )
+  // Reducing of the amount may reduce transaction fee, so this is not completely accurate
+  const amount = desiredAmount.plus(fee).gt(balance) ? balance.minus(fee) : desiredAmount
+  return await send(
+    await _buildTx(TX_TYPE.spend, { ...options, senderId, recipientId, amount }),
+    options
+  )
+}
+
+type TransferFundsOptionsType = BuildTxOptions<TX_TYPE.spend, 'senderId' | 'recipientId' | 'amount'>
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions
+interface TransferFundsOptions extends TransferFundsOptionsType {}
+
+/**
+ * Submit transaction of another account paying for it (fee and gas)
+ * @param transaction - tx_<base64>-encoded transaction
+ * @param options - Options
+ * @returns Object Transaction
+ */
+export async function payForTransaction (
+  transaction: EncodedData<'tx'>, options: PayForTransactionOptions
+): ReturnType<typeof send> {
+  return await send(
+    await _buildTx(
+      TX_TYPE.payingFor,
+      { ...options, payerId: await options.onAccount.address(options), tx: transaction }
+    ),
+    options
+  )
+}
+
+interface PayForTransactionOptions extends
+  BuildTxOptions<TX_TYPE.payingFor, 'payerId' | 'tx'>, SendOptions {
+  onAccount: AccountBase
+}