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

package/src/contract/compiler/Http.ts

@@ -1,19 +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.
- */
 import { RestError } from '@azure/core-rest-pipeline';
 import {
   Compiler as CompilerApi,
@@ -60,7 +44,7 @@ export default class CompilerHttp extends CompilerBase {
           }
           if (Array.isArray(body)) {
             message += `\n${body
-              .map((e) => `${e.type}:${e.pos.line}:${e.pos.col}: ${e.message}${e.context != null ? `(${e.context})` : ''}`)
+              .map((e) => `${e.type}:${e.pos.line}:${e.pos.col}: ${e.message}${e.context != null ? ` (${e.context})` : ''}`)
               .join('\n')}`;
           }
           return message;
@@ -68,9 +52,10 @@ export default class CompilerHttp extends CompilerBase {
       ],
     });
     if (ignoreVersion !== true) {
-      const versionPromise = this.api.apiVersion().then(({ apiVersion }) => apiVersion);
+      const versionPromise = this.api.apiVersion()
+        .then(({ apiVersion }) => apiVersion, (error) => error);
       this.api.pipeline.addPolicy(
-        genVersionCheckPolicy('compiler', '/api-version', versionPromise, '7.0.1', '8.0.0'),
+        genVersionCheckPolicy('compiler', '/api-version', versionPromise, '7.1.1', '8.0.0'),
       );
     }
   }
@@ -80,13 +65,9 @@ export default class CompilerHttp extends CompilerBase {
     fileSystem?: Record<string, string>,
   ): Promise<{ bytecode: Encoded.ContractBytearray; aci: Aci }> {
     try {
-      const [bytecode, aci] = await Promise.all([
-        this.api.compileContract({ code: sourceCode, options: { fileSystem } })
-          .then((res) => res.bytecode as Encoded.ContractBytearray),
-        this.api.generateACI({ code: sourceCode, options: { fileSystem } }),
-      ]);
+      const res = await this.api.compileContract({ code: sourceCode, options: { fileSystem } });
       // TODO: should be fixed when the compiledAci interface gets updated
-      return { bytecode, aci: aci as Aci };
+      return res as { bytecode: Encoded.ContractBytearray; aci: Aci };
     } catch (error) {
       if (error instanceof RestError && error.statusCode === 400) {
         throw new CompilerError(error.message.replace(/^aci error:/, 'compile error:'));

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,32 +1,26 @@
-/*
- * 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';
+export {
+  encode, decode, Encoding, Encoded,
+} from './utils/encoder';
 export * from './aens';
 export { default as Contract } from './contract/Contract';
 export type { ContractMethodsBase } from './contract/Contract';

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;
 };