@aeternity/aepp-sdk 12.1.2 → 13.0.0-alpha.0

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

@@ -0,0 +1,107 @@
+import BigNumber from 'bignumber.js';
+import type Channel from './Base';
+import { Encoded } from '../utils/encoder';
+import { BaseError } from '../utils/errors';
+export interface ChannelAction {
+    guard: (channel: Channel, state?: ChannelFsm) => boolean;
+    action: (channel: Channel, state?: ChannelFsm) => ChannelFsm;
+}
+interface SignOptions {
+    updates?: any[];
+    [k: string]: any;
+}
+export type SignTxWithTag = (tag: string, tx: Encoded.Transaction, options?: SignOptions) => (Promise<Encoded.Transaction>);
+export type SignTx = (tx: Encoded.Transaction, options?: SignOptions) => (Promise<Encoded.Transaction | number | null>);
+export interface ChannelOptions {
+    existingFsmId?: Encoded.Bytearray;
+    url: string;
+    /**
+     * @see {@link https://github.com/aeternity/protocol/blob/6734de2e4c7cce7e5e626caa8305fb535785131d/node/api/channels_api_usage.md#channel-establishing-parameters}
+     */
+    initiatorId: Encoded.AccountAddress;
+    responderId: Encoded.AccountAddress;
+    lockPeriod: number;
+    pushAmount: number;
+    initiatorAmount: BigNumber;
+    responderAmount: BigNumber;
+    channelReserve?: BigNumber | number;
+    ttl?: number;
+    host: string;
+    port: number;
+    role: 'initiator' | 'responder';
+    minimumDepthStrategy?: 'txfee' | 'plain';
+    minimumDepth?: number;
+    fee?: BigNumber | number;
+    gasPrice?: BigNumber | number;
+    signedTx?: string;
+    existingChannelId?: string;
+    offChainTx?: string;
+    reconnectTx?: string;
+    timeoutIdle?: number;
+    timeoutFundingCreate?: number;
+    timeoutFundingSign?: number;
+    timeoutFundingLock?: number;
+    timeoutSign?: number;
+    timeoutAccept?: number;
+    timeoutInitialized?: number;
+    timeoutAwaitingOpen?: number;
+    statePassword?: string;
+    debug: boolean;
+    sign: SignTxWithTag;
+    offchainTx?: string;
+}
+export interface ChannelHandler extends Function {
+    enter?: Function;
+}
+export interface ChannelState {
+    signedTx: Encoded.Transaction;
+    resolve: (r?: any) => void;
+    reject: (e: BaseError) => void;
+    sign: SignTx;
+    handler?: ChannelHandler;
+    onOnChainTx?: (tx: Encoded.Transaction) => void;
+    onOwnWithdrawLocked?: () => void;
+    onWithdrawLocked?: () => void;
+    onOwnDepositLocked?: () => void;
+    onDepositLocked?: () => void;
+    closeTx?: string;
+}
+export interface ChannelFsm {
+    handler: ChannelHandler;
+    state?: ChannelState | {
+        resolve: Function;
+        reject: Function;
+    };
+}
+export interface ChannelMessage {
+    id?: number;
+    method: string;
+    params: any;
+    payload?: any;
+    data?: any;
+    error?: ChannelMessageError;
+}
+interface ChannelMessageError {
+    code: number;
+    message: string;
+    data: [
+        {
+            message: string;
+            code: number;
+        }
+    ];
+    request: ChannelMessage;
+}
+export declare function emit(channel: Channel, ...args: any[]): 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 notify(channel: Channel, method: string, params?: object): void;
+export declare function enqueueAction(channel: Channel, guard: ChannelAction['guard'], action: () => {
+    handler: ChannelHandler;
+    state?: Partial<ChannelState>;
+}): Promise<any>;
+export declare function disconnect(channel: Channel): void;
+export declare function call(channel: Channel, method: string, params: any): Promise<any>;
+export declare function initialize(channel: Channel, connectionHandler: Function, openHandler: Function, { url, ...channelOptions }: ChannelOptions): Promise<void>;
+export {};

package/types-legacy/ts4.5/contract/CompilerHttp.d.ts

@@ -0,0 +1,18 @@
+import { Compiler as CompilerApi } from '../apis/compiler';
+/**
+ * Contract Compiler over HTTP
+ *
+ * This class include api call's related to contract compiler functionality.
+ * @category contract
+ * @example CompilerHttp('COMPILER_URL')
+ */
+export default class CompilerHttp extends CompilerApi {
+    /**
+     * @param compilerUrl - Url for compiler API
+     * @param options - Options
+     * @param options.ignoreVersion - Don't check compiler version
+     */
+    constructor(compilerUrl: string, { ignoreVersion }?: {
+        ignoreVersion?: boolean;
+    });
+}

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

