@silvana-one/token 0.1.0

package/README.md

@@ -0,0 +1 @@
+# Silvana Fungible Token Library

package/dist/node/BondingCurveAdmin.d.ts

@@ -0,0 +1,690 @@
+import { AccountUpdate, Bool, DeployArgs, PublicKey, TokenContract, State, UInt64, VerificationKey, Field, AccountUpdateForest, Int64, UInt32 } from "o1js";
+import { FungibleTokenAdminBase } from "@silvana-one/token";
+declare const BondingCurveParams_base: (new (value: {
+    startPrice: UInt64;
+    curveK: UInt64;
+    fee: UInt32;
+    mintingIsAllowed: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+}) => {
+    startPrice: UInt64;
+    curveK: UInt64;
+    fee: UInt32;
+    mintingIsAllowed: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+}) & {
+    _isStruct: true;
+} & Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
+    startPrice: UInt64;
+    curveK: UInt64;
+    fee: UInt32;
+    mintingIsAllowed: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+}, {
+    startPrice: bigint;
+    curveK: bigint;
+    fee: bigint;
+    mintingIsAllowed: boolean;
+}>, "fromFields"> & {
+    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
+        startPrice: UInt64;
+        curveK: UInt64;
+        fee: UInt32;
+        mintingIsAllowed: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    };
+} & {
+    fromValue: (value: {
+        startPrice: bigint | UInt64;
+        curveK: bigint | UInt64;
+        fee: bigint | UInt32;
+        mintingIsAllowed: boolean | import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    }) => {
+        startPrice: UInt64;
+        curveK: UInt64;
+        fee: UInt32;
+        mintingIsAllowed: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    };
+    toInput: (x: {
+        startPrice: UInt64;
+        curveK: UInt64;
+        fee: UInt32;
+        mintingIsAllowed: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        startPrice: UInt64;
+        curveK: UInt64;
+        fee: UInt32;
+        mintingIsAllowed: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    }) => {
+        startPrice: string;
+        curveK: string;
+        fee: string;
+        mintingIsAllowed: boolean;
+    };
+    fromJSON: (x: {
+        startPrice: string;
+        curveK: string;
+        fee: string;
+        mintingIsAllowed: boolean;
+    }) => {
+        startPrice: UInt64;
+        curveK: UInt64;
+        fee: UInt32;
+        mintingIsAllowed: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    };
+    empty: () => {
+        startPrice: UInt64;
+        curveK: UInt64;
+        fee: UInt32;
+        mintingIsAllowed: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    };
+};
+/**
+ * Default bonding curve:
+ * Initial price: 1 MINA per 100,000 tokens (0.00001 MINA per token), or 10_000 / 10 ** 9
+ * Curve K: 1 MINA per 100,000 tokens (0.00001 MINA per token), or 10_000 / 10 ** 9 MINA
+ * Owner fee: 10% in 0.001 % units(10 * 1000 = 10_000)
+ * Price formula: price = startPrice + curveK * totalSupply
+ * Example:
+ * If supply is 200,000 tokens, price = 1 MINA + 1 MINA * 200_000 / 100_000 = 3 MINA per 100,000 tokens
+ * or per token in MINA/1e9
+ * 10000 + 10000 * 200_000 / 100_000 = 30000 per token,
+ * or 30_000 * 100_000 = 3_000_000_000, or 3 MINA per 100,000 tokens
+ *
+ * To calculate the max supply for the given price for 100,000 tokens:
+ * price = startPrice + curveK * totalSupply
+ * price - startPrice = curveK * totalSupply
+ * (price - startPrice) / curveK = totalSupply
+ * (3 MINA - 1 MINA) / 1 MINA = 2 * 100_000 = 200_000 tokens
+ * (30_000 - 10_000) / 10_000 = 2 * 100_000 = 200_000 tokens
+ * or, in 1e9 units:
+ * (30_000 - 10_000) * 1e9 * 100_000 / 10_000 = 200_000_000_000_000, or to avoid overflow,
+ * (30_000 - 10_000) * 1e9 / 10_000 * 100_000  = 200_000_000_000_000
+ */
+export declare class BondingCurveParams extends BondingCurveParams_base {
+    pack(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    static unpack(field: Field): BondingCurveParams;
+}
+declare const BondingMintEvent_base: (new (value: {
+    to: PublicKey;
+    amount: UInt64;
+    price: UInt64;
+    payment: UInt64;
+    fee: UInt64;
+}) => {
+    to: PublicKey;
+    amount: UInt64;
+    price: UInt64;
+    payment: UInt64;
+    fee: UInt64;
+}) & {
+    _isStruct: true;
+} & Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
+    to: PublicKey;
+    amount: UInt64;
+    price: UInt64;
+    payment: UInt64;
+    fee: UInt64;
+}, {
+    to: {
+        x: bigint;
+        isOdd: boolean;
+    };
+    amount: bigint;
+    price: bigint;
+    payment: bigint;
+    fee: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
+        to: PublicKey;
+        amount: UInt64;
+        price: UInt64;
+        payment: UInt64;
+        fee: UInt64;
+    };
+} & {
+    fromValue: (value: {
+        to: PublicKey | {
+            x: Field | bigint;
+            isOdd: Bool | boolean;
+        };
+        amount: bigint | UInt64;
+        price: bigint | UInt64;
+        payment: bigint | UInt64;
+        fee: bigint | UInt64;
+    }) => {
+        to: PublicKey;
+        amount: UInt64;
+        price: UInt64;
+        payment: UInt64;
+        fee: UInt64;
+    };
+    toInput: (x: {
+        to: PublicKey;
+        amount: UInt64;
+        price: UInt64;
+        payment: UInt64;
+        fee: UInt64;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        to: PublicKey;
+        amount: UInt64;
+        price: UInt64;
+        payment: UInt64;
+        fee: UInt64;
+    }) => {
+        to: string;
+        amount: string;
+        price: string;
+        payment: string;
+        fee: string;
+    };
+    fromJSON: (x: {
+        to: string;
+        amount: string;
+        price: string;
+        payment: string;
+        fee: string;
+    }) => {
+        to: PublicKey;
+        amount: UInt64;
+        price: UInt64;
+        payment: UInt64;
+        fee: UInt64;
+    };
+    empty: () => {
+        to: PublicKey;
+        amount: UInt64;
+        price: UInt64;
+        payment: UInt64;
+        fee: UInt64;
+    };
+};
+export declare class BondingMintEvent extends BondingMintEvent_base {
+}
+declare const BondingRedeemEvent_base: (new (value: {
+    seller: PublicKey;
+    amount: UInt64;
+    payment: UInt64;
+    minBalance: UInt64;
+    maxSupply: UInt64;
+    fee: UInt64;
+}) => {
+    seller: PublicKey;
+    amount: UInt64;
+    payment: UInt64;
+    minBalance: UInt64;
+    maxSupply: UInt64;
+    fee: UInt64;
+}) & {
+    _isStruct: true;
+} & Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
+    seller: PublicKey;
+    amount: UInt64;
+    payment: UInt64;
+    minBalance: UInt64;
+    maxSupply: UInt64;
+    fee: UInt64;
+}, {
+    seller: {
+        x: bigint;
+        isOdd: boolean;
+    };
+    amount: bigint;
+    payment: bigint;
+    minBalance: bigint;
+    maxSupply: bigint;
+    fee: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
+        seller: PublicKey;
+        amount: UInt64;
+        payment: UInt64;
+        minBalance: UInt64;
+        maxSupply: UInt64;
+        fee: UInt64;
+    };
+} & {
+    fromValue: (value: {
+        seller: PublicKey | {
+            x: Field | bigint;
+            isOdd: Bool | boolean;
+        };
+        amount: bigint | UInt64;
+        payment: bigint | UInt64;
+        minBalance: bigint | UInt64;
+        maxSupply: bigint | UInt64;
+        fee: bigint | UInt64;
+    }) => {
+        seller: PublicKey;
+        amount: UInt64;
+        payment: UInt64;
+        minBalance: UInt64;
+        maxSupply: UInt64;
+        fee: UInt64;
+    };
+    toInput: (x: {
+        seller: PublicKey;
+        amount: UInt64;
+        payment: UInt64;
+        minBalance: UInt64;
+        maxSupply: UInt64;
+        fee: UInt64;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        seller: PublicKey;
+        amount: UInt64;
+        payment: UInt64;
+        minBalance: UInt64;
+        maxSupply: UInt64;
+        fee: UInt64;
+    }) => {
+        seller: string;
+        amount: string;
+        payment: string;
+        minBalance: string;
+        maxSupply: string;
+        fee: string;
+    };
+    fromJSON: (x: {
+        seller: string;
+        amount: string;
+        payment: string;
+        minBalance: string;
+        maxSupply: string;
+        fee: string;
+    }) => {
+        seller: PublicKey;
+        amount: UInt64;
+        payment: UInt64;
+        minBalance: UInt64;
+        maxSupply: UInt64;
+        fee: UInt64;
+    };
+    empty: () => {
+        seller: PublicKey;
+        amount: UInt64;
+        payment: UInt64;
+        minBalance: UInt64;
+        maxSupply: UInt64;
+        fee: UInt64;
+    };
+};
+export declare class BondingRedeemEvent extends BondingRedeemEvent_base {
+}
+declare const BondingCurveAdminInitializeProps_base: (new (value: {
+    tokenAddress: PublicKey;
+    startPrice: UInt64;
+    curveK: UInt64;
+    feeMaster: PublicKey;
+    fee: UInt32;
+    launchFee: UInt64;
+    numberOfNewAccounts: UInt64;
+}) => {
+    tokenAddress: PublicKey;
+    startPrice: UInt64;
+    curveK: UInt64;
+    feeMaster: PublicKey;
+    fee: UInt32;
+    launchFee: UInt64;
+    numberOfNewAccounts: UInt64;
+}) & {
+    _isStruct: true;
+} & Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
+    tokenAddress: PublicKey;
+    startPrice: UInt64;
+    curveK: UInt64;
+    feeMaster: PublicKey;
+    fee: UInt32;
+    launchFee: UInt64;
+    numberOfNewAccounts: UInt64;
+}, {
+    tokenAddress: {
+        x: bigint;
+        isOdd: boolean;
+    };
+    startPrice: bigint;
+    curveK: bigint;
+    feeMaster: {
+        x: bigint;
+        isOdd: boolean;
+    };
+    fee: bigint;
+    launchFee: bigint;
+    numberOfNewAccounts: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
+        tokenAddress: PublicKey;
+        startPrice: UInt64;
+        curveK: UInt64;
+        feeMaster: PublicKey;
+        fee: UInt32;
+        launchFee: UInt64;
+        numberOfNewAccounts: UInt64;
+    };
+} & {
+    fromValue: (value: {
+        tokenAddress: PublicKey | {
+            x: Field | bigint;
+            isOdd: Bool | boolean;
+        };
+        startPrice: bigint | UInt64;
+        curveK: bigint | UInt64;
+        feeMaster: PublicKey | {
+            x: Field | bigint;
+            isOdd: Bool | boolean;
+        };
+        fee: bigint | UInt32;
+        launchFee: bigint | UInt64;
+        numberOfNewAccounts: bigint | UInt64;
+    }) => {
+        tokenAddress: PublicKey;
+        startPrice: UInt64;
+        curveK: UInt64;
+        feeMaster: PublicKey;
+        fee: UInt32;
+        launchFee: UInt64;
+        numberOfNewAccounts: UInt64;
+    };
+    toInput: (x: {
+        tokenAddress: PublicKey;
+        startPrice: UInt64;
+        curveK: UInt64;
+        feeMaster: PublicKey;
+        fee: UInt32;
+        launchFee: UInt64;
+        numberOfNewAccounts: UInt64;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        tokenAddress: PublicKey;
+        startPrice: UInt64;
+        curveK: UInt64;
+        feeMaster: PublicKey;
+        fee: UInt32;
+        launchFee: UInt64;
+        numberOfNewAccounts: UInt64;
+    }) => {
+        tokenAddress: string;
+        startPrice: string;
+        curveK: string;
+        feeMaster: string;
+        fee: string;
+        launchFee: string;
+        numberOfNewAccounts: string;
+    };
+    fromJSON: (x: {
+        tokenAddress: string;
+        startPrice: string;
+        curveK: string;
+        feeMaster: string;
+        fee: string;
+        launchFee: string;
+        numberOfNewAccounts: string;
+    }) => {
+        tokenAddress: PublicKey;
+        startPrice: UInt64;
+        curveK: UInt64;
+        feeMaster: PublicKey;
+        fee: UInt32;
+        launchFee: UInt64;
+        numberOfNewAccounts: UInt64;
+    };
+    empty: () => {
+        tokenAddress: PublicKey;
+        startPrice: UInt64;
+        curveK: UInt64;
+        feeMaster: PublicKey;
+        fee: UInt32;
+        launchFee: UInt64;
+        numberOfNewAccounts: UInt64;
+    };
+};
+export declare class BondingCurveAdminInitializeProps extends BondingCurveAdminInitializeProps_base {
+}
+export declare class FungibleTokenBondingCurveAdmin extends TokenContract implements FungibleTokenAdminBase {
+    owner: State<PublicKey>;
+    token: State<PublicKey>;
+    feeMaster: State<PublicKey>;
+    curve: State<import("node_modules/o1js/dist/node/lib/provable/field.js").Field>;
+    insideMint: State<import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool>;
+    events: {
+        mint: typeof BondingMintEvent;
+        redeem: typeof BondingRedeemEvent;
+    };
+    deploy(props: DeployArgs): Promise<void>;
+    approveBase(forest: AccountUpdateForest): Promise<void>;
+    initialize(props: BondingCurveAdminInitializeProps): Promise<void>;
+    mint(to: PublicKey, amount: UInt64, price: UInt64): Promise<void>;
+    redeem(amount: UInt64, minPrice: UInt64, slippage: UInt32): Promise<void>;
+    /**
+     * In case the user burned tokens without calling the redeem method,
+     * we need to sync the supply to the actual circulated supply
+     */
+    sync(): Promise<void>;
+    /** Update the verification key.
+     * Note that because we have set the permissions for setting the verification key to `impossibleDuringCurrentVersion()`, this will only be possible in case of a protocol update that requires an update.
+     */
+    updateVerificationKey(vk: VerificationKey): Promise<void>;
+    ensureOwnerSignature(): AccountUpdate;
+    canMint(_accountUpdate: AccountUpdate): Promise<import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool>;
+    canChangeAdmin(_admin: PublicKey): Promise<import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool>;
+    canPause(): Promise<Bool>;
+    canResume(): Promise<Bool>;
+    canChangeVerificationKey(_vk: VerificationKey): Promise<Bool>;
+}
+export declare const BondingCurveFungibleToken: {
+    new (address: PublicKey, tokenId?: Field): {
+        decimals: State<import("o1js").UInt8>;
+        admin: State<PublicKey>;
+        paused: State<import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool>;
+        readonly events: {
+            SetAdmin: typeof import("@silvana-one/token").SetAdminEvent;
+            Pause: typeof import("@silvana-one/token").PauseEvent;
+            Mint: typeof import("@silvana-one/token").MintEvent;
+            Burn: typeof import("@silvana-one/token").BurnEvent;
+            BalanceChange: typeof import("@silvana-one/token").BalanceChangeEvent;
+        };
+        deploy(props: import("@silvana-one/token").FungibleTokenDeployProps): Promise<void>;
+        updateVerificationKey(vk: VerificationKey): Promise<void>;
+        initialize(admin: PublicKey, decimals: import("o1js").UInt8, startPaused: Bool): Promise<void>;
+        getAdminContract(): Promise<FungibleTokenAdminBase>;
+        setAdmin(admin: PublicKey): Promise<void>;
+        mint(recipient: PublicKey, amount: UInt64): Promise<AccountUpdate>;
+        burn(from: PublicKey, amount: UInt64): Promise<AccountUpdate>;
+        pause(): Promise<void>;
+        resume(): Promise<void>;
+        transfer(from: PublicKey, to: PublicKey, amount: UInt64): Promise<void>;
+        checkPermissionsUpdate(update: AccountUpdate): void;
+        approveBase(updates: AccountUpdateForest): Promise<void>;
+        getBalanceOf(address: PublicKey): Promise<UInt64>;
+        getCirculating(): Promise<UInt64>;
+        getDecimals(): Promise<import("o1js").UInt8>;
+        deriveTokenId(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        readonly internal: {
+            mint({ address, amount, }: {
+                address: PublicKey | AccountUpdate | import("o1js").SmartContract;
+                amount: number | bigint | UInt64;
+            }): AccountUpdate;
+            burn({ address, amount, }: {
+                address: PublicKey | AccountUpdate | import("o1js").SmartContract;
+                amount: number | bigint | UInt64;
+            }): AccountUpdate;
+            send({ from, to, amount, }: {
+                from: PublicKey | AccountUpdate | import("o1js").SmartContract;
+                to: PublicKey | AccountUpdate | import("o1js").SmartContract;
+                amount: number | bigint | UInt64;
+            }): AccountUpdate;
+        };
+        forEachUpdate(updates: AccountUpdateForest, callback: (update: AccountUpdate, usesToken: Bool) => void): void;
+        checkZeroBalanceChange(updates: AccountUpdateForest): void;
+        approveAccountUpdate(accountUpdate: AccountUpdate | import("o1js").AccountUpdateTree): Promise<void>;
+        approveAccountUpdates(accountUpdates: (AccountUpdate | import("o1js").AccountUpdateTree)[]): Promise<void>;
+        "__#3@#private": any;
+        address: PublicKey;
+        tokenId: Field;
+        init(): void;
+        requireSignature(): void;
+        skipAuthorization(): void;
+        readonly self: AccountUpdate;
+        newSelf(methodName?: string): AccountUpdate;
+        sender: {
+            self: import("o1js").SmartContract;
+            getUnconstrained(): PublicKey;
+            getAndRequireSignature(): PublicKey;
+        };
+        readonly account: import("node_modules/o1js/dist/node/lib/mina/precondition.js").Account;
+        readonly network: import("node_modules/o1js/dist/node/lib/mina/precondition.js").Network;
+        readonly currentSlot: import("node_modules/o1js/dist/node/lib/mina/precondition.js").CurrentSlot;
+        approve(update: AccountUpdate | import("o1js").AccountUpdateTree | AccountUpdateForest): void;
+        send(args: {
+            to: PublicKey | AccountUpdate | import("o1js").SmartContract;
+            amount: number | bigint | UInt64;
+        }): AccountUpdate;
+        readonly balance: {
+            addInPlace(x: string | number | bigint | UInt64 | UInt32 | import("node_modules/o1js/dist/node/lib/provable/int.js").Int64): void;
+            subInPlace(x: string | number | bigint | UInt64 | UInt32 | import("node_modules/o1js/dist/node/lib/provable/int.js").Int64): void;
+        };
+        emitEventIf<K extends "SetAdmin" | "Pause" | "Mint" | "Burn" | "BalanceChange">(condition: Bool, type: K, event: any): void;
+        emitEvent<K extends "SetAdmin" | "Pause" | "Mint" | "Burn" | "BalanceChange">(type: K, event: any): void;
+        fetchEvents(start?: UInt32, end?: UInt32): Promise<{
+            type: string;
+            event: {
+                data: import("o1js").ProvablePure<any>;
+                transactionInfo: {
+                    transactionHash: string;
+                    transactionStatus: string;
+                    transactionMemo: string;
+                };
+            };
+            blockHeight: UInt32;
+            blockHash: string;
+            parentBlockHash: string;
+            globalSlot: UInt32;
+            chainStatus: string;
+        }[]>;
+    };
+    MAX_ACCOUNT_UPDATES: number;
+    _methods?: import("node_modules/o1js/dist/node/lib/proof-system/zkprogram.js").MethodInterface[];
+    _methodMetadata?: Record<string, {
+        actions: number;
+        rows: number;
+        digest: string;
+        gates: import("node_modules/o1js/dist/node/snarky.js").Gate[];
+    }>;
+    _provers?: import("node_modules/o1js/dist/node/snarky.js").Pickles.Prover[];
+    _maxProofsVerified?: 0 | 1 | 2;
+    _verificationKey?: {
+        data: string;
+        hash: Field;
+    };
+    Proof(): {
+        new ({ proof, publicInput, publicOutput, maxProofsVerified, }: {
+            proof: unknown;
+            publicInput: import("o1js").ZkappPublicInput;
+            publicOutput: undefined;
+            maxProofsVerified: 0 | 2 | 1;
+        }): {
+            verify(): void;
+            verifyIf(condition: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool): void;
+            publicInput: import("o1js").ZkappPublicInput;
+            publicOutput: undefined;
+            proof: unknown;
+            maxProofsVerified: 0 | 2 | 1;
+            shouldVerify: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+            toJSON(): import("o1js").JsonProof;
+            publicFields(): {
+                input: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
+                output: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
+            };
+        };
+        publicInputType: Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
+            accountUpdate: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+            calls: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        }, {
+            accountUpdate: bigint;
+            calls: bigint;
+        }>, "fromFields"> & {
+            fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
+                accountUpdate: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+                calls: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+            };
+        } & {
+            toInput: (x: {
+                accountUpdate: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+                calls: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+            }) => {
+                fields?: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[] | undefined;
+                packed?: [import("node_modules/o1js/dist/node/lib/provable/field.js").Field, number][] | undefined;
+            };
+            toJSON: (x: {
+                accountUpdate: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+                calls: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+            }) => {
+                accountUpdate: string;
+                calls: string;
+            };
+            fromJSON: (x: {
+                accountUpdate: string;
+                calls: string;
+            }) => {
+                accountUpdate: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+                calls: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+            };
+            empty: () => {
+                accountUpdate: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+                calls: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+            };
+        };
+        publicOutputType: import("node_modules/o1js/dist/node/lib/provable/types/struct.js").ProvablePureExtended<undefined, undefined, null>;
+        tag: () => typeof import("o1js").SmartContract;
+        fromJSON<S extends import("node_modules/o1js/dist/node/lib/util/types.js").Subclass<typeof import("o1js").Proof>>(this: S, { maxProofsVerified, proof: proofString, publicInput: publicInputJson, publicOutput: publicOutputJson, }: import("o1js").JsonProof): Promise<import("o1js").Proof<import("o1js").InferProvable<S["publicInputType"]>, import("o1js").InferProvable<S["publicOutputType"]>>>;
+        dummy<Input, OutPut>(publicInput: Input, publicOutput: OutPut, maxProofsVerified: 0 | 2 | 1, domainLog2?: number): Promise<import("o1js").Proof<Input, OutPut>>;
+        readonly provable: {
+            toFields: (value: import("o1js").Proof<any, any>) => import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
+            toAuxiliary: (value?: import("o1js").Proof<any, any> | undefined) => any[];
+            fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[], aux: any[]) => import("o1js").Proof<any, any>;
+            sizeInFields(): number;
+            check: (value: import("o1js").Proof<any, any>) => void;
+            toValue: (x: import("o1js").Proof<any, any>) => import("node_modules/o1js/dist/node/lib/proof-system/proof.js").ProofValue<any, any>;
+            fromValue: (x: import("o1js").Proof<any, any> | import("node_modules/o1js/dist/node/lib/proof-system/proof.js").ProofValue<any, any>) => import("o1js").Proof<any, any>;
+            toCanonical?: ((x: import("o1js").Proof<any, any>) => import("o1js").Proof<any, any>) | undefined;
+        };
+        publicFields(value: import("o1js").ProofBase<any, any>): {
+            input: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
+            output: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[];
+        };
+        _proofFromBase64(proofString: string, maxProofsVerified: 0 | 2 | 1): unknown;
+        _proofToBase64(proof: unknown, maxProofsVerified: 0 | 2 | 1): string;
+    };
+    compile({ cache, forceRecompile, }?: {
+        cache?: import("o1js").Cache | undefined;
+        forceRecompile?: boolean | undefined;
+    }): Promise<{
+        verificationKey: {
+            data: string;
+            hash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        };
+        provers: import("node_modules/o1js/dist/node/snarky.js").Pickles.Prover[];
+        verify: (statement: import("node_modules/o1js/dist/node/snarky.js").Pickles.Statement<import("node_modules/o1js/dist/node/lib/provable/core/fieldvar.js").FieldConst>, proof: unknown) => Promise<boolean>;
+    }>;
+    digest(): Promise<string>;
+    runOutsideCircuit(run: () => void): void;
+    analyzeMethods({ printSummary }?: {
+        printSummary?: boolean | undefined;
+    }): Promise<Record<string, {
+        actions: number;
+        rows: number;
+        digest: string;
+        gates: import("node_modules/o1js/dist/node/snarky.js").Gate[];
+    }>>;
+};
+export {};