@aeternity/aepp-sdk 13.3.3 → 14.1.0

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

@@ -1,232 +0,0 @@
-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;
-}
-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>);
-/**
- * @see {@link https://github.com/aeternity/protocol/blob/6734de2e4c7cce7e5e626caa8305fb535785131d/node/api/channels_api_usage.md#channel-establishing-parameters}
- */
-interface CommonChannelOptions {
-    existingFsmId?: Encoded.Bytearray;
-    /**
-     * Channel url (for example: "ws://localhost:3001")
-     */
-    url: string;
-    /**
-     * Initiator's public key
-     */
-    initiatorId: Encoded.AccountAddress;
-    /**
-     * Responder's public key
-     */
-    responderId: Encoded.AccountAddress;
-    /**
-     * Amount of blocks for disputing a solo close
-     */
-    lockPeriod: number;
-    /**
-     * Initial deposit in favour of the responder by the initiator
-     */
-    pushAmount: BigNumber | number;
-    /**
-     * Amount of coins the initiator has committed to the channel
-     */
-    initiatorAmount: BigNumber | number;
-    /**
-     * Amount of coins the responder has committed to the channel
-     */
-    responderAmount: BigNumber | number;
-    /**
-     * The minimum amount both peers need to maintain
-     */
-    channelReserve?: BigNumber | number;
-    /**
-     * Minimum block height to include the channel_create_tx
-     */
-    ttl?: number;
-    /**
-     * The port of the responder's node
-     */
-    port: number;
-    /**
-     * How to calculate minimum depth (default: txfee)
-     */
-    minimumDepthStrategy?: 'txfee' | 'plain';
-    /**
-     * The minimum amount of blocks to be mined
-     */
-    minimumDepth?: number;
-    /**
-     * The fee to be used for the channel open transaction
-     */
-    fee?: BigNumber | number;
-    /**
-     * Used for the fee computation of the channel open transaction
-     */
-    gasPrice?: BigNumber | number;
-    signedTx?: Encoded.Transaction;
-    /**
-     * Existing channel id (required if reestablishing a channel)
-     */
-    existingChannelId?: Encoded.Channel;
-    /**
-     * Offchain transaction (required if reestablishing a channel)
-     */
-    offChainTx?: Encoded.Transaction;
-    reconnectTx?: Encoded.Transaction;
-    /**
-     * The time waiting for a new event to be initiated (default: 600000)
-     */
-    timeoutIdle?: number;
-    /**
-     * The time waiting for the initiator to produce the create channel transaction after the noise
-     * session had been established (default: 120000)
-     */
-    timeoutFundingCreate?: number;
-    /**
-     * The time frame the other client has to sign an off-chain update after our client had initiated
-     * and signed it. This applies only for double signed on-chain intended updates: channel create
-     * transaction, deposit, withdrawal and etc. (default: 120000)
-     */
-    timeoutFundingSign?: number;
-    /**
-     * The time frame the other client has to confirm an on-chain transaction reaching maturity
-     * (passing minimum depth) after the local node has detected this. This applies only for double
-     * signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc.
-     * (default: 360000)
-     */
-    timeoutFundingLock?: number;
-    /**
-     * The time frame the client has to return a signed off-chain update or to decline it.
-     * This applies for all off-chain updates (default: 500000)
-     */
-    timeoutSign?: number;
-    /**
-     * The time frame the other client has to react to an event. This applies for all off-chain
-     * updates that are not meant to land on-chain, as well as some special cases: opening a noise
-     * connection, mutual closing acknowledgement and reestablishing an existing channel
-     * (default: 120000)
-     */
-    timeoutAccept?: number;
-    /**
-     * the time frame the responder has to accept an incoming noise session.
-     * Applicable only for initiator (default: timeout_accept's value)
-     */
-    timeoutInitialized?: number;
-    /**
-     * The time frame the initiator has to start an outgoing noise session to the responder's node.
-     * Applicable only for responder (default: timeout_idle's value)
-     */
-    timeoutAwaitingOpen?: number;
-    /**
-     * Log websocket communication and state changes
-     */
-    debug?: boolean;
-    /**
-     * Function which verifies and signs transactions
-     */
-    sign: SignTxWithTag;
-    offchainTx?: Encoded.Transaction;
-}
-export type ChannelOptions = CommonChannelOptions & ({
-    /**
-     * Participant role
-     */
-    role: 'initiator';
-    /**
-     * Host of the responder's node
-     */
-    host: string;
-} | {
-    /**
-     * Participant role
-     */
-    role: 'responder';
-});
-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;
-    /**
-     * Called when transaction has been posted on chain
-     */
-    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<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, debug?: unknown): 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.2/contract/Contract.d.ts