@@ -0,0 +1,237 @@
+/// <reference types="@aeternity__aepp-calldata" />
+/**
+ * Contract module - routines to interact with the æternity contract
+ *
+ * High level documentation of the contracts are available at
+ * https://github.com/aeternity/protocol/tree/master/contracts and
+ */
+import { Encoder as Calldata } from '@aeternity/aepp-calldata';
+import { Tag, AensName } from '../tx/builder/constants';
+import { unpackTx } from '../tx/builder';
+import { send } from '../spend';
+import { Encoded } from '../utils/encoder';
+import { Aci as BaseAci } from '../apis/compiler';
+import { ContractCallObject as NodeContractCallObject, ContractCallReturnType, Event as NodeEvent } from '../apis/node';
+import CompilerHttp from './CompilerHttp';
+import Node, { TransformNodeType } from '../Node';
+import AccountBase from '../account/Base';
+interface FunctionACI {
+    arguments: any[];
+    name: string;
+    payable: boolean;
+    returns: string;
+    stateful: boolean;
+}
+interface Aci extends BaseAci {
+    encodedAci: {
+        contract: {
+            name: string;
+            event: any;
+            kind: string;
+            state: any;
+            type_defs: any[];
+            functions: FunctionACI[];
+        };
+    };
+    externalEncodedAci: any[];
+}
+interface Event extends NodeEvent {
+    address: Encoded.ContractAddress;
+    data: Encoded.ContractBytearray;
+}
+export interface ContractCallObject extends NodeContractCallObject {
+    returnValue: Encoded.ContractBytearray;
+    log: Event[];
+}
+interface DecodedEvent {
+    name: string;
+    args: unknown[];
+    contract: {
+        name: string;
+        address: Encoded.ContractAddress;
+    };
+}
+type TxData = Awaited<ReturnType<typeof send>>;
+interface SendAndProcessReturnType {
+    result?: TransformNodeType<ContractCallObject>;
+    hash: TxData['hash'];
+    tx: Awaited<ReturnType<any>>;
+    txData: TxData;
+    rawTx: Encoded.Transaction;
+}
+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: [
+        ...Args,
+        ...[
+        ] | [
+            Name extends 'init' ? Parameters<Contract<M>['$deploy']>[1] : Parameters<Contract<M>['$call']>[2]
+        ]
+    ]) => Promise<Awaited<ReturnType<Contract<M>['$call']>> & {
+        decodedResult?: Ret;
+    }> : never;
+};
+type ContractWithMethods<M extends ContractMethodsBase> = Contract<M> & MethodsToContractApi<M>;
+type MethodNames<M extends ContractMethodsBase> = keyof M & string | 'init';
+type MethodParameters<M extends ContractMethodsBase, Fn extends MethodNames<M>> = Fn extends 'init' ? M extends {
+    init: any;
+} ? Parameters<M['init']> : [
+] : Parameters<M[Fn]>;
+/**
+ * Generate contract ACI object with predefined js methods for contract usage - can be used for
+ * creating a reference to already deployed contracts
+ * @category contract
+ * @param options - Options object
+ * @returns JS Contract API
+ * @example
+ * ```js
+ * const contractIns = await aeSdk.initializeContract({ sourceCode })
+ * await contractIns.$deploy([321]) or await contractIns.init(321)
+ * const callResult = await contractIns.$call('setState', [123])
+ * const staticCallResult = await contractIns.$call('setState', [123], { callStatic: true })
+ * ```
+ * Also you can call contract like: `await contractIns.setState(123, options)`
+ * Then sdk decide to make on-chain or static call(dry-run API) transaction based on function is
+ * 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>;
+    /**
+     * 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: any): Promise<SendAndProcessReturnType>;
+    _estimateGas<Fn extends MethodNames<M>>(name: Fn, params: MethodParameters<M, Fn>, options?: object): Promise<number>;
+    /**
+     * Deploy contract
+     * @param params - Contract init function arguments array
+     * @param options - Options
+     * @returns deploy info
+     */
+    $deploy(params: MethodParameters<M, 'init'>, options?: Parameters<Contract<M>['$call']>[2] & Parameters<Contract<M>['_sendAndProcess']>[1]): Promise<Omit<SendAndProcessReturnType, 'hash'> & {
+        transaction?: Encoded.TxHash;
+        owner?: Encoded.AccountAddress;
+        address?: Encoded.ContractAddress;
+    }>;
+    /**
+     * 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
+     * @param params - Array of function arguments
+     * @param options - Array of function arguments
+     * @returns CallResult
+     */
+    $call<Fn extends MethodNames<M>>(fn: Fn, params: MethodParameters<M, Fn>, options?: object): 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: Encoded.ContractAddress]: string;
+        };
+    }): string;
+    /**
+     * Decode Events
+     * @param events - Array of encoded events (callRes.result.log)
+     * @param options - Options
+     * @returns DecodedEvents
+     */
+    $decodeEvents(events: Event[], { omitUnknown, ...opt }?: {
+        omitUnknown?: boolean;
+    } & Parameters<Contract<M>['_getContractNameByEvent']>[2]): DecodedEvent[];
+    static initialize<M extends ContractMethodsBase>({ onCompiler, onNode, sourceCode, bytecode, aci, address, fileSystem, validateBytecode, ...otherOptions }: Omit<ConstructorParameters<typeof Contract>[0], 'aci' | 'address'> & {
+        validateBytecode?: boolean;
+        aci?: Aci;
+        address?: Encoded.ContractAddress | AensName;
+    }): Promise<ContractWithMethods<M>>;
+    _aci: Aci;
+    _name: string;
+    _calldata: Calldata;
+    $options: {
+        sourceCode?: string;
+        bytecode?: Encoded.ContractBytearray;
+        address?: Encoded.ContractAddress;
+        onCompiler: CompilerHttp;
+        onNode: Node;
+        omitUnknown?: boolean;
+        contractAddressToName?: {
+            [key: Encoded.ContractAddress]: string;
+        };
+        [key: string]: any;
+    };
+    constructor({ aci, ...otherOptions }: {
+        onAccount?: AccountBase;
+        onCompiler: CompilerHttp;
+        onNode: Node;
+        sourceCode?: string;
+        bytecode?: Encoded.ContractBytearray;
+        aci: Aci;
+        address?: Encoded.ContractAddress;
+        fileSystem?: Record<string, string>;
+        [key: string]: any;
+    });
+}
+interface ContractWithMethodsClass {
+    new <M extends ContractMethodsBase>(options: ConstructorParameters<typeof Contract>[0]): ContractWithMethods<M>;
+    initialize: typeof Contract['initialize'];
+}
+declare const ContractWithMethods: ContractWithMethodsClass;
+export default ContractWithMethods;

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

