@aeternity/aepp-sdk 13.0.0-alpha.1 → 13.0.0-beta.0

package/src/contract/delegation-signature.ts

@@ -0,0 +1,56 @@
+import { decode, Encoded } from '../utils/encoder';
+import { AensName } from '../tx/builder/constants';
+import AccountBase from '../account/Base';
+import { concatBuffers } from '../utils/other';
+import { isNameValid, produceNameId } from '../tx/builder/helpers';
+import Node from '../Node';
+
+/**
+ * Helper to generate a signature to delegate
+ *  - pre-claim/claim/transfer/revoke of a name to a contract.
+ *  - register/extend/respond of an Oracle to a contract.
+ * @category contract
+ * @param contractAddress - Address of contract to delegate access
+ * @param ids - The list of id's to prepend
+ * @param options - Options
+ * @param options.omitAddress - Prepend delegation signature with an account address
+ * @param options.onAccount - Account to use
+ * @param options.onNode - Node to use
+ * @returns Signature
+ * @example
+ * ```js
+ * const aeSdk = new AeSdk({ ... })
+ * const contractAddress = 'ct_asd2ks...'
+ * const aensName = 'example.chain'
+ * const onAccount = new MemoryAccount(...) // Sign with a specific account
+ * // Preclaim signature
+ * const preclaimSig = await aeSdk.createDelegationSignature(contractAddress, [], { onAccount })
+ * // Claim, transfer and revoke signature
+ * const aensDelegationSig = await aeSdk
+ *   .createDelegationSignature(contractAddress, [aensName], { onAccount })
+ *
+ * const oracleQueryId = 'oq_...'
+ * const onAccount = new MemoryAccount(...) // Sign with a specific account
+ * // Oracle register and extend signature
+ * const oracleDelegationSig = await aeSdk
+ *   .createDelegationSignature(contractAddress, [], { onAccount })
+ * // Oracle respond signature
+ * const respondSig = await aeSdk
+ *   .createDelegationSignature(contractAddress, [oracleQueryId], { onAccount, omitAddress: true })
+ * ```
+ */
+export default async function createDelegationSignature(
+  contractAddress: Encoded.ContractAddress,
+  ids: Array<Encoded.Any | AensName>,
+  options: { omitAddress?: boolean; onAccount: AccountBase; onNode: Node },
+): Promise<Uint8Array> {
+  return options.onAccount.sign(
+    concatBuffers([
+      Buffer.from(await options.onNode.getNetworkId()),
+      ...options.omitAddress === true ? [] : [decode(options.onAccount.address)],
+      ...ids.map((e) => (isNameValid(e) ? produceNameId(e) : e)).map((e) => decode(e)),
+      decode(contractAddress),
+    ]),
+    options,
+  );
+}

package/src/contract/ga.ts

@@ -1,36 +1,21 @@
-/*
- * 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.
- */
-
 /**
  * Generalized Account module - routines to use generalized account
  */
 
-import { Tag } from '../tx/builder/constants';
-import { buildContractIdByContractTx } from '../tx/builder';
-import { _buildTx, BuildTxOptions } from '../tx';
+import { ConsensusProtocolVersion, Int, Tag } from '../tx/builder/constants';
+import {
+  buildContractIdByContractTx, buildTx, buildTxAsync, BuildTxOptions, unpackTx,
+} from '../tx/builder';
 import { hash } from '../utils/crypto';
-import { decode, Encoded } from '../utils/encoder';
-import { IllegalArgumentError } from '../utils/errors';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../utils/encoder';
+import { ArgumentError, IllegalArgumentError } from '../utils/errors';
 import { concatBuffers } from '../utils/other';
 import AccountBase from '../account/Base';
 import Contract from './Contract';
-import { send, SendOptions } from '../spend';
 import Node from '../Node';