@@ -1,164 +0,0 @@
-/**
- * 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 { BuildTxOptions } from '../tx/builder';
-import { Encoded } from '../utils/encoder';
-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 { sendTransaction, SendTransactionOptions } from '../send-transaction';
-import AccountBase from '../account/Base';
-import { TxUnpacked } from '../tx/builder/schema.generated';
-interface Event extends NodeEvent {
-    address: Encoded.ContractAddress;
-    data: Encoded.ContractBytearray;
-}
-export interface ContractCallObject extends TransformNodeType<NodeContractCallObject> {
-    returnValue: Encoded.ContractBytearray;
-    log: Event[];
-}
-interface DecodedEvent {
-    name: string;
-    args: unknown[];
-    contract: {
-        name: string;
-        address: Encoded.ContractAddress;
-    };
-}
-type TxData = Awaited<ReturnType<typeof sendTransaction>>;
-interface SendAndProcessReturnType {
-    result?: ContractCallObject;
-    hash: TxData['hash'];
-    tx: TxUnpacked & {
-        tag: Tag.SignedTx | Tag.ContractCallTx | Tag.ContractCreateTx;
-    };
-    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) => any ? (...args: [
-        ...Args,
-        ...[
-        ] | [
-            Name extends 'init' ? Parameters<Contract<M>['$deploy']>[1] : Parameters<Contract<M>['$call']>[2]
-        ]
-    ]) => ReturnType<Contract<M>['$call']> : 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]>;
-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
- * @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> {
-    #private;
-    /**
-     * Compile contract
-     * @returns bytecode
-     */
-    $compile(): Promise<Encoded.ContractBytearray>;
-    $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
-     * @param options - Options
-     * @returns deploy info
-     */
-    $deploy(params: MethodParameters<M, 'init'>, options?: Parameters<Contract<M>['$call']>[2] & Partial<BuildTxOptions<Tag.ContractCreateTx, 'ownerId' | 'code' | 'callData'>>): Promise<Omit<SendAndProcessReturnType, 'hash'> & {
-        transaction?: Encoded.TxHash;
-        owner?: Encoded.AccountAddress;
-        address?: Encoded.ContractAddress;
-        decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
-    }>;
-    /**
-     * 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?: 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<SendAndProcessReturnType & Partial<GetCallResultByHashReturnType<M, Fn>>>;
-    /**
-     * Decode Events
-     * @param events - Array of encoded events (callRes.result.log)
-     * @param options - Options
-     * @returns DecodedEvents
-     */
-    $decodeEvents(events: Event[], { omitUnknown, ...opt }?: {
-        omitUnknown?: boolean;
-    } & 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;
-        address?: Encoded.ContractAddress | AensName;
-    }): Promise<ContractWithMethods<M>>;
-    _aci: Aci;
-    _name: string;
-    _calldata: Calldata;
-    $options: Omit<ConstructorParameters<typeof Contract>[0], 'aci'>;
-    /**
-     * @param options - Options
-     */
-    constructor({ aci, ...otherOptions }: {
-        onCompiler?: CompilerBase;
-        onNode: Node;
-        bytecode?: Encoded.ContractBytearray;
-        aci: Aci;
-        address?: Encoded.ContractAddress;
-        /**
-         * Supported only in Ceres
-         */
-        name?: AensName;
-        sourceCodePath?: Parameters<CompilerBase['compile']>[0];
-        sourceCode?: Parameters<CompilerBase['compileBySourceCode']>[0];
-        fileSystem?: Parameters<CompilerBase['compileBySourceCode']>[1];
-    } & Parameters<Contract<M>['$deploy']>[1]);
-}
-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.2/contract/compiler/Base.d.ts

@@ -1,104 +0,0 @@
-import { Encoded } from '../../utils/encoder';
-interface FunctionAci {
-    arguments: any[];
-    name: string;
-    payable: boolean;
-    returns: any;
-    stateful: boolean;
-}
-export type Aci = Array<{
-    contract?: {
-        name: string;
-        event?: any;
-        functions: FunctionAci[];
-        kind: string;
-        payable: boolean;
-        typedefs: any[];
-    };
-}>;
-export type CompileResult = Promise<{
-    bytecode: Encoded.ContractBytearray;
-    aci: Aci;
-    warnings: Array<{
-        message: string;
-        pos: {
-            file?: string;
-            line: number;
-            col: number;
-        };
-    }>;
-}>;
-/**
- * A base class for all compiler implementations
- */
-export default abstract class CompilerBase {
-    /**
-     * Compile contract by contract's path
-     * Available only in Node.js
-     * @param path - Path to contract source code
-     * @returns ACI and bytecode
-     */
-    abstract compile(path: string): CompileResult;
-    /**
-     * Compile contract by contract's source code
-     * @param sourceCode - Contract source code as string
-     * @param fileSystem - A map of contract filename to the corresponding contract source code to
-     * include into the main contract
-     * @example
-     * ```js
-     * {
-     *   'library.aes': 'namespace TestLib =\n  function sum(x: int, y: int) : int = x + y'
-     * }
-     * ```
-     * @returns ACI and bytecode
-     */
-    abstract compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): CompileResult;
-    /**
-     * Generate contract's ACI by contract's path
-     * Available only in Node.js
-     * @param path - Path to contract source code
-     * @returns ACI
-     */
-    abstract generateAci(path: string): Promise<Aci>;
-    /**
-     * Generate contract's ACI by contract's source code
-     * @param sourceCode - Contract source code as string
-     * @param fileSystem - A map of contract filename to the corresponding contract source code to
-     * include into the main contract
-     * @example
-     * ```js
-     * {
-     *   'library.aes': 'namespace TestLib =\n  function sum(x: int, y: int) : int = x + y'
-     * }
-     * ```
-     * @returns ACI
-     */
-    abstract generateAciBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<Aci>;
-    /**
-     * Verify that a contract bytecode is the result of compiling the given source code
-     * Available only in Node.js
-     * @param bytecode - Contract bytecode to verify
-     * @param path - Path to contract source code
-     * @returns ACI and bytecode
-     */
-    abstract validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
-    /**
-     * Verify that a contract bytecode is the result of compiling the given source code
-     * @param bytecode - Contract bytecode to verify
-     * @param sourceCode - Contract source code as string
-     * @param fileSystem - A map of contract filename to the corresponding contract source code to
-     * include into the main contract
-     * @example
-     * ```js
-     * {
-     *   'library.aes': 'namespace TestLib =\n  function sum(x: int, y: int) : int = x + y'
-     * }
-     * ```
-     */
-    abstract validateBySourceCode(bytecode: Encoded.ContractBytearray, sourceCode: string, fileSystem?: Record<string, string>): Promise<boolean>;
-    /**
-     * @returns Compiler version
-     */
-    abstract version(): Promise<string>;
-}
-export {};

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

