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

package/types-legacy/ts4.2/channel/Base.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { w3cwebsocket as W3CWebSocket } from 'websocket';
-import { SignTx, ChannelOptions, ChannelState, ChannelHandler, ChannelAction, ChannelStatus, ChannelFsm } from './internal';
+import { Tag } from '../tx/builder/constants';
+import { SignTx, ChannelOptions, ChannelState, ChannelHandler, ChannelAction, ChannelStatus, ChannelFsm, ChannelMessage, ChannelEvents } from './internal';
 import { Encoded } from '../utils/encoder';
-type EventCallback = (...args: any[]) => void;
+import { TxUnpacked } from '../tx/builder/schema.generated';
 /**
  * Channel
  * @example
@@ -31,14 +32,14 @@ export default class Channel {
     _nextRpcMessageId: number;
     _rpcCallbacks: Map<number, (message: object) => void>;
     _fsmId?: Encoded.Bytearray;
-    _messageQueue: object[];
+    _messageQueue: ChannelMessage[];
     _isMessageQueueLocked: boolean;
     _actionQueue: ChannelAction[];
     _isActionQueueLocked: boolean;
     _status: ChannelStatus;
     _fsm: ChannelFsm;
     _websocket: W3CWebSocket;
-    _state?: Encoded.Transaction;
+    _state: Encoded.Transaction | '';
     _options: ChannelOptions;
     _channelId?: Encoded.Channel;
     /**
@@ -99,24 +100,29 @@ export default class Channel {
      * Possible events:
      *
      *   - "error"
+     *   - "stateChanged"
+     *   - "statusChanged"
+     *   - "message"
+     *   - "peerDisconnected"
      *   - "onChainTx"
      *   - "ownWithdrawLocked"
      *   - "withdrawLocked"
      *   - "ownDepositLocked"
      *   - "depositLocked"
+     *   - "channelReestablished"
+     *   - "newContract"
      *
-     * TODO: the event list looks outdated
      *
      * @param eventName - Event name
      * @param callback - Callback function
      */
-    on(eventName: string, callback: EventCallback): void;
+    on<E extends keyof ChannelEvents>(eventName: E, callback: ChannelEvents[E]): void;
     /**
      * Remove event listener function
      * @param eventName - Event name
      * @param callback - Callback function
      */
-    off(eventName: string, callback: EventCallback): void;
+    off<E extends keyof ChannelEvents>(eventName: E, callback: ChannelEvents[E]): void;
     /**
      * Close the connection
      */
