@aeternity/aepp-sdk 13.3.3 → 14.1.0

package/src/contract/ga.ts

@@ -1,138 +0,0 @@
-/**
- * Generalized Account module - routines to use generalized account
- */
-
-import { ConsensusProtocolVersion, Int, Tag } from '../tx/builder/constants';
-import {
-  buildContractIdByContractTx, buildTx, buildTxAsync, BuildTxOptions, unpackTx,
-} from '../tx/builder';
-import { hash } from '../utils/crypto';
-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 Node from '../Node';
-import { getAccount } from '../chain';
-import { sendTransaction, SendTransactionOptions } from '../send-transaction';
-import CompilerBase from './compiler/Base';
-
-/**
- * Convert current account to GA
- * @category contract
- * @param authFnName - Authorization function name
- * @param args - init arguments
- * @param options - Options
- * @returns General Account Object
- */
-export async function createGeneralizedAccount(
-  authFnName: string,
-  args: any[],
-  {
-    onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem, ...options
-  }: CreateGeneralizedAccountOptions,
-): Promise<Readonly<{
-    owner: Encoded.AccountAddress;
-    transaction: Encoded.TxHash;
-    rawTx: Encoded.Transaction;
-    gaContractId: Encoded.ContractAddress;
-  }>> {
-  const ownerId = onAccount.address;
-  if ((await getAccount(ownerId, { onNode })).kind === 'generalized') {
-    throw new IllegalArgumentError(`Account ${ownerId} is already GA`);
-  }
-
-  const contract = await Contract.initialize<{ init: (...a: any[]) => void }>({
-    onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem,
-  });
-
-  const tx = await buildTxAsync({
-    _isInternalBuild: true,
-    ...options,
-    tag: Tag.GaAttachTx,
-    onNode,
-    code: await contract.$compile(),
-    gasLimit: options.gasLimit ?? await contract._estimateGas('init', args, options),
-    ownerId,
-    callData: contract._calldata.encode(contract._name, 'init', args),
-    authFun: hash(authFnName),
-  });
-  const { hash: transaction, rawTx } = await sendTransaction(tx, {
-    onNode, onAccount, onCompiler, ...options,
-  });
-  const contractId = buildContractIdByContractTx(rawTx);
-
-  return Object.freeze({
-    owner: ownerId,
-    transaction,
-    rawTx,
-    gaContractId: contractId,
-  });
-}
-
-interface CreateGeneralizedAccountOptions extends
-  BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>,
-  SendTransactionOptions,
-  Pick<
-  Parameters<typeof Contract.initialize>[0],
-  'bytecode' | 'aci' | 'sourceCodePath' | 'sourceCode' | 'fileSystem'
-  > {
-  onAccount: AccountBase;
-  onCompiler: CompilerBase;
-  onNode: Node;
-  gasLimit?: number;
-}
-
-/**
- * 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<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/deprecated.ts

@@ -1,77 +0,0 @@
-import { TypeResolver, ContractByteArrayEncoder } from '@aeternity/aepp-calldata';
-import { AciValue } from './utils/typed-data';
-import { Encoded } from './utils/encoder';
-import { RpcError } from './aepp-wallet-communication/schema';
-import { ORACLE_TTL_TYPES } from './tx/builder/schema';
-
-/**
- * @category exception
- * @deprecated this exception is not thrown anymore
- */
-export class RpcBroadcastError extends RpcError {
-  static override code = 3;
-
-  override code = 3;
-
-  constructor(data?: any) {
-    super('Broadcast failed');
-    this.data = data;
-    this.name = 'RpcBroadcastError';
-  }
-}
-
-/**
- * @deprecated use isAuctionName instead
- */
-export const NAME_BID_MAX_LENGTH = 12; // # this is the max length for a domain to be part of a bid
-
-/**
- * @deprecated use ContractByteArrayEncoder:encodeWithType from \@aeternity/aepp-calldata
- */
-export function encodeFateValue(value: unknown, aci: AciValue): Encoded.ContractBytearray {
-  const valueType = new TypeResolver().resolveType(aci, {});
-  return new ContractByteArrayEncoder().encodeWithType(value, valueType);
-}
-
-/**
- * @deprecated use ContractByteArrayEncoder:decodeWithType from \@aeternity/aepp-calldata
- */
-export function decodeFateValue(value: Encoded.ContractBytearray, aci: AciValue): any {
-  const valueType = new TypeResolver().resolveType(aci, {});
-  return new ContractByteArrayEncoder().decodeWithType(value, valueType);
-}
-
-/**
- * @deprecated inlined in buildTx or use `180000`
- */
-export const NAME_TTL = 180000;
-
-/**
- * @deprecated inlined in buildTx or use `36000`
- */
-export const NAME_MAX_TTL = 36000;
-
-/**
- * @deprecated inlined in buildTx or use `60 * 60`
- */
-export const NAME_MAX_CLIENT_TTL = 60 * 60;
-
-/**
- * @deprecated inlined in buildTx or use `60 * 60`
- */
-export const CLIENT_TTL = NAME_MAX_CLIENT_TTL;
-
-/**
- * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 500 }`
- */
-export const ORACLE_TTL = { type: ORACLE_TTL_TYPES.delta, value: 500 };
-
-/**
- * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
- */
-export const QUERY_TTL = { type: ORACLE_TTL_TYPES.delta, value: 10 };
-
-/**
- * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
- */
-export const RESPONSE_TTL = { type: ORACLE_TTL_TYPES.delta, value: 10 };