@@ -1,26 +0,0 @@
-import CompilerBase, { Aci, CompileResult } from './Base';
-import { Encoded } from '../../utils/encoder';
-export declare const getPackagePath: () => string;
-/**
- * A wrapper around aesophia_cli, available only in Node.js.
- * Requires Erlang installed, assumes that `escript` is available in PATH.
- * @category contract
- */
-export default class CompilerCli extends CompilerBase {
-    #private;
-    /**
-     * @param compilerPath - A path to aesophia_cli binary, by default uses the integrated one
-     * @param options - Options
-     * @param options.ignoreVersion - Don't ensure that the compiler is supported
-     */
-    constructor(compilerPath?: string, { ignoreVersion }?: {
-        ignoreVersion?: boolean;
-    });
-    compile(path: string): CompileResult;
-    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): CompileResult;
-    generateAci(path: string): Promise<Aci>;
-    generateAciBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<Aci>;
-    validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
-    validateBySourceCode(bytecode: Encoded.ContractBytearray, sourceCode: string, fileSystem?: Record<string, string>): Promise<boolean>;
-    version(): Promise<string>;
-}

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

@@ -1,13 +0,0 @@
-import CompilerCli from './Cli';
-/**
- * @category contract
- */
-export default class CompilerCli8 extends CompilerCli {
-    /**
-     * @param options - Options
-     * @param options.ignoreVersion - Don't ensure that the compiler is supported
-     */
-    constructor({ ignoreVersion }?: {
-        ignoreVersion?: boolean;
-    });
-}

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

@@ -1,28 +0,0 @@
-import { Compiler as CompilerApi } from '../../apis/compiler';
-import CompilerBase, { Aci, CompileResult } from './Base';
-import { Encoded } from '../../utils/encoder';
-/**
- * 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 CompilerBase {
-    readonly api: CompilerApi;
-    /**
-     * @param compilerUrl - Url for compiler API
-     * @param options - Options
-     * @param options.ignoreVersion - Don't check compiler version
-     */
-    constructor(compilerUrl: string, { ignoreVersion }?: {
-        ignoreVersion?: boolean;
-    });
-    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): CompileResult;
-    compile(path: string): CompileResult;
-    generateAciBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<Aci>;
-    generateAci(path: string): Promise<Aci>;
-    validateBySourceCode(bytecode: Encoded.ContractBytearray, sourceCode: string, fileSystem?: Record<string, string>): Promise<boolean>;
-    validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
-    version(): Promise<string>;
-}

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

@@ -1,15 +0,0 @@
-import HttpBrowser from './Http';
-import { Aci, CompileResult } from './Base';
-import { Encoded } from '../../utils/encoder';
-/**
- * Contract Compiler over HTTP for Nodejs
- *
- * Inherits CompilerHttp and implements `compile`, `validate` methods
- * @category contract
- * @example CompilerHttpNode('COMPILER_URL')
- */
-export default class CompilerHttpNode extends HttpBrowser {
-    compile(path: string): CompileResult;
-    generateAci(path: string): Promise<Aci>;
-    validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
-}

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

@@ -1,6 +0,0 @@
-/**
- * Reads all files included in the provided contract
- * Available only in Node.js
- * @param path - a path to the main contract source code
- */
-export default function getFileSystem(path: string): Promise<Record<string, string>>;

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

@@ -1,45 +0,0 @@
-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
- * @deprecated use methods `sign*DelegationToContract` of Account instance instead
- * @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>, { onAccount, omitAddress, isOracle, ...options }: {
-    omitAddress?: boolean;
-    onAccount: AccountBase;
-    isOracle?: boolean;
-    onNode: Node;
-}): Promise<Uint8Array>;