@@ -0,0 +1,43 @@
+/**
+ * Generalized Account module - routines to use generalized account
+ */
+import { Tag } from '../tx/builder/constants';
+import { BuildTxOptions } from '../tx';
+import { Encoded } from '../utils/encoder';
+import AccountBase from '../account/Base';
+import { SendOptions } from '../spend';
+import Node from '../Node';
+import CompilerHttp from './CompilerHttp';
+/**
+ * Convert current account to GA
+ * @category contract
+ * @param authFnName - Authorization function name
+ * @param sourceCode - Auth contract source code
+ * @param args - init arguments
+ * @param options - Options
+ * @returns General Account Object
+ */
+export declare function createGeneralizedAccount(authFnName: string, sourceCode: string, args: any[], { onAccount, onCompiler, onNode, ...options }: CreateGeneralizedAccountOptions): Promise<Readonly<{
+    owner: Encoded.AccountAddress;
+    transaction: Encoded.TxHash;
+    rawTx: Encoded.Transaction;
+    gaContractId: Encoded.ContractAddress;
+}>>;
+interface CreateGeneralizedAccountOptions extends BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>, SendOptions {
+    onAccount: AccountBase;
+    onCompiler: CompilerHttp;
+    onNode: Node;
+    gasLimit?: number;
+}
+/**
+ * Build a transaction hash the same as `Auth.tx_hash`
+ * @category contract
+ * @param transaction - tx-encoded transaction
+ * @param options - Options
+ * @param options.onNode - Node to use
+ * @returns Transaction hash
+ */
+export declare function buildAuthTxHash(transaction: Encoded.Transaction, { onNode }: {
+    onNode: Node;
+}): Promise<Uint8Array>;
+export {};

package/types-legacy/ts4.5/index.d.ts

@@ -0,0 +1,38 @@
+export * from './chain';
+export * from './utils/crypto';
+export * from './utils/keystore';
+export * from './utils/bytes';
+export * from './tx';
+export * from './tx/builder';
+export * from './tx/builder/helpers';
+export * from './tx/builder/constants';
+export * from './tx/builder/schema';
+export * from './utils/amount-formatter';
+export * from './utils/hd-wallet';
+export { encode, decode, Encoding } from './utils/encoder';
+export * from './aens';
+export { default as Contract } from './contract/Contract';
+export type { ContractMethodsBase } from './contract/Contract';
+export * from './oracle';
+export * from './spend';
+export * 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 CompilerHttp } from './contract/CompilerHttp';
+export { default as Channel } from './channel/Contract';
+export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
+export * from './aepp-wallet-communication/schema';
+export { default as walletDetector } from './aepp-wallet-communication/wallet-detector';
+export { default as BrowserRuntimeConnection } from './aepp-wallet-communication/connection/BrowserRuntime';
+export { default as BrowserWindowMessageConnection } from './aepp-wallet-communication/connection/BrowserWindowMessage';
+export * from './utils/errors';