package/src/index-browser.ts

@@ -1,121 +0,0 @@
-export {
-  _getPollInterval, getHeight, poll, awaitHeight, waitForTxConfirm,
-  getAccount, getBalance, getCurrentGeneration, getGeneration, getMicroBlockTransactions,
-  getKeyBlock, getMicroBlockHeader, txDryRun, getContractByteCode, getContract, getName,
-  resolveName,
-} from './chain';
-export { InvalidTxError, sendTransaction } from './send-transaction';
-export {
-  getAddressFromPriv, isAddressValid, genSalt, encodeUnsigned, hash, encodeContractAddress,
-  generateKeyPairFromSecret, generateKeyPair, sign, verify, messageToHash, signMessage,
-  verifyMessage, isValidKeypair,
-} from './utils/crypto';
-export {
-  signJwt, unpackJwt, verifyJwt, isJwt, ensureJwt,
-} from './utils/jwt';
-export type { Jwt } from './utils/jwt';
-export { recover, dump } from './utils/keystore';
-export type { Keystore } from './utils/keystore';
-export { toBytes } from './utils/bytes';
-export {
-  buildTx, buildTxAsync, buildTxHash, unpackTx, buildContractIdByContractTx,
-} from './tx/builder';
-export {
-  buildContractId, oracleQueryId, produceNameId, commitmentHash, readInt, isNameValid, ensureName,
-  getDefaultPointerKey, getMinimumNameFee, computeBidFee, computeAuctionEndBlock, isAuctionName,
-} from './tx/builder/helpers';
-export {
-  MAX_AUTH_FUN_GAS, MIN_GAS_PRICE,
-  NAME_FEE_MULTIPLIER, NAME_FEE_BID_INCREMENT, NAME_BID_TIMEOUT_BLOCKS, NAME_MAX_LENGTH_FEE,
-  NAME_BID_RANGES, ConsensusProtocolVersion, VmVersion, AbiVersion, Tag, DRY_RUN_ACCOUNT,
-} from './tx/builder/constants';
-export type { Int, AensName } from './tx/builder/constants';
-// TODO: move to constants
-export { ORACLE_TTL_TYPES, CallReturnType } from './tx/builder/schema';
-export { DelegationTag } from './tx/builder/delegation/schema';
-export { packDelegation, unpackDelegation } from './tx/builder/delegation';
-export {
-  getExecutionCost, getExecutionCostBySignedTx, getExecutionCostUsingNode,
-} from './tx/execution-cost';
-export { default as getTransactionSignerAddress } from './tx/transaction-signer';
-export {
-  AE_AMOUNT_FORMATS, formatAmount, toAe, toAettos, prefixedAmount,
-} from './utils/amount-formatter';
-export {
-  DerivationError, deriveChild, derivePathFromKey, getMasterKeyFromSeed, derivePathFromSeed,
-  getKeyPair, generateSaveHDWalletFromSeed, getSaveHDWalletAccounts, getHdWalletAccountFromSeed,
-} from './utils/hd-wallet';
-export {
-  encode, decode, Encoding, Encoded,
-} from './utils/encoder';
-export { hashTypedData, hashDomain, hashJson } from './utils/typed-data';
-export {
-  aensRevoke, aensUpdate, aensTransfer, aensQuery, aensClaim, aensPreclaim, aensBid,
-} from './aens';
-export { default as Contract } from './contract/Contract';
-export type { ContractMethodsBase } from './contract/Contract';
-export {
-  pollForQueries, pollForQueryResponse, getQueryObject, postQueryToOracle, extendOracleTtl,
-  respondToQuery, getOracleObject, registerOracle,
-} from './oracle';
-export { spend, transferFunds, payForTransaction } from './spend';
-export { createGeneralizedAccount, buildAuthTxHash, buildAuthTxHashByGaMetaTx } from './contract/ga';
-
-export { default as AeSdkMethods } from './AeSdkMethods';
-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 AccountBase } from './account/Base';
-export { default as MemoryAccount } from './account/Memory';
-export { default as AccountGeneralized } from './account/Generalized';
-export { default as AccountLedger } from './account/Ledger';
-export { default as AccountLedgerFactory } from './account/LedgerFactory';
-export { default as CompilerBase } from './contract/compiler/Base';
-export { default as CompilerHttp } from './contract/compiler/Http';
-export { default as Channel } from './channel/Contract';
-export {
-  default as _MiddlewareSubscriber,
-  MiddlewareSubscriberError as _MiddlewareSubscriberError,
-  MiddlewareSubscriberDisconnected as _MiddlewareSubscriberDisconnected,
-} from './MiddlewareSubscriber';
-export { default as _Middleware } from './Middleware';
-
-export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
-export {
-  MESSAGE_DIRECTION, WALLET_TYPE, SUBSCRIPTION_TYPES, METHODS, RPC_STATUS, RpcError,
-  RpcInvalidTransactionError, RpcRejectedByUserError, RpcUnsupportedProtocolError,
-  RpcConnectionDenyError, RpcNotAuthorizeError, RpcPermissionDenyError, RpcInternalError,
-  RpcMethodNotFoundError,
-} 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 {
-  BaseError, AccountError, AensError, AeppError, ChannelError, CompilerError, ContractError,
-  CryptographyError, NodeError, TransactionError, WalletError, ArgumentError, IllegalArgumentError,
-  ArgumentCountMismatchError, InsufficientBalanceError, MissingParamError, NoSerializerFoundError,
-  RequestTimedOutError, TxTimedOutError, TypeError, UnsupportedPlatformError,
-  UnsupportedProtocolError, NotImplementedError, UnsupportedVersionError, LogicError, InternalError,
-  UnexpectedTsError, UnavailableAccountError, AensPointerContextError, InsufficientNameFeeError,
-  InvalidAensNameError, InvalidRpcMessageError, MissingCallbackError, UnAuthorizedAccountError,
-  UnknownRpcClientError, UnsubscribedAccountError, ChannelCallError, ChannelConnectionError,
-  ChannelPingTimedOutError, UnexpectedChannelMessageError, ChannelIncomingMessageError,
-  UnknownChannelStateError, InvalidAuthDataError, BytecodeMismatchError, DuplicateContractError,
-  InactiveContractError, InvalidMethodInvocationError, MissingContractAddressError,
-  MissingContractDefError, MissingFunctionNameError, NodeInvocationError,
-  NoSuchContractFunctionError, NotPayableFunctionError, MissingEventDefinitionError,
-  AmbiguousEventDefinitionError, InvalidChecksumError, InvalidPasswordError,
-  MerkleTreeHashMismatchError, MissingNodeInTreeError, UnknownNodeLengthError,
-  UnknownPathNibbleError, DuplicateNodeError, NodeNotFoundError, DecodeError, PayloadLengthError,
-  DryRunError, IllegalBidFeeError, InvalidSignatureError, PrefixNotFoundError, SchemaNotFoundError,
-  TagNotFoundError, TxNotInChainError, AlreadyConnectedError, NoWalletConnectedError,
-  RpcConnectionError,
-} from './utils/errors';
-export {
-  RpcBroadcastError, NAME_BID_MAX_LENGTH, encodeFateValue, decodeFateValue,
-  NAME_TTL, NAME_MAX_TTL, NAME_MAX_CLIENT_TTL, CLIENT_TTL,
-  ORACLE_TTL, QUERY_TTL, RESPONSE_TTL,
-} from './deprecated';

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './index-browser';
-
-export { default as CompilerCli } from './contract/compiler/Cli';
-export { default as CompilerCli8 } from './contract/compiler/Cli8';
-export { default as getFileSystem } from './contract/compiler/getFileSystem';
-export { default as CompilerHttpNode } from './contract/compiler/HttpNode';