-import { getAccount } from '../chain';
+import { sendTransaction, SendTransactionOptions, getAccount } from '../chain';
 import CompilerBase from './compiler/Base';
 
 /**
@@ -63,8 +48,9 @@ export async function createGeneralizedAccount(
     onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem,
   });
 
-  const tx = await _buildTx(Tag.GaAttachTx, {
+  const tx = await buildTxAsync({
     ...options,
+    tag: Tag.GaAttachTx,
     onNode,
     code: await contract.$compile(),
     gasLimit: options.gasLimit ?? await contract._estimateGas('init', args, options),
@@ -73,7 +59,7 @@ export async function createGeneralizedAccount(
     authFun: hash(authFnName),
   });
   const contractId = buildContractIdByContractTx(tx);
-  const { hash: transaction, rawTx } = await send(tx, {
+  const { hash: transaction, rawTx } = await sendTransaction(tx, {
     onNode, onAccount, onCompiler, ...options,
   });
 
@@ -87,7 +73,7 @@ export async function createGeneralizedAccount(
 
 interface CreateGeneralizedAccountOptions extends
   BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>,
-  SendOptions,
+  SendTransactionOptions,
   Pick<
   Parameters<typeof Contract.initialize>[0],
   'bytecode' | 'aci' | 'sourceCodePath' | 'sourceCode' | 'fileSystem'
@@ -99,18 +85,53 @@ interface CreateGeneralizedAccountOptions extends
 }
 
 /**
- * Build a transaction hash the same as `Auth.tx_hash`
+ * Build a transaction hash the same as `Auth.tx_hash` by GaMetaTx payload
  * @category contract
  * @param transaction - tx-encoded transaction
  * @param options - Options
+ * @param options.fee - GaMetaTx fee, required in Ceres
+ * @param options.gasPrice - GaMetaTx gasPrice, required in Ceres
  * @param options.onNode - Node to use
  * @returns Transaction hash
  */
 export async function buildAuthTxHash(
+  transaction: Encoded.Transaction,
+  { fee, gasPrice, onNode }: { fee?: Int; gasPrice?: Int; onNode: Node },
+): Promise<Buffer> {
+  const { nodeNetworkId, consensusProtocolVersion } = await onNode.getNodeInfo();
+  let payload = hash(concatBuffers([Buffer.from(nodeNetworkId), decode(transaction)]));
+  if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+    if (fee == null) throw new ArgumentError('fee', 'provided (in Ceres)', fee);
+    if (gasPrice == null) throw new ArgumentError('gasPrice', 'provided (in Ceres)', gasPrice);
+    payload = hash(decode(buildTx({
+      tag: Tag.GaMetaTxAuthData,
+      fee,
+      gasPrice,
+      txHash: encode(payload, Encoding.TxHash),
+    })));
+  }
+  return payload;
+}
+
+/**
+ * Build a transaction hash the same as `Auth.tx_hash` by GaMetaTx
+ * @category contract
+ * @param transaction - tx-encoded signed GaMeta transaction
+ * @param options - Options
+ * @param options.onNode - Node to use
+ * @returns Transaction hash
+ */
+export async function buildAuthTxHashByGaMetaTx(
   transaction: Encoded.Transaction,
   { onNode }: { onNode: Node },
-): Promise<Uint8Array> {
-  return new Uint8Array(hash(
-    concatBuffers([Buffer.from(await onNode.getNetworkId()), decode(transaction)]),
-  ));
+): Promise<Buffer> {
+  const txParams = unpackTx(transaction, Tag.SignedTx);
+  if (txParams.encodedTx.tag !== Tag.GaMetaTx) {
+    throw new ArgumentError('transaction', 'to include GaMetaTx', Tag[txParams.encodedTx.tag]);
+  }
+  return buildAuthTxHash(buildTx(txParams.encodedTx.tx.encodedTx), {
+    fee: txParams.encodedTx.fee,
+    gasPrice: txParams.encodedTx.gasPrice,
+    onNode,
+  });
 }

package/src/index-browser.ts

@@ -1,29 +1,21 @@
-/*
- * 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.
- */
-
+// TODO: avoid `export * from`
 export * from './chain';
 export * from './utils/crypto';
 export * from './utils/keystore';
 export * from './utils/bytes';
-export * from './tx';
-export * from './tx/builder';
+export {
+  buildTx, buildTxAsync, buildTxHash, unpackTx, buildContractIdByContractTx,
+} from './tx/builder';
 export * from './tx/builder/helpers';
 export * from './tx/builder/constants';
-export * from './tx/builder/schema';
+// TODO: move to constants
+export {
+  ORACLE_TTL_TYPES, ORACLE_TTL, QUERY_TTL, RESPONSE_TTL, DRY_RUN_ACCOUNT, CallReturnType,
+} from './tx/builder/schema';
+export {
+  getExecutionCost, getExecutionCostBySignedTx, getExecutionCostUsingNode,
+} from './tx/execution-cost';
+export { default as getTransactionSignerAddress } from './tx/transaction-signer';
 export * from './utils/amount-formatter';
 export * from './utils/hd-wallet';
 export { encode, decode, Encoding } from './utils/encoder';

package/src/oracle.ts

@@ -1,20 +1,3 @@
-/*
- * 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
  *
@@ -23,15 +6,12 @@
  * repository.
  */
 
-import BigNumber from 'bignumber.js';
-import { send, SendOptions } from './spend';
 import { mapObject, pause } from './utils/other';
 import { oracleQueryId } from './tx/builder/helpers';
