snarkjs-algorand 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1482 @@
+import * as _algorandfoundation_algokit_utils_types_composer from '@algorandfoundation/algokit-utils/types/composer';
+import { AppCallMethodCall, TransactionComposer, SkipSignaturesSimulateOptions, RawSimulateOptions } from '@algorandfoundation/algokit-utils/types/composer';
+import { SendParams, SendAtomicTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction';
+import * as _algorandfoundation_algokit_utils_types_app from '@algorandfoundation/algokit-utils/types/app';
+import { ABIReturn } from '@algorandfoundation/algokit-utils/types/app';
+import { Arc56Contract } from '@algorandfoundation/algokit-utils/types/app-arc56';
+import * as algosdk from 'algosdk';
+import { Address, OnApplicationComplete, Transaction, TransactionSigner, modelsv2 } from 'algosdk';
+import { AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client';
+import { AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientMethodCallParams, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client';
+import { AppFactoryDeployParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory';
+import { Encodable, Schema } from '../../../../encoding/encoding.js';
+import { SignedTransaction } from '../../../../signedTransaction.js';
+import { Address as Address$1 } from '../../../../encoding/address.js';
+import { AlgorandClient as AlgorandClient$1 } from '@algorandfoundation/algokit-utils';
+import * as snarkjs from 'snarkjs';
+
+/**
+ * Expands types for IntelliSense so they are more human readable
+ * See https://stackoverflow.com/a/69288824
+ */
+type Expand<T> = T extends (...args: infer A) => infer R ? (...args: Expand<A>) => Expand<R> : T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type Proof = {
+    a: Uint8Array;
+    b: Uint8Array;
+    c: Uint8Array;
+    z: Uint8Array;
+    t1: Uint8Array;
+    t2: Uint8Array;
+    t3: Uint8Array;
+    wxi: Uint8Array;
+    wxiw: Uint8Array;
+    evalA: bigint;
+    evalB: bigint;
+    evalC: bigint;
+    evalS1: bigint;
+    evalS2: bigint;
+    evalZw: bigint;
+};
+type VerificationKey = {
+    qm: Uint8Array;
+    ql: Uint8Array;
+    qr: Uint8Array;
+    qo: Uint8Array;
+    qc: Uint8Array;
+    s1: Uint8Array;
+    s2: Uint8Array;
+    s3: Uint8Array;
+    power: bigint;
+    nPublic: bigint;
+    k1: bigint;
+    k2: bigint;
+    x_2: Uint8Array;
+};
+/**
+ * The argument types for the PlonkVerifier contract
+ */
+type PlonkVerifierArgs = {
+    /**
+     * The object representation of the arguments for each method
+     */
+    obj: {
+        '_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void': {
+            _vk: VerificationKey;
+        };
+        'verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void': {
+            signals: bigint[] | number[];
+            proof: Proof;
+        };
+    };
+    /**
+     * The tuple representation of the arguments for each method
+     */
+    tuple: {
+        '_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void': [_vk: VerificationKey];
+        'verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void': [signals: bigint[] | number[], proof: Proof];
+    };
+};
+/**
+ * The return type for each method
+ */
+type PlonkVerifierReturns = {
+    '_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void': void;
+    'verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void': void;
+};
+/**
+ * Defines the types of available calls and state of the PlonkVerifier smart contract.
+ */
+type PlonkVerifierTypes = {
+    /**
+     * Maps method signatures / names to their argument and return types.
+     */
+    methods: Record<'_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void' | '_dummy', {
+        argsObj: PlonkVerifierArgs['obj']['_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void'];
+        argsTuple: PlonkVerifierArgs['tuple']['_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void'];
+        returns: PlonkVerifierReturns['_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void'];
+    }> & Record<'verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void' | 'verify', {
+        argsObj: PlonkVerifierArgs['obj']['verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void'];
+        argsTuple: PlonkVerifierArgs['tuple']['verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void'];
+        returns: PlonkVerifierReturns['verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void'];
+    }>;
+};
+/**
+ * Defines the possible abi call signatures.
+ */
+type PlonkVerifierSignatures = keyof PlonkVerifierTypes['methods'];
+/**
+ * Defines the possible abi call signatures for methods that return a non-void value.
+ */
+type PlonkVerifierNonVoidMethodSignatures = keyof PlonkVerifierTypes['methods'] extends infer T ? T extends keyof PlonkVerifierTypes['methods'] ? MethodReturn<T> extends void ? never : T : never : never;
+/**
+ * Defines an object containing all relevant parameters for a single call to the contract.
+ */
+type CallParams<TArgs> = Expand<Omit<AppClientMethodCallParams, 'method' | 'args' | 'onComplete'> & {
+    /** The args for the ABI method call, either as an ordered array or an object */
+    args: Expand<TArgs>;
+}>;
+/**
+ * Maps a method signature from the PlonkVerifier smart contract to the method's return type
+ */
+type MethodReturn<TSignature extends PlonkVerifierSignatures> = PlonkVerifierTypes['methods'][TSignature]['returns'];
+/**
+ * Defines supported create method params for this smart contract
+ */
+type PlonkVerifierCreateCallParams = Expand<AppClientBareCallParams & {
+    method?: never;
+} & {
+    onComplete?: OnApplicationComplete.NoOpOC;
+} & CreateSchema>;
+/**
+ * Defines arguments required for the deploy method.
+ */
+type PlonkVerifierDeployParams = Expand<Omit<AppFactoryDeployParams, 'createParams' | 'updateParams' | 'deleteParams'> & {
+    /**
+     * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available)
+     */
+    createParams?: PlonkVerifierCreateCallParams;
+}>;
+/**
+ * A client to make calls to the PlonkVerifier smart contract
+ */
+declare class PlonkVerifierClient {
+    /**
+     * The underlying `AppClient` for when you want to have more flexibility
+     */
+    readonly appClient: AppClient;
+    /**
+     * Creates a new instance of `PlonkVerifierClient`
+     *
+     * @param appClient An `AppClient` instance which has been created with the PlonkVerifier app spec
+     */
+    constructor(appClient: AppClient);
+    /**
+     * Creates a new instance of `PlonkVerifierClient`
+     *
+     * @param params The parameters to initialise the app client with
+     */
+    constructor(params: Omit<AppClientParams, 'appSpec'>);
+    /**
+     * Checks for decode errors on the given return value and maps the return value to the return type for the given method
+     * @returns The typed return value or undefined if there was no value
+     */
+    decodeReturnValue<TSignature extends PlonkVerifierNonVoidMethodSignatures>(method: TSignature, returnValue: ABIReturn | undefined): undefined;
+    /**
+     * Returns a new `PlonkVerifierClient` client, resolving the app by creator address and name
+     * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note).
+     * @param params The parameters to create the app client
+     */
+    static fromCreatorAndName(params: Omit<ResolveAppClientByCreatorAndName, 'appSpec'>): Promise<PlonkVerifierClient>;
+    /**
+     * Returns an `PlonkVerifierClient` instance for the current network based on
+     * pre-determined network-specific app IDs specified in the ARC-56 app spec.
+     *
+     * If no IDs are in the app spec or the network isn't recognised, an error is thrown.
+     * @param params The parameters to create the app client
+     */
+    static fromNetwork(params: Omit<ResolveAppClientByNetwork, 'appSpec'>): Promise<PlonkVerifierClient>;
+    /** The ID of the app instance this client is linked to. */
+    get appId(): bigint;
+    /** The app address of the app instance this client is linked to. */
+    get appAddress(): Address;
+    /** The name of the app. */
+    get appName(): string;
+    /** The ARC-56 app spec being used */
+    get appSpec(): Arc56Contract;
+    /** A reference to the underlying `AlgorandClient` this app client is using. */
+    get algorand(): AlgorandClient;
+    /**
+     * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation.
+     */
+    readonly params: {
+        /**
+         * Gets available closeOut methods
+         */
+        closeOut: {
+            /**
+             * Makes a close out call to an existing instance of the PlonkVerifier smart contract using the `_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void` ABI method.
+             *
+             * Dummy function that only exists so we can have the VerificationKey type in the generated client
+             *
+             * @param params The params for the smart contract call
+             * @returns The closeOut params
+             */
+            _dummy: (params: CallParams<PlonkVerifierArgs["obj"]["_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void"] | PlonkVerifierArgs["tuple"]["_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void"]>) => Promise<AppCallMethodCall>;
+        };
+        /**
+         * Makes a clear_state call to an existing instance of the PlonkVerifier smart contract.
+         *
+         * @param params The params for the bare (raw) call
+         * @returns The clearState result
+         */
+        clearState: (params?: Expand<AppClientBareCallParams>) => _algorandfoundation_algokit_utils_types_composer.AppCallParams;
+        /**
+         * Makes a call to the PlonkVerifier smart contract using the `verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void` ABI method.
+         *
+         * @param params The params for the smart contract call
+         * @returns The call params
+         */
+        verify: (params: CallParams<PlonkVerifierArgs["obj"]["verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void"] | PlonkVerifierArgs["tuple"]["verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void"]> & {
+            onComplete?: OnApplicationComplete.NoOpOC;
+        }) => Promise<AppCallMethodCall>;
+    };
+    /**
+     * Create transactions for the current app
+     */
+    readonly createTransaction: {
+        /**
+         * Gets available closeOut methods
+         */
+        closeOut: {
+            /**
+             * Makes a close out call to an existing instance of the PlonkVerifier smart contract using the `_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void` ABI method.
+             *
+             * Dummy function that only exists so we can have the VerificationKey type in the generated client
+             *
+             * @param params The params for the smart contract call
+             * @returns The closeOut transaction
+             */
+            _dummy: (params: CallParams<PlonkVerifierArgs["obj"]["_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void"] | PlonkVerifierArgs["tuple"]["_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void"]>) => Promise<{
+                transactions: Transaction[];
+                methodCalls: Map<number, algosdk.ABIMethod>;
+                signers: Map<number, TransactionSigner>;
+            }>;
+        };
+        /**
+         * Makes a clear_state call to an existing instance of the PlonkVerifier smart contract.
+         *
+         * @param params The params for the bare (raw) call
+         * @returns The clearState result
+         */
+        clearState: (params?: Expand<AppClientBareCallParams>) => Promise<Transaction>;
+        /**
+         * Makes a call to the PlonkVerifier smart contract using the `verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void` ABI method.
+         *
+         * @param params The params for the smart contract call
+         * @returns The call transaction
+         */
+        verify: (params: CallParams<PlonkVerifierArgs["obj"]["verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void"] | PlonkVerifierArgs["tuple"]["verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void"]> & {
+            onComplete?: OnApplicationComplete.NoOpOC;
+        }) => Promise<{
+            transactions: Transaction[];
+            methodCalls: Map<number, algosdk.ABIMethod>;
+            signers: Map<number, TransactionSigner>;
+        }>;
+    };
+    /**
+     * Send calls to the current app
+     */
+    readonly send: {
+        /**
+         * Gets available closeOut methods
+         */
+        closeOut: {
+            /**
+             * Makes a close out call to an existing instance of the PlonkVerifier smart contract using the `_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void` ABI method.
+             *
+             * Dummy function that only exists so we can have the VerificationKey type in the generated client
+             *
+             * @param params The params for the smart contract call
+             * @returns The closeOut result
+             */
+            _dummy: (params: CallParams<PlonkVerifierArgs["obj"]["_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void"] | PlonkVerifierArgs["tuple"]["_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void"]> & SendParams) => Promise<{
+                return: (undefined | PlonkVerifierReturns["_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void"]);
+                groupId: string;
+                txIds: string[];
+                returns?: ABIReturn[] | undefined | undefined;
+                confirmations: modelsv2.PendingTransactionResponse[];
+                transactions: Transaction[];
+                confirmation: modelsv2.PendingTransactionResponse;
+                transaction: Transaction;
+            }>;
+        };
+        /**
+         * Makes a clear_state call to an existing instance of the PlonkVerifier smart contract.
+         *
+         * @param params The params for the bare (raw) call
+         * @returns The clearState result
+         */
+        clearState: (params?: Expand<AppClientBareCallParams & SendParams>) => Promise<{
+            groupId: string;
+            txIds: string[];
+            returns?: ABIReturn[] | undefined;
+            confirmations: modelsv2.PendingTransactionResponse[];
+            transactions: Transaction[];
+            confirmation: modelsv2.PendingTransactionResponse;
+            transaction: Transaction;
+            return?: ABIReturn | undefined;
+        }>;
+        /**
+         * Makes a call to the PlonkVerifier smart contract using the `verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void` ABI method.
+         *
+         * @param params The params for the smart contract call
+         * @returns The call result
+         */
+        verify: (params: CallParams<PlonkVerifierArgs["obj"]["verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void"] | PlonkVerifierArgs["tuple"]["verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void"]> & SendParams & {
+            onComplete?: OnApplicationComplete.NoOpOC;
+        }) => Promise<{
+            return: (undefined | PlonkVerifierReturns["verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void"]);
+            groupId: string;
+            txIds: string[];
+            returns?: ABIReturn[] | undefined | undefined;
+            confirmations: modelsv2.PendingTransactionResponse[];
+            transactions: Transaction[];
+            confirmation: modelsv2.PendingTransactionResponse;
+            transaction: Transaction;
+        }>;
+    };
+    /**
+     * Clone this app client with different params
+     *
+     * @param params The params to use for the the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value.
+     * @returns A new app client with the altered params
+     */
+    clone(params: CloneAppClientParams): PlonkVerifierClient;
+    /**
+     * Methods to access state for the current PlonkVerifier app
+     */
+    state: {};
+    newGroup(): PlonkVerifierComposer;
+}
+type PlonkVerifierComposer<TReturns extends [...any[]] = []> = {
+    /**
+     * Calls the verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void ABI method.
+     *
+     * @param args The arguments for the contract call
+     * @param params Any additional parameters for the call
+     * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions
+     */
+    verify(params?: CallParams<PlonkVerifierArgs['obj']['verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void'] | PlonkVerifierArgs['tuple']['verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void']>): PlonkVerifierComposer<[...TReturns, PlonkVerifierReturns['verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void'] | undefined]>;
+    /**
+     * Gets available closeOut methods
+     */
+    readonly closeOut: {
+        /**
+         * Makes a close out call to an existing instance of the PlonkVerifier smart contract using the _dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void ABI method.
+         *
+         * @param args The arguments for the smart contract call
+         * @param params Any additional parameters for the call
+         * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions
+         */
+        _dummy(params?: CallParams<PlonkVerifierArgs['obj']['_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void'] | PlonkVerifierArgs['tuple']['_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void']>): PlonkVerifierComposer<[...TReturns, PlonkVerifierReturns['_dummy((byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint64,uint64,uint64,uint64,byte[192]))void'] | undefined]>;
+    };
+    /**
+     * Makes a clear_state call to an existing instance of the PlonkVerifier smart contract.
+     *
+     * @param args The arguments for the bare call
+     * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions
+     */
+    clearState(params?: AppClientBareCallParams): PlonkVerifierComposer<[...TReturns, undefined]>;
+    /**
+     * Adds a transaction to the composer
+     *
+     * @param txn A transaction to add to the transaction group
+     * @param signer The optional signer to use when signing this transaction.
+     */
+    addTransaction(txn: Transaction, signer?: TransactionSigner): PlonkVerifierComposer<TReturns>;
+    /**
+     * Returns the underlying AtomicTransactionComposer instance
+     */
+    composer(): Promise<TransactionComposer>;
+    /**
+     * Simulates the transaction group and returns the result
+     */
+    simulate(): Promise<PlonkVerifierComposerResults<TReturns> & {
+        simulateResponse: modelsv2.SimulateResponse;
+    }>;
+    simulate(options: SkipSignaturesSimulateOptions): Promise<PlonkVerifierComposerResults<TReturns> & {
+        simulateResponse: modelsv2.SimulateResponse;
+    }>;
+    simulate(options: RawSimulateOptions): Promise<PlonkVerifierComposerResults<TReturns> & {
+        simulateResponse: modelsv2.SimulateResponse;
+    }>;
+    /**
+     * Sends the transaction group to the network and returns the results
+     */
+    send(params?: SendParams): Promise<PlonkVerifierComposerResults<TReturns>>;
+};
+type PlonkVerifierComposerResults<TReturns extends [...any[]]> = Expand<SendAtomicTransactionComposerResults & {
+    returns: TReturns;
+}>;
+
+/**
+ * NOTICE: This file was generated. Editing this file manually is not recommended.
+ */
+
+/**
+ * Application state delta.
+ */
+declare class AccountStateDelta implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    address: string;
+    /**
+     * Application state delta.
+     */
+    delta: EvalDeltaKeyValue[];
+    /**
+     * Creates a new `AccountStateDelta` object.
+     * @param address -
+     * @param delta - Application state delta.
+     */
+    constructor({ address, delta, }: {
+        address: string;
+        delta: EvalDeltaKeyValue[];
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): AccountStateDelta;
+}
+/**
+ * An application's initial global/local/box states that were accessed during
+ * simulation.
+ */
+declare class ApplicationInitialStates implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Application index.
+     */
+    id: bigint;
+    /**
+     * An application's global/local/box state.
+     */
+    appBoxes?: ApplicationKVStorage;
+    /**
+     * An application's global/local/box state.
+     */
+    appGlobals?: ApplicationKVStorage;
+    /**
+     * An application's initial local states tied to different accounts.
+     */
+    appLocals?: ApplicationKVStorage[];
+    /**
+     * Creates a new `ApplicationInitialStates` object.
+     * @param id - Application index.
+     * @param appBoxes - An application's global/local/box state.
+     * @param appGlobals - An application's global/local/box state.
+     * @param appLocals - An application's initial local states tied to different accounts.
+     */
+    constructor({ id, appBoxes, appGlobals, appLocals, }: {
+        id: number | bigint;
+        appBoxes?: ApplicationKVStorage;
+        appGlobals?: ApplicationKVStorage;
+        appLocals?: ApplicationKVStorage[];
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): ApplicationInitialStates;
+}
+/**
+ * An application's global/local/box state.
+ */
+declare class ApplicationKVStorage implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Key-Value pairs representing application states.
+     */
+    kvs: AvmKeyValue[];
+    /**
+     * The address of the account associated with the local state.
+     */
+    account?: Address$1;
+    /**
+     * Creates a new `ApplicationKVStorage` object.
+     * @param kvs - Key-Value pairs representing application states.
+     * @param account - The address of the account associated with the local state.
+     */
+    constructor({ kvs, account, }: {
+        kvs: AvmKeyValue[];
+        account?: Address$1 | string;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): ApplicationKVStorage;
+}
+/**
+ * References an account's local state for an application.
+ */
+declare class ApplicationLocalReference implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Address of the account with the local state.
+     */
+    account: Address$1;
+    /**
+     * Application ID of the local state application.
+     */
+    app: bigint;
+    /**
+     * Creates a new `ApplicationLocalReference` object.
+     * @param account - Address of the account with the local state.
+     * @param app - Application ID of the local state application.
+     */
+    constructor({ account, app, }: {
+        account: Address$1 | string;
+        app: number | bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): ApplicationLocalReference;
+}
+/**
+ * An operation against an application's global/local/box state.
+ */
+declare class ApplicationStateOperation implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Type of application state. Value `g` is **global state**, `l` is **local
+     * state**, `b` is **boxes**.
+     */
+    appStateType: string;
+    /**
+     * The key (name) of the global/local/box state.
+     */
+    key: Uint8Array;
+    /**
+     * Operation type. Value `w` is **write**, `d` is **delete**.
+     */
+    operation: string;
+    /**
+     * For local state changes, the address of the account associated with the local
+     * state.
+     */
+    account?: Address$1;
+    /**
+     * Represents an AVM value.
+     */
+    newValue?: AvmValue;
+    /**
+     * Creates a new `ApplicationStateOperation` object.
+     * @param appStateType - Type of application state. Value `g` is **global state**, `l` is **local
+     * state**, `b` is **boxes**.
+     * @param key - The key (name) of the global/local/box state.
+     * @param operation - Operation type. Value `w` is **write**, `d` is **delete**.
+     * @param account - For local state changes, the address of the account associated with the local
+     * state.
+     * @param newValue - Represents an AVM value.
+     */
+    constructor({ appStateType, key, operation, account, newValue, }: {
+        appStateType: string;
+        key: string | Uint8Array;
+        operation: string;
+        account?: Address$1 | string;
+        newValue?: AvmValue;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): ApplicationStateOperation;
+}
+/**
+ * References an asset held by an account.
+ */
+declare class AssetHoldingReference implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Address of the account holding the asset.
+     */
+    account: Address$1;
+    /**
+     * Asset ID of the holding.
+     */
+    asset: bigint;
+    /**
+     * Creates a new `AssetHoldingReference` object.
+     * @param account - Address of the account holding the asset.
+     * @param asset - Asset ID of the holding.
+     */
+    constructor({ account, asset, }: {
+        account: Address$1 | string;
+        asset: number | bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): AssetHoldingReference;
+}
+/**
+ * Represents an AVM key-value pair in an application store.
+ */
+declare class AvmKeyValue implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    key: Uint8Array;
+    /**
+     * Represents an AVM value.
+     */
+    value: AvmValue;
+    /**
+     * Creates a new `AvmKeyValue` object.
+     * @param key -
+     * @param value - Represents an AVM value.
+     */
+    constructor({ key, value }: {
+        key: string | Uint8Array;
+        value: AvmValue;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): AvmKeyValue;
+}
+/**
+ * Represents an AVM value.
+ */
+declare class AvmValue implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * value type. Value `1` refers to **bytes**, value `2` refers to **uint64**
+     */
+    type: number;
+    /**
+     * bytes value.
+     */
+    bytes?: Uint8Array;
+    /**
+     * uint value.
+     */
+    uint?: bigint;
+    /**
+     * Creates a new `AvmValue` object.
+     * @param type - value type. Value `1` refers to **bytes**, value `2` refers to **uint64**
+     * @param bytes - bytes value.
+     * @param uint - uint value.
+     */
+    constructor({ type, bytes, uint, }: {
+        type: number | bigint;
+        bytes?: string | Uint8Array;
+        uint?: number | bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): AvmValue;
+}
+/**
+ * References a box of an application.
+ */
+declare class BoxReference implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Application ID which this box belongs to
+     */
+    app: bigint;
+    /**
+     * Base64 encoded box name
+     */
+    name: Uint8Array;
+    /**
+     * Creates a new `BoxReference` object.
+     * @param app - Application ID which this box belongs to
+     * @param name - Base64 encoded box name
+     */
+    constructor({ app, name, }: {
+        app: number | bigint;
+        name: string | Uint8Array;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): BoxReference;
+}
+/**
+ * Represents a TEAL value delta.
+ */
+declare class EvalDelta implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * (at) delta action.
+     */
+    action: number;
+    /**
+     * (bs) bytes value.
+     */
+    bytes?: string;
+    /**
+     * (ui) uint value.
+     */
+    uint?: bigint;
+    /**
+     * Creates a new `EvalDelta` object.
+     * @param action - (at) delta action.
+     * @param bytes - (bs) bytes value.
+     * @param uint - (ui) uint value.
+     */
+    constructor({ action, bytes, uint, }: {
+        action: number | bigint;
+        bytes?: string;
+        uint?: number | bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): EvalDelta;
+}
+/**
+ * Key-value pairs for StateDelta.
+ */
+declare class EvalDeltaKeyValue implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    key: string;
+    /**
+     * Represents a TEAL value delta.
+     */
+    value: EvalDelta;
+    /**
+     * Creates a new `EvalDeltaKeyValue` object.
+     * @param key -
+     * @param value - Represents a TEAL value delta.
+     */
+    constructor({ key, value }: {
+        key: string;
+        value: EvalDelta;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): EvalDeltaKeyValue;
+}
+/**
+ * Details about a pending transaction. If the transaction was recently confirmed,
+ * includes confirmation details like the round and reward details.
+ */
+declare class PendingTransactionResponse implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Indicates that the transaction was kicked out of this node's transaction pool
+     * (and specifies why that happened). An empty string indicates the transaction
+     * wasn't kicked out of this node's txpool due to an error.
+     */
+    poolError: string;
+    /**
+     * The raw signed transaction.
+     */
+    txn: SignedTransaction;
+    /**
+     * The application index if the transaction was found and it created an
+     * application.
+     */
+    applicationIndex?: bigint;
+    /**
+     * The number of the asset's unit that were transferred to the close-to address.
+     */
+    assetClosingAmount?: bigint;
+    /**
+     * The asset index if the transaction was found and it created an asset.
+     */
+    assetIndex?: bigint;
+    /**
+     * Rewards in microalgos applied to the close remainder to account.
+     */
+    closeRewards?: bigint;
+    /**
+     * Closing amount for the transaction.
+     */
+    closingAmount?: bigint;
+    /**
+     * The round where this transaction was confirmed, if present.
+     */
+    confirmedRound?: bigint;
+    /**
+     * Global state key/value changes for the application being executed by this
+     * transaction.
+     */
+    globalStateDelta?: EvalDeltaKeyValue[];
+    /**
+     * Inner transactions produced by application execution.
+     */
+    innerTxns?: PendingTransactionResponse[];
+    /**
+     * Local state key/value changes for the application being executed by this
+     * transaction.
+     */
+    localStateDelta?: AccountStateDelta[];
+    /**
+     * Logs for the application being executed by this transaction.
+     */
+    logs?: Uint8Array[];
+    /**
+     * Rewards in microalgos applied to the receiver account.
+     */
+    receiverRewards?: bigint;
+    /**
+     * Rewards in microalgos applied to the sender account.
+     */
+    senderRewards?: bigint;
+    /**
+     * Creates a new `PendingTransactionResponse` object.
+     * @param poolError - Indicates that the transaction was kicked out of this node's transaction pool
+     * (and specifies why that happened). An empty string indicates the transaction
+     * wasn't kicked out of this node's txpool due to an error.
+     * @param txn - The raw signed transaction.
+     * @param applicationIndex - The application index if the transaction was found and it created an
+     * application.
+     * @param assetClosingAmount - The number of the asset's unit that were transferred to the close-to address.
+     * @param assetIndex - The asset index if the transaction was found and it created an asset.
+     * @param closeRewards - Rewards in microalgos applied to the close remainder to account.
+     * @param closingAmount - Closing amount for the transaction.
+     * @param confirmedRound - The round where this transaction was confirmed, if present.
+     * @param globalStateDelta - Global state key/value changes for the application being executed by this
+     * transaction.
+     * @param innerTxns - Inner transactions produced by application execution.
+     * @param localStateDelta - Local state key/value changes for the application being executed by this
+     * transaction.
+     * @param logs - Logs for the application being executed by this transaction.
+     * @param receiverRewards - Rewards in microalgos applied to the receiver account.
+     * @param senderRewards - Rewards in microalgos applied to the sender account.
+     */
+    constructor({ poolError, txn, applicationIndex, assetClosingAmount, assetIndex, closeRewards, closingAmount, confirmedRound, globalStateDelta, innerTxns, localStateDelta, logs, receiverRewards, senderRewards, }: {
+        poolError: string;
+        txn: SignedTransaction;
+        applicationIndex?: number | bigint;
+        assetClosingAmount?: number | bigint;
+        assetIndex?: number | bigint;
+        closeRewards?: number | bigint;
+        closingAmount?: number | bigint;
+        confirmedRound?: number | bigint;
+        globalStateDelta?: EvalDeltaKeyValue[];
+        innerTxns?: PendingTransactionResponse[];
+        localStateDelta?: AccountStateDelta[];
+        logs?: Uint8Array[];
+        receiverRewards?: number | bigint;
+        senderRewards?: number | bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): PendingTransactionResponse;
+}
+/**
+ * A write operation into a scratch slot.
+ */
+declare class ScratchChange implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Represents an AVM value.
+     */
+    newValue: AvmValue;
+    /**
+     * The scratch slot written.
+     */
+    slot: number;
+    /**
+     * Creates a new `ScratchChange` object.
+     * @param newValue - Represents an AVM value.
+     * @param slot - The scratch slot written.
+     */
+    constructor({ newValue, slot, }: {
+        newValue: AvmValue;
+        slot: number | bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): ScratchChange;
+}
+/**
+ * Initial states of resources that were accessed during simulation.
+ */
+declare class SimulateInitialStates implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * The initial states of accessed application before simulation. The order of this
+     * array is arbitrary.
+     */
+    appInitialStates?: ApplicationInitialStates[];
+    /**
+     * Creates a new `SimulateInitialStates` object.
+     * @param appInitialStates - The initial states of accessed application before simulation. The order of this
+     * array is arbitrary.
+     */
+    constructor({ appInitialStates, }: {
+        appInitialStates?: ApplicationInitialStates[];
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SimulateInitialStates;
+}
+/**
+ * Result of a transaction group simulation.
+ */
+declare class SimulateResponse implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * The round immediately preceding this simulation. State changes through this
+     * round were used to run this simulation.
+     */
+    lastRound: bigint;
+    /**
+     * A result object for each transaction group that was simulated.
+     */
+    txnGroups: SimulateTransactionGroupResult[];
+    /**
+     * The version of this response object.
+     */
+    version: number;
+    /**
+     * The set of parameters and limits override during simulation. If this set of
+     * parameters is present, then evaluation parameters may differ from standard
+     * evaluation in certain ways.
+     */
+    evalOverrides?: SimulationEvalOverrides;
+    /**
+     * An object that configures simulation execution trace.
+     */
+    execTraceConfig?: SimulateTraceConfig;
+    /**
+     * Initial states of resources that were accessed during simulation.
+     */
+    initialStates?: SimulateInitialStates;
+    /**
+     * Creates a new `SimulateResponse` object.
+     * @param lastRound - The round immediately preceding this simulation. State changes through this
+     * round were used to run this simulation.
+     * @param txnGroups - A result object for each transaction group that was simulated.
+     * @param version - The version of this response object.
+     * @param evalOverrides - The set of parameters and limits override during simulation. If this set of
+     * parameters is present, then evaluation parameters may differ from standard
+     * evaluation in certain ways.
+     * @param execTraceConfig - An object that configures simulation execution trace.
+     * @param initialStates - Initial states of resources that were accessed during simulation.
+     */
+    constructor({ lastRound, txnGroups, version, evalOverrides, execTraceConfig, initialStates, }: {
+        lastRound: number | bigint;
+        txnGroups: SimulateTransactionGroupResult[];
+        version: number | bigint;
+        evalOverrides?: SimulationEvalOverrides;
+        execTraceConfig?: SimulateTraceConfig;
+        initialStates?: SimulateInitialStates;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SimulateResponse;
+}
+/**
+ * An object that configures simulation execution trace.
+ */
+declare class SimulateTraceConfig implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * A boolean option for opting in execution trace features simulation endpoint.
+     */
+    enable?: boolean;
+    /**
+     * A boolean option enabling returning scratch slot changes together with execution
+     * trace during simulation.
+     */
+    scratchChange?: boolean;
+    /**
+     * A boolean option enabling returning stack changes together with execution trace
+     * during simulation.
+     */
+    stackChange?: boolean;
+    /**
+     * A boolean option enabling returning application state changes (global, local,
+     * and box changes) with the execution trace during simulation.
+     */
+    stateChange?: boolean;
+    /**
+     * Creates a new `SimulateTraceConfig` object.
+     * @param enable - A boolean option for opting in execution trace features simulation endpoint.
+     * @param scratchChange - A boolean option enabling returning scratch slot changes together with execution
+     * trace during simulation.
+     * @param stackChange - A boolean option enabling returning stack changes together with execution trace
+     * during simulation.
+     * @param stateChange - A boolean option enabling returning application state changes (global, local,
+     * and box changes) with the execution trace during simulation.
+     */
+    constructor({ enable, scratchChange, stackChange, stateChange, }: {
+        enable?: boolean;
+        scratchChange?: boolean;
+        stackChange?: boolean;
+        stateChange?: boolean;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SimulateTraceConfig;
+}
+/**
+ * Simulation result for an atomic transaction group
+ */
+declare class SimulateTransactionGroupResult implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Simulation result for individual transactions
+     */
+    txnResults: SimulateTransactionResult[];
+    /**
+     * Total budget added during execution of app calls in the transaction group.
+     */
+    appBudgetAdded?: number;
+    /**
+     * Total budget consumed during execution of app calls in the transaction group.
+     */
+    appBudgetConsumed?: number;
+    /**
+     * If present, indicates which transaction in this group caused the failure. This
+     * array represents the path to the failing transaction. Indexes are zero based,
+     * the first element indicates the top-level transaction, and successive elements
+     * indicate deeper inner transactions.
+     */
+    failedAt?: number[];
+    /**
+     * If present, indicates that the transaction group failed and specifies why that
+     * happened
+     */
+    failureMessage?: string;
+    /**
+     * These are resources that were accessed by this group that would normally have
+     * caused failure, but were allowed in simulation. Depending on where this object
+     * is in the response, the unnamed resources it contains may or may not qualify for
+     * group resource sharing. If this is a field in SimulateTransactionGroupResult,
+     * the resources do qualify, but if this is a field in SimulateTransactionResult,
+     * they do not qualify. In order to make this group valid for actual submission,
+     * resources that qualify for group sharing can be made available by any
+     * transaction of the group; otherwise, resources must be placed in the same
+     * transaction which accessed them.
+     */
+    unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
+    /**
+     * Creates a new `SimulateTransactionGroupResult` object.
+     * @param txnResults - Simulation result for individual transactions
+     * @param appBudgetAdded - Total budget added during execution of app calls in the transaction group.
+     * @param appBudgetConsumed - Total budget consumed during execution of app calls in the transaction group.
+     * @param failedAt - If present, indicates which transaction in this group caused the failure. This
+     * array represents the path to the failing transaction. Indexes are zero based,
+     * the first element indicates the top-level transaction, and successive elements
+     * indicate deeper inner transactions.
+     * @param failureMessage - If present, indicates that the transaction group failed and specifies why that
+     * happened
+     * @param unnamedResourcesAccessed - These are resources that were accessed by this group that would normally have
+     * caused failure, but were allowed in simulation. Depending on where this object
+     * is in the response, the unnamed resources it contains may or may not qualify for
+     * group resource sharing. If this is a field in SimulateTransactionGroupResult,
+     * the resources do qualify, but if this is a field in SimulateTransactionResult,
+     * they do not qualify. In order to make this group valid for actual submission,
+     * resources that qualify for group sharing can be made available by any
+     * transaction of the group; otherwise, resources must be placed in the same
+     * transaction which accessed them.
+     */
+    constructor({ txnResults, appBudgetAdded, appBudgetConsumed, failedAt, failureMessage, unnamedResourcesAccessed, }: {
+        txnResults: SimulateTransactionResult[];
+        appBudgetAdded?: number | bigint;
+        appBudgetConsumed?: number | bigint;
+        failedAt?: (number | bigint)[];
+        failureMessage?: string;
+        unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SimulateTransactionGroupResult;
+}
+/**
+ * Simulation result for an individual transaction
+ */
+declare class SimulateTransactionResult implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * Details about a pending transaction. If the transaction was recently confirmed,
+     * includes confirmation details like the round and reward details.
+     */
+    txnResult: PendingTransactionResponse;
+    /**
+     * Budget used during execution of an app call transaction. This value includes
+     * budged used by inner app calls spawned by this transaction.
+     */
+    appBudgetConsumed?: number;
+    /**
+     * The execution trace of calling an app or a logic sig, containing the inner app
+     * call trace in a recursive way.
+     */
+    execTrace?: SimulationTransactionExecTrace;
+    /**
+     * The account that needed to sign this transaction when no signature was provided
+     * and the provided signer was incorrect.
+     */
+    fixedSigner?: Address$1;
+    /**
+     * Budget used during execution of a logic sig transaction.
+     */
+    logicSigBudgetConsumed?: number;
+    /**
+     * These are resources that were accessed by this group that would normally have
+     * caused failure, but were allowed in simulation. Depending on where this object
+     * is in the response, the unnamed resources it contains may or may not qualify for
+     * group resource sharing. If this is a field in SimulateTransactionGroupResult,
+     * the resources do qualify, but if this is a field in SimulateTransactionResult,
+     * they do not qualify. In order to make this group valid for actual submission,
+     * resources that qualify for group sharing can be made available by any
+     * transaction of the group; otherwise, resources must be placed in the same
+     * transaction which accessed them.
+     */
+    unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
+    /**
+     * Creates a new `SimulateTransactionResult` object.
+     * @param txnResult - Details about a pending transaction. If the transaction was recently confirmed,
+     * includes confirmation details like the round and reward details.
+     * @param appBudgetConsumed - Budget used during execution of an app call transaction. This value includes
+     * budged used by inner app calls spawned by this transaction.
+     * @param execTrace - The execution trace of calling an app or a logic sig, containing the inner app
+     * call trace in a recursive way.
+     * @param fixedSigner - The account that needed to sign this transaction when no signature was provided
+     * and the provided signer was incorrect.
+     * @param logicSigBudgetConsumed - Budget used during execution of a logic sig transaction.
+     * @param unnamedResourcesAccessed - These are resources that were accessed by this group that would normally have
+     * caused failure, but were allowed in simulation. Depending on where this object
+     * is in the response, the unnamed resources it contains may or may not qualify for
+     * group resource sharing. If this is a field in SimulateTransactionGroupResult,
+     * the resources do qualify, but if this is a field in SimulateTransactionResult,
+     * they do not qualify. In order to make this group valid for actual submission,
+     * resources that qualify for group sharing can be made available by any
+     * transaction of the group; otherwise, resources must be placed in the same
+     * transaction which accessed them.
+     */
+    constructor({ txnResult, appBudgetConsumed, execTrace, fixedSigner, logicSigBudgetConsumed, unnamedResourcesAccessed, }: {
+        txnResult: PendingTransactionResponse;
+        appBudgetConsumed?: number | bigint;
+        execTrace?: SimulationTransactionExecTrace;
+        fixedSigner?: Address$1 | string;
+        logicSigBudgetConsumed?: number | bigint;
+        unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SimulateTransactionResult;
+}
+/**
+ * These are resources that were accessed by this group that would normally have
+ * caused failure, but were allowed in simulation. Depending on where this object
+ * is in the response, the unnamed resources it contains may or may not qualify for
+ * group resource sharing. If this is a field in SimulateTransactionGroupResult,
+ * the resources do qualify, but if this is a field in SimulateTransactionResult,
+ * they do not qualify. In order to make this group valid for actual submission,
+ * resources that qualify for group sharing can be made available by any
+ * transaction of the group; otherwise, resources must be placed in the same
+ * transaction which accessed them.
+ */
+declare class SimulateUnnamedResourcesAccessed implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * The unnamed accounts that were referenced. The order of this array is arbitrary.
+     */
+    accounts?: Address$1[];
+    /**
+     * The unnamed application local states that were referenced. The order of this
+     * array is arbitrary.
+     */
+    appLocals?: ApplicationLocalReference[];
+    /**
+     * The unnamed applications that were referenced. The order of this array is
+     * arbitrary.
+     */
+    apps?: bigint[];
+    /**
+     * The unnamed asset holdings that were referenced. The order of this array is
+     * arbitrary.
+     */
+    assetHoldings?: AssetHoldingReference[];
+    /**
+     * The unnamed assets that were referenced. The order of this array is arbitrary.
+     */
+    assets?: bigint[];
+    /**
+     * The unnamed boxes that were referenced. The order of this array is arbitrary.
+     */
+    boxes?: BoxReference[];
+    /**
+     * The number of extra box references used to increase the IO budget. This is in
+     * addition to the references defined in the input transaction group and any
+     * referenced to unnamed boxes.
+     */
+    extraBoxRefs?: number;
+    /**
+     * Creates a new `SimulateUnnamedResourcesAccessed` object.
+     * @param accounts - The unnamed accounts that were referenced. The order of this array is arbitrary.
+     * @param appLocals - The unnamed application local states that were referenced. The order of this
+     * array is arbitrary.
+     * @param apps - The unnamed applications that were referenced. The order of this array is
+     * arbitrary.
+     * @param assetHoldings - The unnamed asset holdings that were referenced. The order of this array is
+     * arbitrary.
+     * @param assets - The unnamed assets that were referenced. The order of this array is arbitrary.
+     * @param boxes - The unnamed boxes that were referenced. The order of this array is arbitrary.
+     * @param extraBoxRefs - The number of extra box references used to increase the IO budget. This is in
+     * addition to the references defined in the input transaction group and any
+     * referenced to unnamed boxes.
+     */
+    constructor({ accounts, appLocals, apps, assetHoldings, assets, boxes, extraBoxRefs, }: {
+        accounts?: (Address$1 | string)[];
+        appLocals?: ApplicationLocalReference[];
+        apps?: (number | bigint)[];
+        assetHoldings?: AssetHoldingReference[];
+        assets?: (number | bigint)[];
+        boxes?: BoxReference[];
+        extraBoxRefs?: number | bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SimulateUnnamedResourcesAccessed;
+}
+/**
+ * The set of parameters and limits override during simulation. If this set of
+ * parameters is present, then evaluation parameters may differ from standard
+ * evaluation in certain ways.
+ */
+declare class SimulationEvalOverrides implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * If true, transactions without signatures are allowed and simulated as if they
+     * were properly signed.
+     */
+    allowEmptySignatures?: boolean;
+    /**
+     * If true, allows access to unnamed resources during simulation.
+     */
+    allowUnnamedResources?: boolean;
+    /**
+     * The extra opcode budget added to each transaction group during simulation
+     */
+    extraOpcodeBudget?: number;
+    /**
+     * If true, signers for transactions that are missing signatures will be fixed
+     * during evaluation.
+     */
+    fixSigners?: boolean;
+    /**
+     * The maximum log calls one can make during simulation
+     */
+    maxLogCalls?: number;
+    /**
+     * The maximum byte number to log during simulation
+     */
+    maxLogSize?: number;
+    /**
+     * Creates a new `SimulationEvalOverrides` object.
+     * @param allowEmptySignatures - If true, transactions without signatures are allowed and simulated as if they
+     * were properly signed.
+     * @param allowUnnamedResources - If true, allows access to unnamed resources during simulation.
+     * @param extraOpcodeBudget - The extra opcode budget added to each transaction group during simulation
+     * @param fixSigners - If true, signers for transactions that are missing signatures will be fixed
+     * during evaluation.
+     * @param maxLogCalls - The maximum log calls one can make during simulation
+     * @param maxLogSize - The maximum byte number to log during simulation
+     */
+    constructor({ allowEmptySignatures, allowUnnamedResources, extraOpcodeBudget, fixSigners, maxLogCalls, maxLogSize, }: {
+        allowEmptySignatures?: boolean;
+        allowUnnamedResources?: boolean;
+        extraOpcodeBudget?: number | bigint;
+        fixSigners?: boolean;
+        maxLogCalls?: number | bigint;
+        maxLogSize?: number | bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SimulationEvalOverrides;
+}
+/**
+ * The set of trace information and effect from evaluating a single opcode.
+ */
+declare class SimulationOpcodeTraceUnit implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * The program counter of the current opcode being evaluated.
+     */
+    pc: number;
+    /**
+     * The writes into scratch slots.
+     */
+    scratchChanges?: ScratchChange[];
+    /**
+     * The indexes of the traces for inner transactions spawned by this opcode, if any.
+     */
+    spawnedInners?: number[];
+    /**
+     * The values added by this opcode to the stack.
+     */
+    stackAdditions?: AvmValue[];
+    /**
+     * The number of deleted stack values by this opcode.
+     */
+    stackPopCount?: number;
+    /**
+     * The operations against the current application's states.
+     */
+    stateChanges?: ApplicationStateOperation[];
+    /**
+     * Creates a new `SimulationOpcodeTraceUnit` object.
+     * @param pc - The program counter of the current opcode being evaluated.
+     * @param scratchChanges - The writes into scratch slots.
+     * @param spawnedInners - The indexes of the traces for inner transactions spawned by this opcode, if any.
+     * @param stackAdditions - The values added by this opcode to the stack.
+     * @param stackPopCount - The number of deleted stack values by this opcode.
+     * @param stateChanges - The operations against the current application's states.
+     */
+    constructor({ pc, scratchChanges, spawnedInners, stackAdditions, stackPopCount, stateChanges, }: {
+        pc: number | bigint;
+        scratchChanges?: ScratchChange[];
+        spawnedInners?: (number | bigint)[];
+        stackAdditions?: AvmValue[];
+        stackPopCount?: number | bigint;
+        stateChanges?: ApplicationStateOperation[];
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SimulationOpcodeTraceUnit;
+}
+/**
+ * The execution trace of calling an app or a logic sig, containing the inner app
+ * call trace in a recursive way.
+ */
+declare class SimulationTransactionExecTrace implements Encodable {
+    private static encodingSchemaValue;
+    static get encodingSchema(): Schema;
+    /**
+     * SHA512_256 hash digest of the approval program executed in transaction.
+     */
+    approvalProgramHash?: Uint8Array;
+    /**
+     * Program trace that contains a trace of opcode effects in an approval program.
+     */
+    approvalProgramTrace?: SimulationOpcodeTraceUnit[];
+    /**
+     * SHA512_256 hash digest of the clear state program executed in transaction.
+     */
+    clearStateProgramHash?: Uint8Array;
+    /**
+     * Program trace that contains a trace of opcode effects in a clear state program.
+     */
+    clearStateProgramTrace?: SimulationOpcodeTraceUnit[];
+    /**
+     * If true, indicates that the clear state program failed and any persistent state
+     * changes it produced should be reverted once the program exits.
+     */
+    clearStateRollback?: boolean;
+    /**
+     * The error message explaining why the clear state program failed. This field will
+     * only be populated if clear-state-rollback is true and the failure was due to an
+     * execution error.
+     */
+    clearStateRollbackError?: string;
+    /**
+     * An array of SimulationTransactionExecTrace representing the execution trace of
+     * any inner transactions executed.
+     */
+    innerTrace?: SimulationTransactionExecTrace[];
+    /**
+     * SHA512_256 hash digest of the logic sig executed in transaction.
+     */
+    logicSigHash?: Uint8Array;
+    /**
+     * Program trace that contains a trace of opcode effects in a logic sig.
+     */
+    logicSigTrace?: SimulationOpcodeTraceUnit[];
+    /**
+     * Creates a new `SimulationTransactionExecTrace` object.
+     * @param approvalProgramHash - SHA512_256 hash digest of the approval program executed in transaction.
+     * @param approvalProgramTrace - Program trace that contains a trace of opcode effects in an approval program.
+     * @param clearStateProgramHash - SHA512_256 hash digest of the clear state program executed in transaction.
+     * @param clearStateProgramTrace - Program trace that contains a trace of opcode effects in a clear state program.
+     * @param clearStateRollback - If true, indicates that the clear state program failed and any persistent state
+     * changes it produced should be reverted once the program exits.
+     * @param clearStateRollbackError - The error message explaining why the clear state program failed. This field will
+     * only be populated if clear-state-rollback is true and the failure was due to an
+     * execution error.
+     * @param innerTrace - An array of SimulationTransactionExecTrace representing the execution trace of
+     * any inner transactions executed.
+     * @param logicSigHash - SHA512_256 hash digest of the logic sig executed in transaction.
+     * @param logicSigTrace - Program trace that contains a trace of opcode effects in a logic sig.
+     */
+    constructor({ approvalProgramHash, approvalProgramTrace, clearStateProgramHash, clearStateProgramTrace, clearStateRollback, clearStateRollbackError, innerTrace, logicSigHash, logicSigTrace, }: {
+        approvalProgramHash?: string | Uint8Array;
+        approvalProgramTrace?: SimulationOpcodeTraceUnit[];
+        clearStateProgramHash?: string | Uint8Array;
+        clearStateProgramTrace?: SimulationOpcodeTraceUnit[];
+        clearStateRollback?: boolean;
+        clearStateRollbackError?: string;
+        innerTrace?: SimulationTransactionExecTrace[];
+        logicSigHash?: string | Uint8Array;
+        logicSigTrace?: SimulationOpcodeTraceUnit[];
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SimulationTransactionExecTrace;
+}
+
+declare function getVkey(zKey: snarkjs.ZKArtifact, curve: any): Promise<VerificationKey>;
+declare function encodeVk(vkey: VerificationKey, appSpec: Arc56Contract): Uint8Array;
+declare function getProof(path: string, curve: any): Promise<Proof>;
+declare function encodeProof(proof: any, curve: any): Proof;
+declare function encodeSignals(...inputs: string[]): bigint[];
+type ProofAndSignals = {
+    proof: Proof;
+    signals: bigint[];
+};
+declare class AppVerifier {
+    algorand: AlgorandClient$1;
+    zKey: snarkjs.ZKArtifact;
+    wasmProver: snarkjs.ZKArtifact;
+    appClient?: PlonkVerifierClient;
+    curve?: any;
+    constructor(algorand: AlgorandClient$1, zKey: snarkjs.ZKArtifact, wasmProver: snarkjs.ZKArtifact);
+    private ensureCurveInstanttiation;
+    deploy(params: Omit<PlonkVerifierDeployParams, "deployTimeParams"> & {
+        defaultSender: Address;
+        debugLogging?: boolean;
+    }): Promise<PlonkVerifierClient>;
+    proofAndSignals(inputs: snarkjs.CircuitSignals): Promise<ProofAndSignals>;
+    private assertDeployed;
+    simulateVerificationWithProofAndSignals(proofAndSignals: ProofAndSignals, simParams?: RawSimulateOptions): Promise<{
+        groupId: string;
+        txIds: string[];
+        returns: _algorandfoundation_algokit_utils_types_app.ABIReturn[] & [void | undefined];
+        confirmations: PendingTransactionResponse[];
+        transactions: Transaction[];
+    } & {
+        simulateResponse: SimulateResponse;
+    }>;
+    verifyTransactionFromProofAndSignals(proofAndSignals: ProofAndSignals): Promise<Transaction>;
+    callVerifyFromProofAndSignals(proofAndSignals: ProofAndSignals, callParams?: Omit<AppClientMethodCallParams, "method" | "args" | "onComplete">): Promise<{
+        return: (undefined | PlonkVerifierReturns["verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void"]);
+        groupId: string;
+        txIds: string[];
+        returns?: _algorandfoundation_algokit_utils_types_app.ABIReturn[] | undefined | undefined;
+        confirmations: PendingTransactionResponse[];
+        transactions: Transaction[];
+        confirmation: PendingTransactionResponse;
+        transaction: Transaction;
+    }>;
+    simulateVerification(inputs: snarkjs.CircuitSignals, simParams?: RawSimulateOptions): Promise<{
+        groupId: string;
+        txIds: string[];
+        returns: _algorandfoundation_algokit_utils_types_app.ABIReturn[] & [void | undefined];
+        confirmations: PendingTransactionResponse[];
+        transactions: Transaction[];
+    } & {
+        simulateResponse: SimulateResponse;
+    }>;
+    verifyTransaction(inputs: snarkjs.CircuitSignals): Promise<Transaction>;
+    callVerify(inputs: snarkjs.CircuitSignals, callParams?: Omit<AppClientMethodCallParams, "method" | "args" | "onComplete">): Promise<{
+        return: (undefined | PlonkVerifierReturns["verify(uint256[],(byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],byte[96],uint256,uint256,uint256,uint256,uint256,uint256))void"]);
+        groupId: string;
+        txIds: string[];
+        returns?: _algorandfoundation_algokit_utils_types_app.ABIReturn[] | undefined | undefined;
+        confirmations: PendingTransactionResponse[];
+        transactions: Transaction[];
+        confirmation: PendingTransactionResponse;
+        transaction: Transaction;
+    }>;
+}
+
+export { AppVerifier, PlonkVerifierClient, type PlonkVerifierDeployParams, type Proof, type ProofAndSignals, type VerificationKey, encodeProof, encodeSignals, encodeVk, getProof, getVkey };