package/src/oracle.ts

@@ -1,311 +0,0 @@
-/**
- * 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 { mapObject, pause } from './utils/other';
-import { oracleQueryId } from './tx/builder/helpers';
-import { unpackTx, buildTxAsync, BuildTxOptions } from './tx/builder';
-import { Tag } from './tx/builder/constants';
-import { RequestTimedOutError } from './utils/errors';
-import {
-  decode, encode, Encoded, Encoding,
-} from './utils/encoder';
-import { _getPollInterval, getHeight } from './chain';
-import { sendTransaction, SendTransactionOptions } from './send-transaction';
-import Node from './Node';
-import AccountBase from './account/Base';
-
-type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries'];
-
-/**
- * Poll for oracle queries
- * @category oracle
- * @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: Encoded.OracleAddress,
-  onQuery: (query: OracleQueries[number]) => void,
-  { interval, ...options }: { interval?: number; onNode: Node }
-  & Parameters<typeof _getPollInterval>[1],
-): () => void {
-  const knownQueryIds = new Set();
-  const checkNewQueries = async (): Promise<void> => {
-    const queries = ((await options.onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries ?? [])
-      .filter(({ id }) => !knownQueryIds.has(id));
-    queries.forEach((query) => {
-      knownQueryIds.add(query.id);
-      onQuery(query);
-    });
-  };
-
-  let stopped = false;
-
-  // eslint-disable-next-line @typescript-eslint/no-floating-promises
-  (async () => {
-    interval ??= await _getPollInterval('micro-block', options);
-    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; };
-}
-
-/**
- * Poll for oracle query response
- * @category oracle
- * @param oracleId - Oracle public key
- * @param queryId - Oracle Query id
- * @param options - Options object
- * @param options.interval - Poll interval
- * @param options.onNode - Node to use
- * @returns OracleQuery object
- */
-export async function pollForQueryResponse(
-  oracleId: Encoded.OracleAddress,
-  queryId: Encoded.OracleQueryId,
-  { interval, ...options }:
-  { interval?: number; onNode: Node } & Parameters<typeof _getPollInterval>[1],
-): Promise<string> {
-  interval ??= await _getPollInterval('micro-block', options);
-  let height;
-  let ttl;
-  let response;
-  do {
-    ({ response, ttl } = await options.onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId));
-    const responseBuffer = decode(response as Encoded.OracleResponse);
-    if (responseBuffer.length > 0) return responseBuffer.toString();
-    await pause(interval);
-    height = await getHeight({ ...options, cached: true });
-  } while (ttl >= height);
-  throw new RequestTimedOutError(height);
-}
-
-/**
- * Constructor for OracleQuery Object (helper object for using OracleQuery)
- * @category oracle
- * @param oracleId - Oracle public key
- * @param queryId - Oracle Query id
- * @param options - Options
- * @returns OracleQuery object
- */
-export async function getQueryObject(
-  oracleId: Encoded.OracleAddress,
-  queryId: Encoded.OracleQueryId,
-  options: RespondToQueryOptions & Parameters<typeof pollForQueryResponse>[2],
-): Promise<GetQueryObjectReturnType> {
-  const record = await options.onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId);
-  return {
-    ...record,
-    decodedQuery: decode(record.query as Encoded.OracleQueryId).toString(),
-    decodedResponse: decode(record.response as Encoded.OracleResponse).toString(),
-    respond: async (response, opt) => (
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      respondToQuery(queryId, response, { ...options, ...opt })
-    ),
-    pollForResponse: async (opt) => pollForQueryResponse(oracleId, queryId, { ...options, ...opt }),
-  };
-}
-
-interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
-  decodedQuery: string;
-  decodedResponse: string;
-  respond: (response: string, options?: Parameters<typeof respondToQuery>[2]) =>
-  ReturnType<typeof respondToQuery>;
-  pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) =>
-  ReturnType<typeof pollForQueryResponse>;
-}
-
-/**
- * Post query to oracle
- * @category oracle
- * @param oracleId - Oracle public key
- * @param query - Oracle query object
- * @param options - Options object
- * @returns Query object
- */
-export async function postQueryToOracle(
-  oracleId: Encoded.OracleAddress,
-  query: string,
-  options: PostQueryToOracleOptions,
-): Promise<
-  Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getQueryObject>>
-  > {
-  const senderId = options.onAccount.address;
-
-  const oracleQueryTx = await buildTxAsync({
-    _isInternalBuild: true,
-    ...options,
-    tag: Tag.OracleQueryTx,
-    oracleId,
-    senderId,
-    query,
-  });
-  const { nonce } = unpackTx(oracleQueryTx, Tag.OracleQueryTx);
-  const queryId = oracleQueryId(senderId, nonce, oracleId);
-  return {
-    ...await sendTransaction(oracleQueryTx, options),
-    ...await getQueryObject(oracleId, queryId, options),
-  };
-}
-
-type PostQueryToOracleOptionsType = Parameters<typeof sendTransaction>[1]
-& Parameters<typeof getQueryObject>[2]
-& BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query'>;
-interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {}
-
-/**
- * Extend oracle ttl
- * @category oracle
- * @param options - Options object
- * @returns Oracle object
- */
-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({
-    _isInternalBuild: true,
-    ...options,
-    tag: Tag.OracleExtendTx,
-    oracleId,
-  });
-  return {
-    ...await sendTransaction(oracleExtendTx, options),
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    ...await getOracleObject(oracleId, options),
-  };
-}
-
-type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
-& BuildTxOptions<Tag.OracleExtendTx, 'callerId' | 'oracleId'>;
-interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
-
-/**
- * Extend oracle ttl
- * @category oracle
- * @param queryId - Oracle query id
- * @param response - Oracle query response
- * @param options - Options object
- * @returns Oracle object
- */
-export async function respondToQuery(
-  queryId: Encoded.OracleQueryId,
-  response: string,
-  options: RespondToQueryOptions,
-): Promise<
-  Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>
-  > {
-  const oracleId = encode(decode(options.onAccount.address), Encoding.OracleAddress);
-  const oracleRespondTx = await buildTxAsync({
-    _isInternalBuild: true,
-    ...options,
-    tag: Tag.OracleResponseTx,
-    oracleId,
-    queryId,
-    response,
-  });
-  return {
-    ...await sendTransaction(oracleRespondTx, options),
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    ...await getOracleObject(oracleId, options),
-  };
-}
-
-type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
-& BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response'>;
-interface RespondToQueryOptions extends RespondToQueryOptionsType {}
-
-/**
- * Constructor for Oracle Object (helper object for using Oracle)
- * @category oracle
- * @param oracleId - Oracle public key
- * @param options - Options
- * @returns Oracle object
- */
-export async function getOracleObject(
-  oracleId: Encoded.OracleAddress,
-  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,
-        (...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(
-            ...['extendOracle', 'respondToQuery'].includes(name) ? [] : [oracleId],
-            ...args,
-          );
-        },
-      ],
-    ),
-  } as any;
-}
-
-interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleByPubkey']>> {
-  id: Encoded.OracleAddress;
-  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;
-}
-
-/**
- * Register oracle
- * @category oracle
- * @param queryFormat - Format of query
- * @param responseFormat - Format of query response
- * @param options - Options
- * @returns Oracle object
- */
-export async function registerOracle(
-  queryFormat: string,
-  responseFormat: string,
-  options: RegisterOracleOptions,
-): Promise<
-  Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>
-  > {
-  const accountId = options.onAccount.address;
-  const oracleRegisterTx = await buildTxAsync({
-    _isInternalBuild: true,
-    ...options,
-    tag: Tag.OracleRegisterTx,
-    accountId,
-    queryFormat,
-    responseFormat,
-  });
-  return {
-    ...await sendTransaction(oracleRegisterTx, options),
-    ...await getOracleObject(encode(decode(accountId), Encoding.OracleAddress), options),
-  };
-}
-
-type RegisterOracleOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
-& BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat'>;
-interface RegisterOracleOptions extends RegisterOracleOptionsType {}