-import { unpackTx } from './tx/builder';
+import { unpackTx, buildTxAsync, BuildTxOptions } from './tx/builder';
 import {
   ORACLE_TTL,
   ORACLE_TTL_TYPES,
-  QUERY_FEE,
   QUERY_TTL,
   RESPONSE_TTL,
 } from './tx/builder/schema';
@@ -40,8 +20,9 @@ import { RequestTimedOutError } from './utils/errors';
 import {
   decode, encode, Encoded, Encoding,
 } from './utils/encoder';
-import { _getPollInterval, getHeight } from './chain';
-import { _buildTx, BuildTxOptions } from './tx';
+import {
+  _getPollInterval, getHeight, sendTransaction, SendTransactionOptions,
+} from './chain';
 import Node from './Node';
 import AccountBase from './account/Base';
 
@@ -59,7 +40,7 @@ type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['orac
  */
 export function pollForQueries(
   oracleId: Encoded.OracleAddress,
-  onQuery: (queries: OracleQueries) => void,
+  onQuery: (query: OracleQueries[number]) => void,
   { interval, onNode, ...options }: { interval?: number; onNode: Node }
   & Parameters<typeof _getPollInterval>[1],
 ): () => void {
@@ -68,8 +49,10 @@ export function pollForQueries(
   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);
+    queries.forEach((query) => {
+      knownQueryIds.add(query.id);
+      onQuery(query);
+    });
   };
 
   let stopped = false;
@@ -135,7 +118,7 @@ export async function getQueryObject(
     decodedResponse: decode(record.response as Encoded.OracleResponse).toString(),
     respond: async (response, opt) => (
       // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      respondToQuery(oracleId, queryId, response, { ...options, ...opt })
+      respondToQuery(queryId, response, { ...options, ...opt })
     ),
     pollForResponse: async (opt) => pollForQueryResponse(oracleId, queryId, { ...options, ...opt }),
   };
@@ -144,7 +127,7 @@ export async function getQueryObject(
 interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
   decodedQuery: string;
   decodedResponse: string;
-  respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) =>
+  respond: (response: string, options?: Parameters<typeof respondToQuery>[2]) =>
   ReturnType<typeof respondToQuery>;
   pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) =>
   ReturnType<typeof pollForQueryResponse>;