@@ -129,10 +135,18 @@ export default class Channel {
      * Get current state
      */
     state(): Promise<{
-        calls: Encoded.CallStateTree;
-        halfSignedTx: Encoded.Transaction | '';
-        signedTx: Encoded.Transaction;
-        trees: Encoded.StateTrees;
+        calls: TxUnpacked & {
+            tag: Tag.CallsMtree;
+        };
+        halfSignedTx?: TxUnpacked & {
+            tag: Tag.SignedTx;
+        };
+        signedTx?: TxUnpacked & {
+            tag: Tag.SignedTx;
+        };
+        trees: TxUnpacked & {
+            tag: Tag.StateTrees;
+        };
     }>;
     /**
      * Get current round
@@ -196,4 +210,3 @@ export default class Channel {
     shutdown(sign: SignTx): Promise<Encoded.Transaction>;
     static reconnect(options: ChannelOptions, txParams: any): Promise<Channel>;
 }
-export {};

package/types-legacy/ts4.2/channel/Spend.d.ts

@@ -2,8 +2,8 @@ import BigNumber from 'bignumber.js';
 import { SignTx, ChannelState } from './internal';
 import { Encoded } from '../utils/encoder';
 import Channel from './Base';
-import { unpackTx } from '../tx/builder';
 import { Tag } from '../tx/builder/constants';
+import { TxUnpacked } from '../tx/builder/schema.generated';
 export default class ChannelSpend extends Channel {
     /**
      * Trigger a transfer update
@@ -63,7 +63,9 @@ export default class ChannelSpend extends Channel {
     poi({ accounts, contracts }: {
         accounts: Encoded.AccountAddress[];
         contracts?: Encoded.ContractAddress[];
-    }): Promise<ReturnType<any>>;
+    }): Promise<TxUnpacked & {
+        tag: Tag.TreesPoi;
+    }>;
     /**
      * Get balances
      *

package/types-legacy/ts4.2/channel/internal.d.ts

@@ -2,6 +2,23 @@ import BigNumber from 'bignumber.js';
 import type Channel from './Base';
 import { Encoded } from '../utils/encoder';
 import { BaseError } from '../utils/errors';
+export interface ChannelEvents {
+    statusChanged: (status: ChannelStatus) => void;
+    stateChanged: (tx: Encoded.Transaction | '') => void;
+    depositLocked: () => void;
+    ownDepositLocked: () => void;
+    withdrawLocked: () => void;
+    ownWithdrawLocked: () => void;
+    peerDisconnected: () => void;
+    channelReestablished: () => void;
+    error: (error: Error) => void;
+    onChainTx: (tx: Encoded.Transaction, details: {
+        info: string;
+        type: string;
+    }) => void;
+    message: (message: string | Object) => void;
+    newContract: (contractAddress: Encoded.ContractAddress) => void;
+}
 export interface ChannelAction {
     guard: (channel: Channel, state?: ChannelFsm) => boolean;
     action: (channel: Channel, state?: ChannelFsm) => ChannelFsm;
@@ -92,10 +109,13 @@ interface ChannelMessageError {
     ];
     request: ChannelMessage;
 }
-export declare function emit(channel: Channel, ...args: any[]): void;
+export declare function emit<E extends keyof ChannelEvents>(channel: Channel, ...args: [
+    E,
+    ...Parameters<ChannelEvents[E]>
+]): void;
 export type ChannelStatus = 'connecting' | 'connected' | 'accepted' | 'halfSigned' | 'signed' | 'open' | 'closing' | 'closed' | 'died' | 'disconnected';
 export declare function changeStatus(channel: Channel, newStatus: ChannelStatus): void;
-export declare function changeState(channel: Channel, newState: Encoded.Transaction): void;
+export declare function changeState(channel: Channel, newState: Encoded.Transaction | ''): void;
 export declare function notify(channel: Channel, method: string, params?: object): void;
 export declare function enqueueAction(channel: Channel, guard: ChannelAction['guard'], action: () => {
     handler: ChannelHandler;

package/types-legacy/ts4.2/contract/Contract.d.ts

@@ -7,21 +7,19 @@
  */
 import { Encoder as Calldata } from '@aeternity/aepp-calldata';
 import { Tag, AensName } from '../tx/builder/constants';
-import { unpackTx } from '../tx/builder';
-import { BuildTxOptions } from '../tx';
-import { send, SendOptions } from '../spend';
+import { BuildTxOptions } from '../tx/builder';
 import { Encoded } from '../utils/encoder';
-import { ContractCallObject as NodeContractCallObject, ContractCallReturnType, Event as NodeEvent } from '../apis/node';
+import { ContractCallObject as NodeContractCallObject, Event as NodeEvent } from '../apis/node';
 import CompilerBase, { Aci } from './compiler/Base';
 import Node, { TransformNodeType } from '../Node';
-import { txDryRun } from '../chain';
+import { txDryRun, sendTransaction, SendTransactionOptions } from '../chain';
 import AccountBase from '../account/Base';
-type FunctionAci = Aci['encodedAci']['contract']['functions'][0];
+import { TxUnpacked } from '../tx/builder/schema.generated';
 interface Event extends NodeEvent {
     address: Encoded.ContractAddress;
     data: Encoded.ContractBytearray;
 }
-export interface ContractCallObject extends NodeContractCallObject {
+export interface ContractCallObject extends TransformNodeType<NodeContractCallObject> {
     returnValue: Encoded.ContractBytearray;
     log: Event[];
 }
@@ -33,11 +31,13 @@ interface DecodedEvent {
         address: Encoded.ContractAddress;
     };
 }
-type TxData = Awaited<ReturnType<typeof send>>;
+type TxData = Awaited<ReturnType<typeof sendTransaction>>;
 interface SendAndProcessReturnType {
-    result?: TransformNodeType<ContractCallObject>;
+    result?: ContractCallObject;
     hash: TxData['hash'];
-    tx: Awaited<ReturnType<any>>;
+    tx: TxUnpacked & {
+        tag: Tag.ContractCallTx | Tag.ContractCreateTx;
+    };
     txData: TxData;
     rawTx: Encoded.Transaction;
 }
@@ -45,15 +45,13 @@ export interface ContractMethodsBase {
     [key: string]: (...args: any[]) => any;
 }
 type MethodsToContractApi<M extends ContractMethodsBase> = {
-    [Name in keyof M]: M[Name] extends (...args: infer Args) => infer Ret ? (...args: [
+    [Name in keyof M]: M[Name] extends (...args: infer Args) => any ? (...args: [
         ...Args,
         ...[
         ] | [
             Name extends 'init' ? Parameters<Contract<M>['$deploy']>[1] : Parameters<Contract<M>['$call']>[2]
         ]
-    ]) => Promise<Awaited<ReturnType<Contract<M>['$call']>> & {
-        decodedResult?: Ret;
-    }> : never;
+    ]) => ReturnType<Contract<M>['$call']> : never;
 };
 type ContractWithMethods<M extends ContractMethodsBase> = Contract<M> & MethodsToContractApi<M>;
 type MethodNames<M extends ContractMethodsBase> = keyof M & string | 'init';
@@ -61,6 +59,15 @@ type MethodParameters<M extends ContractMethodsBase, Fn extends MethodNames<M>>
     init: any;
 } ? Parameters<M['init']> : [
 ] : Parameters<M[Fn]>;