package/types-legacy/ts4.5/oracle.d.ts

@@ -0,0 +1,161 @@
+/**
+ * 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 BigNumber from 'bignumber.js';
+import { send, SendOptions } from './spend';
+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 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 declare function pollForQueries(oracleId: Encoded.OracleAddress, onQuery: (queries: OracleQueries) => void, { interval, onNode, ...options }: {
+    interval?: number;
+    onNode: Node;
+} & Parameters<typeof _getPollInterval>[1]): () => void;
+/**
+ * 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 declare function pollForQueryResponse(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, { interval, onNode, ...options }: {
+    interval?: number;
+    onNode: Node;
+} & Parameters<typeof _getPollInterval>[1]): Promise<string>;
+/**
+ * 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 declare function getQueryObject(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, options: RespondToQueryOptions & Parameters<typeof pollForQueryResponse>[2]): Promise<GetQueryObjectReturnType>;
+interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
+    decodedQuery: string;
+    decodedResponse: string;
+    respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) => ReturnType<typeof respondToQuery>;
+    pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) => ReturnType<typeof pollForQueryResponse>;
+}
+/**
+ * Post query to oracle
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param query - Oracle query object
+ * @param options - Options object
+ * @param options.queryTtl - queryTtl Oracle query time to leave
+ * @param options.responseTtl - queryFee Oracle query response time to leave
+ * @param options.queryFee - queryFee Oracle query fee
+ * @param options.fee - fee Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @returns Query object
+ */
+export 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'> & {
+    queryTtlType?: ORACLE_TTL_TYPES;
+    queryTtlValue?: number;
+    responseTtlType?: ORACLE_TTL_TYPES;
+    responseTtlValue?: number;
+};
+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
+ * @param options.oracleTtlType - Oracle time to leave for extend
+ * @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'> & {
+    oracleTtlType?: ORACLE_TTL_TYPES;
+    oracleTtlValue?: number;
+};
+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
+ * @param options.responseTtl - responseTtl Query response time to leave
+ * @param options.fee - Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @returns Oracle object
+ */
+export 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'> & {
+    responseTtlType?: ORACLE_TTL_TYPES;
+    responseTtlValue?: number;
+};
+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 declare function getOracleObject(oracleId: Encoded.OracleAddress, options: {
+    onNode: Node;
+    onAccount: AccountBase;
+}): Promise<GetOracleObjectReturnType>;
+interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleByPubkey']>> {
+    id: Encoded.OracleAddress;
+    queries: OracleQueries;
+    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
+ * @param options.queryFee - Oracle query Fee
+ * @param options - Options object
+ * @param options.abiVersion - Always 0 (do not use virtual machine)
+ * @param options.fee - Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @returns Oracle object
+ */
+export 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;
+    oracleTtlType?: ORACLE_TTL_TYPES;
+    oracleTtlValue?: number;
+};
+interface RegisterOracleOptions extends RegisterOracleOptionsType {
+}
+export {};

package/types-legacy/ts4.5/spend.d.ts

@@ -0,0 +1,62 @@
+import { sendTransaction, resolveName } from './chain';
+import { BuildTxOptions } from './tx';
+import { Encoded } 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 declare function send(tx: Encoded.Transaction, options: SendOptions): Promise<SendReturnType>;
+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
+ * @param amount - Amount to spend
+ * @param recipientIdOrName - Address or name of recipient account
+ * @param options - Options
+ * @returns Transaction
+ */
+export declare function spend(amount: number | string, recipientIdOrName: Encoded.AccountAddress | AensName, options: SpendOptions): ReturnType<typeof send>;
+type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
+    onAccount: AccountBase;
+} & SendOptions;
+interface SpendOptions extends SpendOptionsType {
+}
+/**
+ * Send a fraction of coin balance to another account
+ * @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
+ */
+export declare function transferFunds(fraction: number | string, recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof send>;
+type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
+    onAccount: AccountBase;
+} & SendOptions;
+interface TransferFundsOptions extends TransferFundsOptionsType {
+}
+/**
+ * Submit transaction of another account paying for it (fee and gas)
+ * @category chain
+ * @param transaction - tx_<base64>-encoded transaction
+ * @param options - Options
+ * @returns Object Transaction
+ */
+export declare function payForTransaction(transaction: Encoded.Transaction, options: PayForTransactionOptions): ReturnType<typeof send>;
+interface PayForTransactionOptions extends BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx'>, SendOptions {
+    onAccount: AccountBase;
+}
+export {};