@@ -167,16 +150,19 @@ export async function postQueryToOracle(
   oracleId: Encoded.OracleAddress,
   query: string,
   options: PostQueryToOracleOptions,
-): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>> {
+): Promise<
+  Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getQueryObject>>
+  > {
   options.queryFee ??= (await options.onNode.getOracleByPubkey(oracleId)).queryFee.toString();
   const senderId = options.onAccount.address;
 
-  const oracleQueryTx = await _buildTx(Tag.OracleQueryTx, {
+  const oracleQueryTx = await buildTxAsync({
     queryTtlType: QUERY_TTL.type,
     queryTtlValue: QUERY_TTL.value,
     responseTtlType: RESPONSE_TTL.type,
     responseTtlValue: RESPONSE_TTL.value,
     ...options,
+    tag: Tag.OracleQueryTx,
     oracleId,
     senderId,
     query,
@@ -184,12 +170,12 @@ export async function postQueryToOracle(
   const { nonce } = unpackTx(oracleQueryTx, Tag.OracleQueryTx);
   const queryId = oracleQueryId(senderId, nonce, oracleId);
   return {
-    ...await send(oracleQueryTx, options),
+    ...await sendTransaction(oracleQueryTx, options),
     ...await getQueryObject(oracleId, queryId, options),
   };
 }
 
-type PostQueryToOracleOptionsType = Parameters<typeof send>[1]
+type PostQueryToOracleOptionsType = Parameters<typeof sendTransaction>[1]
 & Parameters<typeof getQueryObject>[2]
 & BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'>
 & {
@@ -203,7 +189,6 @@ interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {}
 /**
  * Extend oracle ttl
  * @category oracle
- * @param oracleId - Oracle public key
  * @param options - Options object
  * @param options.fee - fee Transaction fee
  * @param options.ttl - Transaction time to leave
@@ -211,25 +196,25 @@ interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {}
  * @param options.oracleTtlValue - Oracle time to leave for extend
  * @returns Oracle object
  */
-export async function extendOracleTtl(
-  oracleId: Encoded.OracleAddress,
-  options: ExtendOracleTtlOptions,
-): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
-  const oracleExtendTx = await _buildTx(Tag.OracleExtendTx, {
+export async function extendOracleTtl(options: ExtendOracleTtlOptions): Promise<
+Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>
+> {
+  const oracleId = encode(decode(options.onAccount.address), Encoding.OracleAddress);
+  const oracleExtendTx = await buildTxAsync({
     oracleTtlType: ORACLE_TTL.type,
     oracleTtlValue: ORACLE_TTL.value,
     ...options,
-    callerId: options.onAccount.address,
+    tag: Tag.OracleExtendTx,
     oracleId,
   });
   return {
-    ...await send(oracleExtendTx, options),
+    ...await sendTransaction(oracleExtendTx, options),
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
     ...await getOracleObject(oracleId, options),
   };
 }
 
-type ExtendOracleTtlOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
 & BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'>
 & { oracleTtlType?: ORACLE_TTL_TYPES; oracleTtlValue?: number };
 interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
@@ -237,7 +222,6 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
 /**
  * Extend oracle ttl
  * @category oracle
- * @param oracleId - Oracle public key
  * @param queryId - Oracle query id
  * @param response - Oracle query response
  * @param options - Options object
@@ -247,28 +231,30 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
  * @returns Oracle object
  */
 export async function respondToQuery(
-  oracleId: Encoded.OracleAddress,
   queryId: Encoded.OracleQueryId,
   response: string,
   options: RespondToQueryOptions,
-): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
-  const oracleRespondTx = await _buildTx(Tag.OracleResponseTx, {
+): Promise<
+  Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>
+  > {
+  const oracleId = encode(decode(options.onAccount.address), Encoding.OracleAddress);
+  const oracleRespondTx = await buildTxAsync({
     responseTtlType: RESPONSE_TTL.type,
     responseTtlValue: RESPONSE_TTL.value,
     ...options,
-    callerId: options.onAccount.address,
+    tag: Tag.OracleResponseTx,
     oracleId,
     queryId,
     response,
   });
   return {
-    ...await send(oracleRespondTx, options),
+    ...await sendTransaction(oracleRespondTx, options),
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
     ...await getOracleObject(oracleId, options),
   };
 }
 
-type RespondToQueryOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
 & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'>
 & { responseTtlType?: ORACLE_TTL_TYPES; responseTtlValue?: number };
 interface RespondToQueryOptions extends RespondToQueryOptionsType {}
@@ -302,7 +288,10 @@ export async function getOracleObject(
           if (lastArg != null && typeof lastArg === 'object' && lastArg.constructor === Object) {
             Object.assign(lastArg, { ...options, ...lastArg });
           } else args.push(options);
-          return handler(oracleId, ...args);
+          return handler(
+            ...['extendOracle', 'respondToQuery'].includes(name) ? [] : [oracleId],
+            ...args,
+          );
         },
       ],
     ),
@@ -337,27 +326,28 @@ export async function registerOracle(
   queryFormat: string,
   responseFormat: string,
   options: RegisterOracleOptions,
-): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
+): Promise<
+  Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>
+  > {
   const accountId = options.onAccount.address;
-  const oracleRegisterTx = await _buildTx(Tag.OracleRegisterTx, {
-    queryFee: QUERY_FEE,
+  const oracleRegisterTx = await buildTxAsync({
     oracleTtlValue: ORACLE_TTL.value,
     oracleTtlType: ORACLE_TTL.type,
     ...options,
+    tag: Tag.OracleRegisterTx,
     accountId,
     queryFormat,
     responseFormat,
   });
   return {
-    ...await send(oracleRegisterTx, options),
+    ...await sendTransaction(oracleRegisterTx, options),
     ...await getOracleObject(encode(decode(accountId), Encoding.OracleAddress), options),
   };
 }
 
-type RegisterOracleOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
-& BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'queryFee' | 'oracleTtlType' | 'oracleTtlValue'>
+type RegisterOracleOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
+& BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'oracleTtlType' | 'oracleTtlValue'>
 & {
-  queryFee?: number | string | BigNumber;
   oracleTtlType?: ORACLE_TTL_TYPES;
   oracleTtlValue?: number;
 };

package/src/spend.ts

@@ -1,56 +1,13 @@
-/*
- * 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 BigNumber from 'bignumber.js';
-import { sendTransaction, getBalance, resolveName } from './chain';
-import { _buildTx, BuildTxOptions } from './tx';
-import { buildTxHash, unpackTx } from './tx/builder';
+import {
+  sendTransaction, getBalance, resolveName, SendTransactionOptions,
+} from './chain';
+import { buildTxAsync, BuildTxOptions, unpackTx } from './tx/builder';
 import { ArgumentError } from './utils/errors';
 import { Encoded, Encoding } from './utils/encoder';
 import { Tag, AensName } from './tx/builder/constants';
 import AccountBase from './account/Base';
 
-/**
- * Sign and post a transaction to the chain
- * @category 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: Encoded.Transaction,
-  options: SendOptions,
-): Promise<SendReturnType> {
-  const signed = await options.onAccount.signTransaction(tx, {
-    ...options,
-    networkId: await options.onNode.getNetworkId(),
-  });
-
-  return options.innerTx === true
-    ? { hash: buildTxHash(signed), rawTx: signed }
-    : sendTransaction(signed, options);
-}
-
-type SendOptionsType = Parameters<AccountBase['signTransaction']>[1]
-& Parameters<typeof sendTransaction>[1] & { onAccount: AccountBase };
-export interface SendOptions extends SendOptionsType {}
-interface SendReturnType extends Awaited<ReturnType<typeof sendTransaction>> {}
-
 /**
  * Send coins to another account
  * @category chain
@@ -63,10 +20,11 @@ export async function spend(
   amount: number | string,
   recipientIdOrName: Encoded.AccountAddress | AensName,
   options: SpendOptions,
-): ReturnType<typeof send> {
-  return send(
-    await _buildTx(Tag.SpendTx, {
+): ReturnType<typeof sendTransaction> {
+  return sendTransaction(
+    await buildTxAsync({
       ...options,
+      tag: Tag.SpendTx,
       senderId: options.onAccount.address,
       recipientId: await resolveName<Encoding.AccountAddress>(
         recipientIdOrName,
@@ -80,23 +38,32 @@ export async function spend(
 }
 
 type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
-& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions;
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendTransactionOptions;
 interface SpendOptions extends SpendOptionsType {}
 
 // TODO: Rename to spendFraction
 /**
- * Send a fraction of coin balance to another account
+ * Spend a fraction of coin balance to another account. Useful if needed to drain account balance
+ * completely, sending funds to another account (with fraction set to 1).
  * @category chain
  * @param fraction - Fraction of balance to spend (between 0 and 1)
  * @param recipientIdOrName - Address or name of recipient account
  * @param options - Options
- * @returns Transaction
+ * @example
+ * ```js
+ * // `fraction` * 100 = % of AE to be transferred (e.g. `0.42` for 42% or `1` for 100%)
+ * const { blockHeight } = await aeSdk.transferFunds(
+ *   0.42,
+ *   'ak_21A27UVVt3hDkBE5J7rhhqnH5YNb4Y1dqo4PnSybrH85pnWo7E',
+ * );
+ * console.log('Transaction mined at', blockHeight);
+ * ```
  */
 export async function transferFunds(
   fraction: number | string,
   recipientIdOrName: AensName | Encoded.AccountAddress,
   options: TransferFundsOptions,
-): ReturnType<typeof send> {
+): ReturnType<typeof sendTransaction> {
   if (fraction < 0 || fraction > 1) {
     throw new ArgumentError('fraction', 'a number between 0 and 1', fraction);
   }
@@ -111,23 +78,23 @@ export async function transferFunds(
   );
   const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP);
   const { fee } = unpackTx(
-    await _buildTx(Tag.SpendTx, {
-      ...options, senderId, recipientId, amount: desiredAmount,
+    await buildTxAsync({
+      ...options, tag: Tag.SpendTx, senderId, recipientId, amount: desiredAmount,
     }),
     Tag.SpendTx,
   );
   // 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 send(
-    await _buildTx(Tag.SpendTx, {
-      ...options, senderId, recipientId, amount,
+  return sendTransaction(
+    await buildTxAsync({
+      ...options, tag: Tag.SpendTx, senderId, recipientId, amount,
     }),
     options,
   );
 }
 
 type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
-& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions;
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendTransactionOptions;
 interface TransferFundsOptions extends TransferFundsOptionsType {}
 
 /**
@@ -140,17 +107,16 @@ interface TransferFundsOptions extends TransferFundsOptionsType {}
 export async function payForTransaction(
   transaction: Encoded.Transaction,
   options: PayForTransactionOptions,
-): ReturnType<typeof send> {
-  return send(
-    await _buildTx(
-      Tag.PayingForTx,
-      { ...options, payerId: options.onAccount.address, tx: transaction },
-    ),
+): ReturnType<typeof sendTransaction> {
+  return sendTransaction(
+    await buildTxAsync({
+      ...options, tag: Tag.PayingForTx, payerId: options.onAccount.address, tx: transaction,
+    }),
     options,
   );
 }
 
 interface PayForTransactionOptions extends
-  BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx'>, SendOptions {
+  BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx' | 'onNode'>, SendTransactionOptions {
   onAccount: AccountBase;
 }