+interface GetContractNameByEventOptions {
+    contractAddressToName?: {
+        [key: string]: string;
+    };
+}
+interface GetCallResultByHashReturnType<M extends ContractMethodsBase, Fn extends MethodNames<M>> {
+    decodedResult: ReturnType<M[Fn]>;
+    decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
+}
 /**
  * Generate contract ACI object with predefined js methods for contract usage - can be used for
  * creating a reference to already deployed contracts
@@ -79,56 +86,16 @@ type MethodParameters<M extends ContractMethodsBase, Fn extends MethodNames<M>>
  * stateful or not
  */
 declare class Contract<M extends ContractMethodsBase> {
-    /**
-     * 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 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
-     * @returns Signature
-     * @example
-     * ```js
-     * const aeSdk = new AeSdk({ ... })
-     * const contract = await aeSdk.initializeContract({ address: 'ct_asd2ks...' })
-     * const aensName = 'example.chain'
-     * const onAccount = new MemoryAccount(...) // Sign with a specific account
-     * // Preclaim signature
-     * const preclaimSig = await contract.$createDelegationSignature([], { onAccount })
-     * // Claim, transfer and revoke signature
-     * const aensDelegationSig = await contract
-     *   .$createDelegationSignature([aensName], { onAccount })
-     * ```
-     * @example
-     * ```js
-     * const aeSdk = new AeSdk({ ... })
-     * const contract = await aeSdk.initializeContract({ address: 'ct_asd2ks...' })
-     * const oracleQueryId = 'oq_...'
-     * const onAccount = new MemoryAccount(...) // Sign with a specific account
-     * // Oracle register and extend signature
-     * const oracleDelegationSig = await contract.$createDelegationSignature([], { onAccount })
-     * // Oracle respond signature
-     * const respondSig = await contract
-     *   .$createDelegationSignature([oracleQueryId], { onAccount, omitAddress: true })
-     * ```
-     */
-    $createDelegationSignature(ids?: Array<Encoded.Any | AensName>, _options?: {
-        omitAddress?: boolean;
-        onAccount?: AccountBase;
-    }): Promise<Uint8Array>;
+    #private;
     /**
      * Compile contract
      * @returns bytecode
      */
     $compile(): Promise<Encoded.ContractBytearray>;
-    protected _handleCallError({ returnType, returnValue }: {
-        returnType: ContractCallReturnType;
-        returnValue: Encoded.ContractBytearray;
-    }, transaction: string): void;
-    protected _sendAndProcess(tx: Encoded.Transaction, options: SendOptions): Promise<SendAndProcessReturnType>;
-    _estimateGas<Fn extends MethodNames<M>>(name: Fn, params: MethodParameters<M, Fn>, options?: object): Promise<number>;
+    $getCallResultByTxHash<Fn extends MethodNames<M>>(hash: Encoded.TxHash, fnName: Fn, options?: Parameters<Contract<M>['$decodeEvents']>[1]): Promise<GetCallResultByHashReturnType<M, Fn> & {
+        result: ContractCallObject;
+    }>;
+    _estimateGas<Fn extends MethodNames<M>>(name: Fn, params: MethodParameters<M, Fn>, options?: Omit<Parameters<Contract<M>['$call']>[2], 'callStatic'>): Promise<number>;
     /**
      * Deploy contract
      * @param params - Contract init function arguments array
@@ -141,12 +108,6 @@ declare class Contract<M extends ContractMethodsBase> {
         address?: Encoded.ContractAddress;
         decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
     }>;
-    /**
-     * Get function schema from contract ACI object
-     * @param name - Function name
-     * @returns function ACI
-     */
-    protected _getFunctionACI(name: string): Partial<FunctionAci>;
     /**
      * Call contract function
      * @param fn - Function name
@@ -154,27 +115,11 @@ declare class Contract<M extends ContractMethodsBase> {
      * @param options - Array of function arguments
      * @returns CallResult
      */
-    $call<Fn extends MethodNames<M>>(fn: Fn, params: MethodParameters<M, Fn>, options?: Partial<BuildTxOptions<Tag.ContractCallTx, 'callerId' | 'contractId' | 'callData'>> & Parameters<Contract<M>['$decodeEvents']>[1] & Omit<Parameters<Contract<M>['_sendAndProcess']>[1], 'onAccount' | 'onNode'> & Omit<Parameters<typeof txDryRun>[2], 'onNode'> & {
+    $call<Fn extends MethodNames<M>>(fn: Fn, params: MethodParameters<M, Fn>, options?: Partial<BuildTxOptions<Tag.ContractCallTx, 'callerId' | 'contractId' | 'callData'>> & Parameters<Contract<M>['$decodeEvents']>[1] & Omit<SendTransactionOptions, 'onAccount' | 'onNode'> & Omit<Parameters<typeof txDryRun>[2], 'onNode'> & {
         onAccount?: AccountBase;
         onNode?: Node;
         callStatic?: boolean;
-    }): Promise<{
-        decodedResult?: any;
-        decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
-    } & SendAndProcessReturnType>;
-    /**
-     * @param ctAddress - Contract address that emitted event
-     * @param nameHash - Hash of emitted event name
-     * @param options - Options
-     * @returns Contract name
-     * @throws {@link MissingEventDefinitionError}
-     * @throws {@link AmbiguousEventDefinitionError}
-     */
-    protected _getContractNameByEvent(ctAddress: Encoded.ContractAddress, nameHash: BigInt, { contractAddressToName }: {
-        contractAddressToName?: {
-            [key: string]: string;
-        };
-    }): string;
+    }): Promise<SendAndProcessReturnType & Partial<GetCallResultByHashReturnType<M, Fn>>>;
     /**
      * Decode Events
      * @param events - Array of encoded events (callRes.result.log)
@@ -183,7 +128,7 @@ declare class Contract<M extends ContractMethodsBase> {
      */
     $decodeEvents(events: Event[], { omitUnknown, ...opt }?: {
         omitUnknown?: boolean;
-    } & Parameters<Contract<M>['_getContractNameByEvent']>[2]): DecodedEvent[];
+    } & GetContractNameByEventOptions): DecodedEvent[];
     static initialize<M extends ContractMethodsBase>({ onCompiler, onNode, bytecode, aci, address, sourceCodePath, sourceCode, fileSystem, validateBytecode, ...otherOptions }: Omit<ConstructorParameters<typeof Contract>[0], 'aci' | 'address'> & {
         validateBytecode?: boolean;
         aci?: Aci;

package/types-legacy/ts4.2/contract/compiler/Base.d.ts

@@ -1,25 +1,21 @@
 import { Encoded } from '../../utils/encoder';
-import { Aci as BaseAci } from '../../apis/compiler';
 interface FunctionAci {
     arguments: any[];
     name: string;
     payable: boolean;
-    returns: string;
+    returns: any;
     stateful: boolean;
 }
-export interface Aci extends BaseAci {
-    encodedAci: {
-        contract: {
-            name: string;
-            event: any;
-            kind: string;
-            state: any;
-            type_defs: any[];
-            functions: FunctionAci[];
-        };
+export type Aci = Array<{
+    contract?: {
+        name: string;
+        event?: any;
+        functions: FunctionAci[];
+        kind: string;
+        payable: boolean;
+        typedefs: any[];
     };
-    externalEncodedAci: any[];
-}
+}>;
 /**
  * A base class for all compiler implementations
  */

package/types-legacy/ts4.2/contract/delegation-signature.d.ts

@@ -0,0 +1,43 @@
+import { Encoded } from '../utils/encoder';
+import { AensName } from '../tx/builder/constants';
+import AccountBase from '../account/Base';
+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 function createDelegationSignature(contractAddress: Encoded.ContractAddress, ids: Array<Encoded.Any | AensName>, options: {
+    omitAddress?: boolean;
+    onAccount: AccountBase;
+    onNode: Node;
+}): Promise<Uint8Array>;

package/types-legacy/ts4.2/contract/ga.d.ts

@@ -1,13 +1,14 @@
+/// <reference types="node" />
 /**
  * Generalized Account module - routines to use generalized account
  */
-import { Tag } from '../tx/builder/constants';
-import { BuildTxOptions } from '../tx';
+import { Int, Tag } from '../tx/builder/constants';
+import { BuildTxOptions } from '../tx/builder';
 import { Encoded } from '../utils/encoder';
 import AccountBase from '../account/Base';
 import Contract from './Contract';
-import { SendOptions } from '../spend';
 import Node from '../Node';
+import { SendTransactionOptions } from '../chain';
 import CompilerBase from './compiler/Base';
 /**
  * Convert current account to GA
@@ -24,21 +25,36 @@ export declare function createGeneralizedAccount(authFnName: string, args: any[]
     rawTx: Encoded.Transaction;
     gaContractId: Encoded.ContractAddress;
 }>>;
-interface CreateGeneralizedAccountOptions extends BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>, SendOptions, Pick<Parameters<typeof Contract.initialize>[0], 'bytecode' | 'aci' | 'sourceCodePath' | 'sourceCode' | 'fileSystem'> {
+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`
+ * 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 declare function buildAuthTxHash(transaction: Encoded.Transaction, { onNode }: {
+export declare function buildAuthTxHash(transaction: Encoded.Transaction, { fee, gasPrice, onNode }: {
+    fee?: Int;
+    gasPrice?: Int;
     onNode: Node;
-}): Promise<Uint8Array>;
+}): Promise<Buffer>;
+/**
+ * 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 declare function buildAuthTxHashByGaMetaTx(transaction: Encoded.Transaction, { onNode }: {
+    onNode: Node;
+}): Promise<Buffer>;
 export {};

package/types-legacy/ts4.2/index-browser.d.ts

@@ -2,14 +2,15 @@ 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';
+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/types-legacy/ts4.2/oracle.d.ts

@@ -5,13 +5,11 @@
  * https://github.com/aeternity/protocol/blob/master/ORACLE.md in the protocol
  * repository.
  */
-import BigNumber from 'bignumber.js';
-import { send, SendOptions } from './spend';
+import { BuildTxOptions } from './tx/builder';
 import { ORACLE_TTL_TYPES } from './tx/builder/schema';
 import { Tag } from './tx/builder/constants';
 import { Encoded } from './utils/encoder';
-import { _getPollInterval } from './chain';
-import { BuildTxOptions } from './tx';
+import { _getPollInterval, sendTransaction, SendTransactionOptions } from './chain';
 import Node from './Node';
 import AccountBase from './account/Base';
 type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries'];
@@ -25,7 +23,7 @@ type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['orac
  * @param options.onNode - Node to use
  * @returns Callback to stop polling function
  */
-export declare function pollForQueries(oracleId: Encoded.OracleAddress, onQuery: (queries: OracleQueries) => void, { interval, onNode, ...options }: {
+export declare function pollForQueries(oracleId: Encoded.OracleAddress, onQuery: (query: OracleQueries[number]) => void, { interval, onNode, ...options }: {
     interval?: number;
     onNode: Node;
 } & Parameters<typeof _getPollInterval>[1]): () => void;
@@ -55,7 +53,7 @@ export declare function getQueryObject(oracleId: Encoded.OracleAddress, queryId:
 interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
     decodedQuery: string;
     decodedResponse: string;
-    respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) => ReturnType<typeof respondToQuery>;
+    respond: (response: string, options?: Parameters<typeof respondToQuery>[2]) => ReturnType<typeof respondToQuery>;
     pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) => ReturnType<typeof pollForQueryResponse>;
 }
 /**
@@ -71,8 +69,8 @@ interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQue
  * @param options.ttl - Transaction time to leave
  * @returns Query object
  */
-export declare function postQueryToOracle(oracleId: Encoded.OracleAddress, query: string, options: PostQueryToOracleOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>>;
-type PostQueryToOracleOptionsType = Parameters<typeof send>[1] & Parameters<typeof getQueryObject>[2] & BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'> & {
+export declare function postQueryToOracle(oracleId: Encoded.OracleAddress, query: string, options: PostQueryToOracleOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getQueryObject>>>;
+type PostQueryToOracleOptionsType = Parameters<typeof sendTransaction>[1] & Parameters<typeof getQueryObject>[2] & BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'> & {
     queryTtlType?: ORACLE_TTL_TYPES;
     queryTtlValue?: number;
     responseTtlType?: ORACLE_TTL_TYPES;
@@ -83,7 +81,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
@@ -91,8 +88,8 @@ interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {
  * @param options.oracleTtlValue - Oracle time to leave for extend
  * @returns Oracle object
  */
-export declare function extendOracleTtl(oracleId: Encoded.OracleAddress, options: ExtendOracleTtlOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type ExtendOracleTtlOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'> & {
+export declare function extendOracleTtl(options: ExtendOracleTtlOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
+type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'> & {
     oracleTtlType?: ORACLE_TTL_TYPES;
     oracleTtlValue?: number;
 };
@@ -101,7 +98,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
@@ -110,8 +106,8 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
  * @param options.ttl - Transaction time to leave
  * @returns Oracle object
  */
-export declare function respondToQuery(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, response: string, options: RespondToQueryOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type RespondToQueryOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'> & {
+export declare function respondToQuery(queryId: Encoded.OracleQueryId, response: string, options: RespondToQueryOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
+type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'> & {
     responseTtlType?: ORACLE_TTL_TYPES;
     responseTtlValue?: number;
 };
@@ -150,9 +146,8 @@ interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleBy
  * @param options.ttl - Transaction time to leave
  * @returns Oracle object
  */
-export declare function registerOracle(queryFormat: string, responseFormat: string, options: RegisterOracleOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type RegisterOracleOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'queryFee' | 'oracleTtlType' | 'oracleTtlValue'> & {
-    queryFee?: number | string | BigNumber;
+export declare function registerOracle(queryFormat: string, responseFormat: string, options: RegisterOracleOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
+type RegisterOracleOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'oracleTtlType' | 'oracleTtlValue'> & {
     oracleTtlType?: ORACLE_TTL_TYPES;
     oracleTtlValue?: number;
 };