export * from 'mina-fungible-token'; import * as o1js from 'o1js'; import { UInt64, Bool, Field, UInt32, PublicKey, MerkleMapWitness, Signature, State, Int64, TokenContract, VerificationKey, AccountUpdateForest, Types, DeployArgs, SmartContract } from 'o1js'; import * as o1js_dist_node_lib_provable_field_js from 'o1js/dist/node/lib/provable/field.js'; import * as o1js_dist_node_lib_provable_types_provable_intf_js from 'o1js/dist/node/lib/provable/types/provable-intf.js'; import * as o1js_dist_node_lib_provable_field from 'o1js/dist/node/lib/provable/field'; import * as o1js_dist_node_lib_provable_types_provable_intf from 'o1js/dist/node/lib/provable/types/provable-intf'; import * as o1js_dist_node_lib_provable_bool from 'o1js/dist/node/lib/provable/bool'; import * as o1js_dist_node_lib_provable_merkle_tree from 'o1js/dist/node/lib/provable/merkle-tree'; /** * Function to multiply one Uint64 by another and divide the result, * We check for overflow on the final result to avoid a premature overflow error. * @param a The multiplicand * @param b The multiplier * @param denominator The divisor * @returns the quotient and the remainder */ declare function mulDivMod(a: UInt64, b: UInt64, denominator: UInt64): { quotient: UInt64; rest: UInt64; }; /** * Function to multiply one Uint64 by another and divide the result, * We check for overflow on the final result to avoid a premature overflow error. * @param a The multiplicand * @param b The multiplier * @param denominator The divisor * @returns The 64-bit result */ declare function mulDiv(a: UInt64, b: UInt64, denominator: UInt64): UInt64; declare const SignatureRight_base: (new (value: { deployPool: o1js_dist_node_lib_provable_bool.Bool; uppdatePool: o1js_dist_node_lib_provable_bool.Bool; updateSigner: o1js_dist_node_lib_provable_bool.Bool; updateProtocol: o1js_dist_node_lib_provable_bool.Bool; updateDelegator: o1js_dist_node_lib_provable_bool.Bool; updateFactory: o1js_dist_node_lib_provable_bool.Bool; }) => { deployPool: o1js_dist_node_lib_provable_bool.Bool; uppdatePool: o1js_dist_node_lib_provable_bool.Bool; updateSigner: o1js_dist_node_lib_provable_bool.Bool; updateProtocol: o1js_dist_node_lib_provable_bool.Bool; updateDelegator: o1js_dist_node_lib_provable_bool.Bool; updateFactory: o1js_dist_node_lib_provable_bool.Bool; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { deployPool: o1js_dist_node_lib_provable_bool.Bool; uppdatePool: o1js_dist_node_lib_provable_bool.Bool; updateSigner: o1js_dist_node_lib_provable_bool.Bool; updateProtocol: o1js_dist_node_lib_provable_bool.Bool; updateDelegator: o1js_dist_node_lib_provable_bool.Bool; updateFactory: o1js_dist_node_lib_provable_bool.Bool; }; } & { fromValue: (value: { deployPool: boolean | o1js_dist_node_lib_provable_bool.Bool; uppdatePool: boolean | o1js_dist_node_lib_provable_bool.Bool; updateSigner: boolean | o1js_dist_node_lib_provable_bool.Bool; updateProtocol: boolean | o1js_dist_node_lib_provable_bool.Bool; updateDelegator: boolean | o1js_dist_node_lib_provable_bool.Bool; updateFactory: boolean | o1js_dist_node_lib_provable_bool.Bool; }) => { deployPool: o1js_dist_node_lib_provable_bool.Bool; uppdatePool: o1js_dist_node_lib_provable_bool.Bool; updateSigner: o1js_dist_node_lib_provable_bool.Bool; updateProtocol: o1js_dist_node_lib_provable_bool.Bool; updateDelegator: o1js_dist_node_lib_provable_bool.Bool; updateFactory: o1js_dist_node_lib_provable_bool.Bool; }; toInput: (x: { deployPool: o1js_dist_node_lib_provable_bool.Bool; uppdatePool: o1js_dist_node_lib_provable_bool.Bool; updateSigner: o1js_dist_node_lib_provable_bool.Bool; updateProtocol: o1js_dist_node_lib_provable_bool.Bool; updateDelegator: o1js_dist_node_lib_provable_bool.Bool; updateFactory: o1js_dist_node_lib_provable_bool.Bool; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { deployPool: o1js_dist_node_lib_provable_bool.Bool; uppdatePool: o1js_dist_node_lib_provable_bool.Bool; updateSigner: o1js_dist_node_lib_provable_bool.Bool; updateProtocol: o1js_dist_node_lib_provable_bool.Bool; updateDelegator: o1js_dist_node_lib_provable_bool.Bool; updateFactory: o1js_dist_node_lib_provable_bool.Bool; }) => { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; fromJSON: (x: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }) => { deployPool: o1js_dist_node_lib_provable_bool.Bool; uppdatePool: o1js_dist_node_lib_provable_bool.Bool; updateSigner: o1js_dist_node_lib_provable_bool.Bool; updateProtocol: o1js_dist_node_lib_provable_bool.Bool; updateDelegator: o1js_dist_node_lib_provable_bool.Bool; updateFactory: o1js_dist_node_lib_provable_bool.Bool; }; empty: () => { deployPool: o1js_dist_node_lib_provable_bool.Bool; uppdatePool: o1js_dist_node_lib_provable_bool.Bool; updateSigner: o1js_dist_node_lib_provable_bool.Bool; updateProtocol: o1js_dist_node_lib_provable_bool.Bool; updateDelegator: o1js_dist_node_lib_provable_bool.Bool; updateFactory: o1js_dist_node_lib_provable_bool.Bool; }; }; /** * Signature right to update pool information */ declare class SignatureRight extends SignatureRight_base { constructor(deployPool: Bool, uppdatePool: Bool, updateSigner: Bool, updateProtocol: Bool, updateDelegator: Bool, updateFactory: Bool); toFields(): Field[]; static canUpdatePool(): SignatureRight; static canUpdateDelegator(): SignatureRight; static canUpdateProtocol(): SignatureRight; static canUpdateSigner(): SignatureRight; static canUpdateFactory(): SignatureRight; static canDeployPool(): SignatureRight; /** * Check if the user right match the necessary right * @param right user right */ hasRight(right: SignatureRight): o1js_dist_node_lib_provable_bool.Bool; /** * hash store in the signer merkle map */ hash(): Field; } declare const UpdateFactoryInfo_base: (new (value: { newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; } & { fromValue: (value: { newVkHash: string | number | bigint | o1js_dist_node_lib_provable_field.Field; deadlineSlot: number | bigint | UInt32; }) => { newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; toInput: (x: { newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { newVkHash: string; deadlineSlot: string; }; fromJSON: (x: { newVkHash: string; deadlineSlot: string; }) => { newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; empty: () => { newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; }; /** * Information needed to update the factory verification key */ declare class UpdateFactoryInfo extends UpdateFactoryInfo_base { constructor(value: { newVkHash: Field; deadlineSlot: UInt32; }); /** * Data use to create the signature * @returns array of field of all parameters */ toFields(): Field[]; hash(): Field; } declare const UpgradeInfo_base: (new (value: { contractAddress: PublicKey; tokenId: o1js_dist_node_lib_provable_field.Field; newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { contractAddress: PublicKey; tokenId: o1js_dist_node_lib_provable_field.Field; newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { contractAddress: PublicKey; tokenId: o1js_dist_node_lib_provable_field.Field; newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; } & { fromValue: (value: { contractAddress: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; tokenId: string | number | bigint | o1js_dist_node_lib_provable_field.Field; newVkHash: string | number | bigint | o1js_dist_node_lib_provable_field.Field; deadlineSlot: number | bigint | UInt32; }) => { contractAddress: PublicKey; tokenId: o1js_dist_node_lib_provable_field.Field; newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; toInput: (x: { contractAddress: PublicKey; tokenId: o1js_dist_node_lib_provable_field.Field; newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { contractAddress: PublicKey; tokenId: o1js_dist_node_lib_provable_field.Field; newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { contractAddress: string; tokenId: string; newVkHash: string; deadlineSlot: string; }; fromJSON: (x: { contractAddress: string; tokenId: string; newVkHash: string; deadlineSlot: string; }) => { contractAddress: PublicKey; tokenId: o1js_dist_node_lib_provable_field.Field; newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; empty: () => { contractAddress: PublicKey; tokenId: o1js_dist_node_lib_provable_field.Field; newVkHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; }; /** * Information needed to update the pool verification key */ declare class UpgradeInfo extends UpgradeInfo_base { constructor(value: { contractAddress: PublicKey; tokenId: Field; newVkHash: Field; deadlineSlot: UInt32; }); /** * Data use to create the signature * @returns array of field of all parameters */ toFields(): Field[]; hash(): Field; } declare const UpdateAccountInfo_base: (new (value: { oldUser: PublicKey; newUser: PublicKey; deadlineSlot: UInt32; }) => { oldUser: PublicKey; newUser: PublicKey; deadlineSlot: UInt32; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { oldUser: PublicKey; newUser: PublicKey; deadlineSlot: UInt32; }; } & { fromValue: (value: { oldUser: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; newUser: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; deadlineSlot: number | bigint | UInt32; }) => { oldUser: PublicKey; newUser: PublicKey; deadlineSlot: UInt32; }; toInput: (x: { oldUser: PublicKey; newUser: PublicKey; deadlineSlot: UInt32; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { oldUser: PublicKey; newUser: PublicKey; deadlineSlot: UInt32; }) => { oldUser: string; newUser: string; deadlineSlot: string; }; fromJSON: (x: { oldUser: string; newUser: string; deadlineSlot: string; }) => { oldUser: PublicKey; newUser: PublicKey; deadlineSlot: UInt32; }; empty: () => { oldUser: PublicKey; newUser: PublicKey; deadlineSlot: UInt32; }; }; /** * Information needed to update the delegator/protocol */ declare class UpdateAccountInfo extends UpdateAccountInfo_base { constructor(value: { oldUser: PublicKey; newUser: PublicKey; deadlineSlot: UInt32; }); /** * Data use to create the signature * @returns array of field of all parameters */ toFields(): Field[]; hash(): Field; } declare const UpdateSignerData_base: (new (value: { oldRoot: o1js_dist_node_lib_provable_field.Field; newRoot: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { oldRoot: o1js_dist_node_lib_provable_field.Field; newRoot: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { oldRoot: o1js_dist_node_lib_provable_field.Field; newRoot: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; } & { fromValue: (value: { oldRoot: string | number | bigint | o1js_dist_node_lib_provable_field.Field; newRoot: string | number | bigint | o1js_dist_node_lib_provable_field.Field; deadlineSlot: number | bigint | UInt32; }) => { oldRoot: o1js_dist_node_lib_provable_field.Field; newRoot: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; toInput: (x: { oldRoot: o1js_dist_node_lib_provable_field.Field; newRoot: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { oldRoot: o1js_dist_node_lib_provable_field.Field; newRoot: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { oldRoot: string; newRoot: string; deadlineSlot: string; }; fromJSON: (x: { oldRoot: string; newRoot: string; deadlineSlot: string; }) => { oldRoot: o1js_dist_node_lib_provable_field.Field; newRoot: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; empty: () => { oldRoot: o1js_dist_node_lib_provable_field.Field; newRoot: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; }; /** * Information needed to update the approved signer */ declare class UpdateSignerData extends UpdateSignerData_base { constructor(value: { oldRoot: Field; newRoot: Field; deadlineSlot: UInt32; }); /** * Data use to create the signature * @returns array of field of all parameters */ toFields(): Field[]; hash(): Field; } declare const MultisigInfo_base: (new (value: { approvedUpgrader: o1js_dist_node_lib_provable_field.Field; messageHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { approvedUpgrader: o1js_dist_node_lib_provable_field.Field; messageHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { approvedUpgrader: o1js_dist_node_lib_provable_field.Field; messageHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; } & { fromValue: (value: { approvedUpgrader: string | number | bigint | o1js_dist_node_lib_provable_field.Field; messageHash: string | number | bigint | o1js_dist_node_lib_provable_field.Field; deadlineSlot: number | bigint | UInt32; }) => { approvedUpgrader: o1js_dist_node_lib_provable_field.Field; messageHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; toInput: (x: { approvedUpgrader: o1js_dist_node_lib_provable_field.Field; messageHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { approvedUpgrader: o1js_dist_node_lib_provable_field.Field; messageHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }) => { approvedUpgrader: string; messageHash: string; deadlineSlot: string; }; fromJSON: (x: { approvedUpgrader: string; messageHash: string; deadlineSlot: string; }) => { approvedUpgrader: o1js_dist_node_lib_provable_field.Field; messageHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; empty: () => { approvedUpgrader: o1js_dist_node_lib_provable_field.Field; messageHash: o1js_dist_node_lib_provable_field.Field; deadlineSlot: UInt32; }; }; declare class MultisigInfo extends MultisigInfo_base { constructor(value: { approvedUpgrader: Field; messageHash: Field; deadlineSlot: UInt32; }); /** * Data use to create the signature * @returns array of field of all parameters */ toFields(): Field[]; } declare const SignatureInfo_base: (new (value: { user: PublicKey; witness: MerkleMapWitness; signature: Signature; right: SignatureRight; }) => { user: PublicKey; witness: MerkleMapWitness; signature: Signature; right: SignatureRight; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { user: PublicKey; witness: MerkleMapWitness; signature: Signature; right: SignatureRight; }; } & { fromValue: (value: { user: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; witness: any; signature: Signature | { r: Field | bigint; s: o1js.Scalar | bigint; }; right: SignatureRight | { deployPool: boolean | o1js_dist_node_lib_provable_bool.Bool; uppdatePool: boolean | o1js_dist_node_lib_provable_bool.Bool; updateSigner: boolean | o1js_dist_node_lib_provable_bool.Bool; updateProtocol: boolean | o1js_dist_node_lib_provable_bool.Bool; updateDelegator: boolean | o1js_dist_node_lib_provable_bool.Bool; updateFactory: boolean | o1js_dist_node_lib_provable_bool.Bool; }; }) => { user: PublicKey; witness: MerkleMapWitness; signature: Signature; right: SignatureRight; }; toInput: (x: { user: PublicKey; witness: MerkleMapWitness; signature: Signature; right: SignatureRight; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { user: PublicKey; witness: MerkleMapWitness; signature: Signature; right: SignatureRight; }) => { user: string; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }; fromJSON: (x: { user: string; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }) => { user: PublicKey; witness: MerkleMapWitness; signature: Signature; right: SignatureRight; }; empty: () => { user: PublicKey; witness: MerkleMapWitness; signature: Signature; right: SignatureRight; }; }; /** * Information needed to verify signature in the proof */ declare class SignatureInfo extends SignatureInfo_base { constructor(value: { user: PublicKey; witness: MerkleMapWitness; signature: Signature; right: SignatureRight; }); /** * Check if the signature match the current user and data subnit * @param merkle list of approved signer * @param data data use for the signature * @returns true if the signature is valid */ validate(merkle: Field, data: Field[]): Bool; } declare const Multisig_base: (new (value: { info: MultisigInfo; signatures: SignatureInfo[]; }) => { info: MultisigInfo; signatures: SignatureInfo[]; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { info: MultisigInfo; signatures: SignatureInfo[]; }; } & { fromValue: (value: { info: MultisigInfo | { approvedUpgrader: string | number | bigint | o1js_dist_node_lib_provable_field.Field; messageHash: string | number | bigint | o1js_dist_node_lib_provable_field.Field; deadlineSlot: number | bigint | UInt32; }; signatures: SignatureInfo[] | { user: { x: bigint; isOdd: boolean; }; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }[]; }) => { info: MultisigInfo; signatures: SignatureInfo[]; }; toInput: (x: { info: MultisigInfo; signatures: SignatureInfo[]; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { info: MultisigInfo; signatures: SignatureInfo[]; }) => { info: { approvedUpgrader: string; messageHash: string; deadlineSlot: string; }; signatures: { user: string; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }[]; }; fromJSON: (x: { info: { approvedUpgrader: string; messageHash: string; deadlineSlot: string; }; signatures: { user: string; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }[]; }) => { info: MultisigInfo; signatures: SignatureInfo[]; }; empty: () => { info: MultisigInfo; signatures: SignatureInfo[]; }; }; /** * Information needed to verify the signatures is correct */ declare class Multisig extends Multisig_base { constructor(value: { info: MultisigInfo; signatures: SignatureInfo[]; }); /** * Check if the signature match the current user and data subbit * @param data needed to verify the signature */ verifyUpdateFactory(updateInfo: UpdateFactoryInfo): void; /** * Check if the signature match the current user and data subbit * @param data needed to verify the signature */ verifyUpdatePool(upgradeInfo: UpgradeInfo): void; /** * Check if the signature match the current user and data subbit * @param data needed to verify the signature */ verifyUpdateDelegator(updateInfo: UpdateAccountInfo): void; /** * Check if the signature match the current user and data subbit * @param data needed to verify the signature */ verifyUpdateProtocol(updateInfo: UpdateAccountInfo): void; } declare const MultisigSigner_base: (new (value: { info: MultisigInfo; signatures: SignatureInfo[]; newSignatures: SignatureInfo[]; }) => { info: MultisigInfo; signatures: SignatureInfo[]; newSignatures: SignatureInfo[]; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { info: MultisigInfo; signatures: SignatureInfo[]; newSignatures: SignatureInfo[]; }; } & { fromValue: (value: { info: MultisigInfo | { approvedUpgrader: string | number | bigint | o1js_dist_node_lib_provable_field.Field; messageHash: string | number | bigint | o1js_dist_node_lib_provable_field.Field; deadlineSlot: number | bigint | UInt32; }; signatures: SignatureInfo[] | { user: { x: bigint; isOdd: boolean; }; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }[]; newSignatures: SignatureInfo[] | { user: { x: bigint; isOdd: boolean; }; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }[]; }) => { info: MultisigInfo; signatures: SignatureInfo[]; newSignatures: SignatureInfo[]; }; toInput: (x: { info: MultisigInfo; signatures: SignatureInfo[]; newSignatures: SignatureInfo[]; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { info: MultisigInfo; signatures: SignatureInfo[]; newSignatures: SignatureInfo[]; }) => { info: { approvedUpgrader: string; messageHash: string; deadlineSlot: string; }; signatures: { user: string; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }[]; newSignatures: { user: string; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }[]; }; fromJSON: (x: { info: { approvedUpgrader: string; messageHash: string; deadlineSlot: string; }; signatures: { user: string; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }[]; newSignatures: { user: string; witness: any; signature: any; right: { deployPool: boolean; uppdatePool: boolean; updateSigner: boolean; updateProtocol: boolean; updateDelegator: boolean; updateFactory: boolean; }; }[]; }) => { info: MultisigInfo; signatures: SignatureInfo[]; newSignatures: SignatureInfo[]; }; empty: () => { info: MultisigInfo; signatures: SignatureInfo[]; newSignatures: SignatureInfo[]; }; }; /** * Information needed to verify the multisig is correct to update the signer list */ declare class MultisigSigner extends MultisigSigner_base { constructor(value: { info: MultisigInfo; signatures: SignatureInfo[]; newSignatures: SignatureInfo[]; }); /** * Check if the signature match the current user and data subbit * @param data needed to verify the signature */ verifyUpdateSigner(upgradeInfo: UpdateSignerData): void; } /** * Check if the 3 signatures are valid */ declare function verifySignature(signatures: SignatureInfo[], deadlineSlot: UInt32, info: MultisigInfo, root: Field, data: Field[], right: SignatureRight): void; /** * Data needed by pool and pool token */ interface IPool { token0: State; token1: State; poolFactory: State; } declare const SwapEvent_base: (new (value: { sender: PublicKey; amountIn: Types.UInt64; amountOut: Types.UInt64; }) => { sender: PublicKey; amountIn: Types.UInt64; amountOut: Types.UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { sender: PublicKey; amountIn: Types.UInt64; amountOut: Types.UInt64; }; } & { fromValue: (value: { sender: PublicKey | { x: Types.Field | bigint; isOdd: Bool | boolean; }; amountIn: number | bigint | Types.UInt64; amountOut: number | bigint | Types.UInt64; }) => { sender: PublicKey; amountIn: Types.UInt64; amountOut: Types.UInt64; }; toInput: (x: { sender: PublicKey; amountIn: Types.UInt64; amountOut: Types.UInt64; }) => { fields?: Types.Field[] | undefined; packed?: [Types.Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; amountIn: Types.UInt64; amountOut: Types.UInt64; }) => { sender: string; amountIn: string; amountOut: string; }; fromJSON: (x: { sender: string; amountIn: string; amountOut: string; }) => { sender: PublicKey; amountIn: Types.UInt64; amountOut: Types.UInt64; }; empty: () => { sender: PublicKey; amountIn: Types.UInt64; amountOut: Types.UInt64; }; }; /** * Event emitted when a swap is validated */ declare class SwapEvent extends SwapEvent_base { constructor(value: { sender: PublicKey; amountIn: UInt64; amountOut: UInt64; }); } declare const ReceiveMinaEvent_base: (new (value: { sender: PublicKey; amountMinaIn: Types.UInt64; }) => { sender: PublicKey; amountMinaIn: Types.UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { sender: PublicKey; amountMinaIn: Types.UInt64; }; } & { fromValue: (value: { sender: PublicKey | { x: Types.Field | bigint; isOdd: Bool | boolean; }; amountMinaIn: number | bigint | Types.UInt64; }) => { sender: PublicKey; amountMinaIn: Types.UInt64; }; toInput: (x: { sender: PublicKey; amountMinaIn: Types.UInt64; }) => { fields?: Types.Field[] | undefined; packed?: [Types.Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; amountMinaIn: Types.UInt64; }) => { sender: string; amountMinaIn: string; }; fromJSON: (x: { sender: string; amountMinaIn: string; }) => { sender: PublicKey; amountMinaIn: Types.UInt64; }; empty: () => { sender: PublicKey; amountMinaIn: Types.UInt64; }; }; /** * Event emitted when the contract receive mina in case of swap */ declare class ReceiveMinaEvent extends ReceiveMinaEvent_base { constructor(value: { sender: PublicKey; amountMinaIn: UInt64; }); } declare const AddLiquidityEvent_base: (new (value: { sender: PublicKey; amountToken0In: Types.UInt64; amountToken1In: Types.UInt64; amountLiquidityOut: Types.UInt64; }) => { sender: PublicKey; amountToken0In: Types.UInt64; amountToken1In: Types.UInt64; amountLiquidityOut: Types.UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { sender: PublicKey; amountToken0In: Types.UInt64; amountToken1In: Types.UInt64; amountLiquidityOut: Types.UInt64; }; } & { fromValue: (value: { sender: PublicKey | { x: Types.Field | bigint; isOdd: Bool | boolean; }; amountToken0In: number | bigint | Types.UInt64; amountToken1In: number | bigint | Types.UInt64; amountLiquidityOut: number | bigint | Types.UInt64; }) => { sender: PublicKey; amountToken0In: Types.UInt64; amountToken1In: Types.UInt64; amountLiquidityOut: Types.UInt64; }; toInput: (x: { sender: PublicKey; amountToken0In: Types.UInt64; amountToken1In: Types.UInt64; amountLiquidityOut: Types.UInt64; }) => { fields?: Types.Field[] | undefined; packed?: [Types.Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; amountToken0In: Types.UInt64; amountToken1In: Types.UInt64; amountLiquidityOut: Types.UInt64; }) => { sender: string; amountToken0In: string; amountToken1In: string; amountLiquidityOut: string; }; fromJSON: (x: { sender: string; amountToken0In: string; amountToken1In: string; amountLiquidityOut: string; }) => { sender: PublicKey; amountToken0In: Types.UInt64; amountToken1In: Types.UInt64; amountLiquidityOut: Types.UInt64; }; empty: () => { sender: PublicKey; amountToken0In: Types.UInt64; amountToken1In: Types.UInt64; amountLiquidityOut: Types.UInt64; }; }; /** * Event emitted when an user add liquidity */ declare class AddLiquidityEvent extends AddLiquidityEvent_base { constructor(value: { sender: PublicKey; amountToken0In: UInt64; amountToken1In: UInt64; amountLiquidityOut: UInt64; }); } declare const BalanceEvent_base: (new (value: { address: PublicKey; amount: Int64; }) => { address: PublicKey; amount: Int64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { address: PublicKey; amount: Int64; }; } & { fromValue: (value: { address: PublicKey | { x: Types.Field | bigint; isOdd: Bool | boolean; }; amount: any; }) => { address: PublicKey; amount: Int64; }; toInput: (x: { address: PublicKey; amount: Int64; }) => { fields?: Types.Field[] | undefined; packed?: [Types.Field, number][] | undefined; }; toJSON: (x: { address: PublicKey; amount: Int64; }) => { address: string; amount: any; }; fromJSON: (x: { address: string; amount: any; }) => { address: PublicKey; amount: Int64; }; empty: () => { address: PublicKey; amount: Int64; }; }; /** * Event emitted when liquidity balance changed */ declare class BalanceEvent extends BalanceEvent_base { constructor(value: { address: PublicKey; amount: Int64; }); } declare const BurnLiqudityEvent_base: (new (value: { sender: PublicKey; amountMinaOut: Types.UInt64; amountLiquidity: Types.UInt64; }) => { sender: PublicKey; amountMinaOut: Types.UInt64; amountLiquidity: Types.UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { sender: PublicKey; amountMinaOut: Types.UInt64; amountLiquidity: Types.UInt64; }; } & { fromValue: (value: { sender: PublicKey | { x: Types.Field | bigint; isOdd: Bool | boolean; }; amountMinaOut: number | bigint | Types.UInt64; amountLiquidity: number | bigint | Types.UInt64; }) => { sender: PublicKey; amountMinaOut: Types.UInt64; amountLiquidity: Types.UInt64; }; toInput: (x: { sender: PublicKey; amountMinaOut: Types.UInt64; amountLiquidity: Types.UInt64; }) => { fields?: Types.Field[] | undefined; packed?: [Types.Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; amountMinaOut: Types.UInt64; amountLiquidity: Types.UInt64; }) => { sender: string; amountMinaOut: string; amountLiquidity: string; }; fromJSON: (x: { sender: string; amountMinaOut: string; amountLiquidity: string; }) => { sender: PublicKey; amountMinaOut: Types.UInt64; amountLiquidity: Types.UInt64; }; empty: () => { sender: PublicKey; amountMinaOut: Types.UInt64; amountLiquidity: Types.UInt64; }; }; /** * Event emitted when liquidity was burned */ declare class BurnLiqudityEvent extends BurnLiqudityEvent_base { constructor(value: { sender: PublicKey; amountMinaOut: UInt64; amountLiquidity: UInt64; }); } /** * Main Pool contract for Lumina dex */ declare class Pool extends TokenContract implements IPool { /** * Address of first token in the pool (ordered by address) * PublicKey.empty() in case of native mina */ token0: State; /** * Address of second token in the pool * Can't be empty */ token1: State; /** * Pool factory contract address */ poolFactory: State; /** * Protocol address stored in the pool to not exceed account update limit on swap */ protocol: State; /** * Frontend max fee, 0.10% */ static maxFee: UInt64; /** * Minimun liquidity in the pool, 1000 */ static minimumLiquidity: UInt64; /** * List of pool events */ events: { swap: typeof SwapEvent; addLiquidity: typeof AddLiquidityEvent; balanceChange: typeof BalanceEvent; updateDelegator: typeof UpdateUserEvent; updateProtocol: typeof UpdateUserEvent; upgrade: typeof UpdateVerificationKeyEvent; burnLiquidity: typeof BurnLiqudityEvent; receiveMina: typeof ReceiveMinaEvent; }; /** * This method can't be called directly, deploy new pool from pool factory instead */ deploy(): Promise; /** * Upgrade to a new version, necessary due to o1js breaking verification key compatibility between versions * @param multisig multisig data * @param vk new verification key */ updateVerificationKey(multisig: Multisig, vk: VerificationKey): Promise; /** * Update the delegator account address from pool factory */ setDelegator(): Promise; /** * Update the protocol account address from pool factory */ setProtocol(): Promise; /** Approve `AccountUpdate`s that have been created outside of the token contract. * * @argument {AccountUpdateForest} updates - The `AccountUpdate`s to approve. Note that the forest size is limited by the base token contract, @see TokenContract.MAX_ACCOUNT_UPDATES The current limit is 9. */ approveBase(updates: AccountUpdateForest): Promise; private checkPermissionsUpdate; /** * Transfer liquidity from an account to another * @param from account from * @param to account to * @param amount amount to tranfer */ transfer(from: PublicKey, to: PublicKey, amount: UInt64): Promise; /** * Call it on the first time liquidity is supplied to the mina/token pool * @param amountMina mina to add to the pool * @param amountToken token to add to the pool * @returns liquity amount minted */ supplyFirstLiquidities(amountMina: UInt64, amountToken: UInt64): Promise; /** * Supply liquidity to the mina/token pool if it's not the first time * The reserves max and supply min permit concurrent call, use slippage mechanism to calculate it * @param amountMina mina to add to the pool * @param amountToken token to add to the pool * @param reserveMinaMax reserve max of mina in the pool * @param reserveTokenMax reserve max of token in the pool * @param supplyMin minimun liquidity in the pool * @returns liquity amount minted */ supplyLiquidity(amountMina: UInt64, amountToken: UInt64, reserveMinaMax: UInt64, reserveTokenMax: UInt64, supplyMin: UInt64): Promise; /** * Method to call on the first time liquidity is supplied to the token pool * @param amountToken0 amount of token 0 to add to the pool * @param amountToken1 amount of token 1 to add to the pool * @returns liquity amount minted */ supplyFirstLiquiditiesToken(amountToken0: UInt64, amountToken1: UInt64): Promise; /** * Supply liquidity to the token/token pool if it's not the first time * The reserves max and supply min permit concurrent call, use slippage mechanism to calculate it * @param amountToken0 amount of token 0 to add to the pool * @param amountToken1 amount of token 1 to add to the pool * @param reserveMinaMax reserve max of mina in the pool * @param reserveTokenMax reserve max of token in the pool * @param supplyMin minimun liquidity in the pool * @returns liquity amount minted */ supplyLiquidityToken(amountToken0: UInt64, amountToken1: UInt64, reserveToken0Max: UInt64, reserveToken1Max: UInt64, supplyMin: UInt64): Promise; /** * Swap token to mina * @param frontend address who collect the frontend fees * @param taxFeeFrontend fees applied by the frontend * @param amountTokenIn amount of token to swap * @param amountMinaOutMin minimum mina to received * @param balanceInMax minimum balance of token in the pool * @param balanceOutMin maximum balance of mina in the pool */ swapFromTokenToMina(frontend: PublicKey, taxFeeFrontend: UInt64, amountTokenIn: UInt64, amountMinaOutMin: UInt64, balanceInMax: UInt64, balanceOutMin: UInt64): Promise; /** * Don't call this method directly, use pool token holder or you will just lost mina * @param sender use in the previous method * @param amountMinaIn mina amount in * @param balanceInMax actual reserve max in */ swapFromMinaToToken(sender: PublicKey, protocol: PublicKey, amountMinaIn: UInt64, balanceInMax: UInt64): Promise; /** * Don't call this method directly, use withdrawLiquidity from PoolTokenHolder */ withdrawLiquidity(sender: PublicKey, liquidityAmount: UInt64, amountMinaMin: UInt64, reserveMinaMin: UInt64, supplyMax: UInt64): Promise; /** * Don't call this method directly, use withdrawLiquidityToken from PoolTokenHolder */ burnLiquidityToken(sender: PublicKey, liquidityAmount: UInt64, supplyMax: UInt64): Promise; private burnLiquidity; private supply; private sendTokenAccount; private getProtocolAddress; /** * Calculate amount out on swap, use by pool and pool token holder contracts * @param taxFeeFrontend fees applied by the frontend * @param amountTokenIn amount of tokenIn to swap * @param balanceInMax minimum balance of tokenIn in the pool * @param balanceOutMin maximum balance of tokenOut in the pool * @returns amount of token out */ static getAmountOut(taxFeeFrontend: UInt64, amountTokenIn: UInt64, balanceInMax: UInt64, balanceOutMin: UInt64): { feeLP: Types.UInt64; feeFrontend: Types.UInt64; feeProtocol: Types.UInt64; amountOut: Types.UInt64; }; } /** * Current verification key of pool contract */ declare const contractData = "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"; /** * Current hash of verification key of pool contract */ declare const contractHash: o1js_dist_node_lib_provable_field_js.Field; /** * Current verification key of pool token holder contract */ declare const contractHolderData = "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"; /** * Current hash of verification key of pool token holder contract */ declare const contractHolderHash: o1js_dist_node_lib_provable_field_js.Field; /** * Interface of current data needed to deploy the pool factory */ interface PoolDeployProps extends Exclude { symbol: string; src: string; protocol: PublicKey; delegator: PublicKey; approvedSigner: Field; signatures: SignatureInfo[]; multisigInfo: MultisigInfo; } declare const PoolCreationEvent_base: (new (value: { sender: PublicKey; signer: PublicKey; poolAddress: PublicKey; token0Address: PublicKey; token1Address: PublicKey; }) => { sender: PublicKey; signer: PublicKey; poolAddress: PublicKey; token0Address: PublicKey; token1Address: PublicKey; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { sender: PublicKey; signer: PublicKey; poolAddress: PublicKey; token0Address: PublicKey; token1Address: PublicKey; }; } & { fromValue: (value: { sender: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; signer: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; poolAddress: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; token0Address: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; token1Address: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; }) => { sender: PublicKey; signer: PublicKey; poolAddress: PublicKey; token0Address: PublicKey; token1Address: PublicKey; }; toInput: (x: { sender: PublicKey; signer: PublicKey; poolAddress: PublicKey; token0Address: PublicKey; token1Address: PublicKey; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; signer: PublicKey; poolAddress: PublicKey; token0Address: PublicKey; token1Address: PublicKey; }) => { sender: string; signer: string; poolAddress: string; token0Address: string; token1Address: string; }; fromJSON: (x: { sender: string; signer: string; poolAddress: string; token0Address: string; token1Address: string; }) => { sender: PublicKey; signer: PublicKey; poolAddress: PublicKey; token0Address: PublicKey; token1Address: PublicKey; }; empty: () => { sender: PublicKey; signer: PublicKey; poolAddress: PublicKey; token0Address: PublicKey; token1Address: PublicKey; }; }; /** * Event emitted when a new pool is created */ declare class PoolCreationEvent extends PoolCreationEvent_base { constructor(value: { sender: PublicKey; signer: PublicKey; poolAddress: PublicKey; token0Address: PublicKey; token1Address: PublicKey; }); } declare const UpdateUserEvent_base: (new (value: { newUser: PublicKey; }) => { newUser: PublicKey; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { newUser: PublicKey; }; } & { fromValue: (value: { newUser: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; }) => { newUser: PublicKey; }; toInput: (x: { newUser: PublicKey; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { newUser: PublicKey; }) => { newUser: string; }; fromJSON: (x: { newUser: string; }) => { newUser: PublicKey; }; empty: () => { newUser: PublicKey; }; }; /** * Event emitted when an address is updated */ declare class UpdateUserEvent extends UpdateUserEvent_base { constructor(newUser: PublicKey); } declare const UpdateVerificationKeyEvent_base: (new (value: { hash: o1js_dist_node_lib_provable_field_js.Field; }) => { hash: o1js_dist_node_lib_provable_field_js.Field; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { hash: o1js_dist_node_lib_provable_field_js.Field; }; } & { fromValue: (value: { hash: string | number | bigint | o1js_dist_node_lib_provable_field_js.Field; }) => { hash: o1js_dist_node_lib_provable_field_js.Field; }; toInput: (x: { hash: o1js_dist_node_lib_provable_field_js.Field; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { hash: o1js_dist_node_lib_provable_field_js.Field; }) => { hash: string; }; fromJSON: (x: { hash: string; }) => { hash: o1js_dist_node_lib_provable_field_js.Field; }; empty: () => { hash: o1js_dist_node_lib_provable_field_js.Field; }; }; /** * Event emitted when the verification key is updated */ declare class UpdateVerificationKeyEvent extends UpdateVerificationKeyEvent_base { constructor(hash: Field); } declare const UpdateSignerEvent_base: (new (value: { root: o1js_dist_node_lib_provable_field_js.Field; }) => { root: o1js_dist_node_lib_provable_field_js.Field; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { root: o1js_dist_node_lib_provable_field_js.Field; }; } & { fromValue: (value: { root: string | number | bigint | o1js_dist_node_lib_provable_field_js.Field; }) => { root: o1js_dist_node_lib_provable_field_js.Field; }; toInput: (x: { root: o1js_dist_node_lib_provable_field_js.Field; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { root: o1js_dist_node_lib_provable_field_js.Field; }) => { root: string; }; fromJSON: (x: { root: string; }) => { root: o1js_dist_node_lib_provable_field_js.Field; }; empty: () => { root: o1js_dist_node_lib_provable_field_js.Field; }; }; /** * Event emitted when the signer list is updated */ declare class UpdateSignerEvent extends UpdateSignerEvent_base { constructor(root: Field); } /** * Factory who create pools */ declare class PoolFactory extends TokenContract { /** * List of signer approved to deploy a new pool */ approvedSigner: State; /** * Account who collect protocol fees */ protocol: State; /** * Delegator account for mina pools */ delegator: State; /** * List of pool factory events */ events: { poolAdded: typeof PoolCreationEvent; upgrade: typeof UpdateVerificationKeyEvent; updateSigner: typeof UpdateSignerEvent; updateProtocol: typeof UpdateUserEvent; updateDelegator: typeof UpdateUserEvent; updateOwner: typeof UpdateUserEvent; }; /** * Method call when you deploy the pool factory contracts * @param args default data stored in the contracts */ deploy(args: PoolDeployProps): Promise; /** * Upgrade to a new version * @param multisig multisig data * @param vk new verification key */ updateVerificationKey(multisig: Multisig, vk: VerificationKey): Promise; /** * Update the list of approved signers * @param multisig multisig data * @param newRoot merkle root of the new list */ updateApprovedSigner(multisig: MultisigSigner, newRoot: Field): Promise; /** * Update the protocol account address * @param multisig multisig data * @param newUser address of the new protocol collectord */ setNewProtocol(multisig: Multisig, newUser: PublicKey): Promise; /** * Update the delgator address * @param multisig multisig data * @param newUser address of the new delegator */ setNewDelegator(multisig: Multisig, newUser: PublicKey): Promise; /** * Get protocol address * @returns address of the protocol */ getProtocol(): Promise; /** * Get delegator address * @returns address of the delegator */ getDelegator(): Promise; /** * Get approved signer * @returns root of approved signer */ getApprovedSigner(): Promise; /** * Method use by token allowance but it's not permissible to use it * @param forest account forest to update */ approveBase(forest: AccountUpdateForest): Promise; /** * Create a new mina/token pool * @param newAccount address of the new pool * @param token token 1 for the mina pool * @param signer who sign the argument * @param signature who proves you can deploy this pool (only approved signer can deploy a pool) * @param path merkle witness to check if signer is in the approved list * @param right right of the signer */ createPool(newAccount: PublicKey, token: PublicKey, signer: PublicKey, signature: Signature, path: MerkleMapWitness, right: SignatureRight): Promise; /** * Create a new token/token pool * @param newAccount address of the new pool * @param token 0 of the pool * @param token 1 of the pool * @param signer who sign the argument * @param signature who proves you can deploy this pool (only approved signer can deploy a pool) * @param path merkle witness to check if signer is in the approved list * @param right right of the signer */ createPoolToken(newAccount: PublicKey, token0: PublicKey, token1: PublicKey, signer: PublicKey, signature: Signature, path: MerkleMapWitness, right: SignatureRight): Promise; private createAccounts; private createState; private createPoolHolderAccount; } declare const WithdrawLiquidityEvent_base: (new (value: { sender: PublicKey; amountLiquidityIn: UInt64; amountToken0Out: UInt64; amountToken1Out: UInt64; }) => { sender: PublicKey; amountLiquidityIn: UInt64; amountToken0Out: UInt64; amountToken1Out: UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { sender: PublicKey; amountLiquidityIn: UInt64; amountToken0Out: UInt64; amountToken1Out: UInt64; }; } & { fromValue: (value: { sender: PublicKey | { x: o1js.Field | bigint; isOdd: Bool | boolean; }; amountLiquidityIn: number | bigint | UInt64; amountToken0Out: number | bigint | UInt64; amountToken1Out: number | bigint | UInt64; }) => { sender: PublicKey; amountLiquidityIn: UInt64; amountToken0Out: UInt64; amountToken1Out: UInt64; }; toInput: (x: { sender: PublicKey; amountLiquidityIn: UInt64; amountToken0Out: UInt64; amountToken1Out: UInt64; }) => { fields?: o1js.Field[] | undefined; packed?: [o1js.Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; amountLiquidityIn: UInt64; amountToken0Out: UInt64; amountToken1Out: UInt64; }) => { sender: string; amountLiquidityIn: string; amountToken0Out: string; amountToken1Out: string; }; fromJSON: (x: { sender: string; amountLiquidityIn: string; amountToken0Out: string; amountToken1Out: string; }) => { sender: PublicKey; amountLiquidityIn: UInt64; amountToken0Out: UInt64; amountToken1Out: UInt64; }; empty: () => { sender: PublicKey; amountLiquidityIn: UInt64; amountToken0Out: UInt64; amountToken1Out: UInt64; }; }; /** * Event emitted when an user withdraw liquidity */ declare class WithdrawLiquidityEvent extends WithdrawLiquidityEvent_base { constructor(value: { sender: PublicKey; amountLiquidityIn: UInt64; amountToken0Out: UInt64; amountToken1Out: UInt64; }); } declare const SubWithdrawLiquidityEvent_base: (new (value: { sender: PublicKey; amountLiquidityIn: UInt64; amountTokenOut: UInt64; }) => { sender: PublicKey; amountLiquidityIn: UInt64; amountTokenOut: UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { sender: PublicKey; amountLiquidityIn: UInt64; amountTokenOut: UInt64; }; } & { fromValue: (value: { sender: PublicKey | { x: o1js.Field | bigint; isOdd: Bool | boolean; }; amountLiquidityIn: number | bigint | UInt64; amountTokenOut: number | bigint | UInt64; }) => { sender: PublicKey; amountLiquidityIn: UInt64; amountTokenOut: UInt64; }; toInput: (x: { sender: PublicKey; amountLiquidityIn: UInt64; amountTokenOut: UInt64; }) => { fields?: o1js.Field[] | undefined; packed?: [o1js.Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; amountLiquidityIn: UInt64; amountTokenOut: UInt64; }) => { sender: string; amountLiquidityIn: string; amountTokenOut: string; }; fromJSON: (x: { sender: string; amountLiquidityIn: string; amountTokenOut: string; }) => { sender: PublicKey; amountLiquidityIn: UInt64; amountTokenOut: UInt64; }; empty: () => { sender: PublicKey; amountLiquidityIn: UInt64; amountTokenOut: UInt64; }; }; /** * Event emitted when liquidity was withdrawn on the second pool token holder contract */ declare class SubWithdrawLiquidityEvent extends SubWithdrawLiquidityEvent_base { constructor(value: { sender: PublicKey; amountLiquidityIn: UInt64; amountTokenOut: UInt64; }); } /** * Token holder contract, manage swap and liquidity remove functions */ declare class PoolTokenHolder extends SmartContract implements IPool { /** * Address of first token in the pool (ordered by address) * PublicKey.empty() in case of native mina */ token0: State; /** * Address of second token in the pool * Can't be empty */ token1: State; /** * Pool factory contract address */ poolFactory: State; /** * List of pool token holder events */ events: { withdrawLiquidity: typeof WithdrawLiquidityEvent; swap: typeof SwapEvent; upgrade: typeof UpdateVerificationKeyEvent; subWithdrawLiquidity: typeof SubWithdrawLiquidityEvent; }; /** * This method can't be called directly, deploy new pool token holder from pool factory */ deploy(): Promise; /** * Upgrade to a new version, necessary due to o1js breaking verification key compatibility between versions * @param multisig multisig data * @param vk new verification key */ updateVerificationKey(multisig: Multisig, vk: VerificationKey): Promise; /** * Swap from mina to token * @param frontend address who collect the frontend fees * @param taxFeeFrontend fees applied by the frontend * @param amountMinaIn amount of mina to swap * @param amountTokenOutMin minimum token to received * @param balanceInMax minimum balance of mina in the pool * @param balanceOutMin maximum balance of token in the pool */ swapFromMinaToToken(frontend: PublicKey, taxFeeFrontend: UInt64, amountMinaIn: UInt64, amountTokenOutMin: UInt64, balanceInMax: UInt64, balanceOutMin: UInt64): Promise; /** * Swap from token to another token * @param frontend address who collect the frontend fees * @param taxFeeFrontend fees applied by the frontend * @param amountTokenIn amount of tokenIn to swap * @param amountTokenOutMin minimum tokenOut to received * @param balanceInMax minimum balance of tokenIn in the pool * @param balanceOutMin maximum balance of tokenOut in the pool */ swapFromTokenToToken(frontend: PublicKey, taxFeeFrontend: UInt64, amountTokenIn: UInt64, amountTokenOutMin: UInt64, balanceInMax: UInt64, balanceOutMin: UInt64): Promise; /** * Withdraw liquidity from the mina/token pool * The reserves min and supply max permit concurrent call, use slippage mechanism to calculate it * @param liquidityAmount amount of liquidity to withdraw * @param amountMinaMin minimum amount of mina to receive * @param amountTokenMin minimum amount of token to receive * @param reserveMinaMin reserve min of mina in the pool * @param reserveTokenMin reserve min of token in the pool * @param supplyMax maximum liquidity in the pool */ withdrawLiquidity(liquidityAmount: UInt64, amountMinaMin: UInt64, amountTokenMin: UInt64, reserveMinaMin: UInt64, reserveTokenMin: UInt64, supplyMax: UInt64): Promise; /** * Withdraw liquidity from the token/token pool * The reserves min and supply max permit concurrent call, use slippage mechanism to calculate it * @param liquidityAmount amount of liquidity to withdraw * @param amountMinaMin minimum amount of mina to receive * @param amountTokenMin minimum amount of token to receive * @param reserveMinaMin reserve min of mina in the pool * @param reserveTokenMin reserve min of token in the pool * @param supplyMax maximum liquidity in the pool */ withdrawLiquidityToken(liquidityAmount: UInt64, amountToken0Min: UInt64, amountToken1Min: UInt64, reserveToken0Min: UInt64, reserveToken1Min: UInt64, supplyMax: UInt64): Promise; /** * Don't call this method directly, use withdrawLiquidityToken for token 0 */ subWithdrawLiquidity(sender: PublicKey, liquidityAmount: UInt64, amountToken1Min: UInt64, reserveToken1Min: UInt64, supplyMax: UInt64): Promise; private withdraw; private swap; } declare const FarmingInfo_base: (new (value: { startTimestamp: UInt64; endTimestamp: UInt64; }) => { startTimestamp: UInt64; endTimestamp: UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { startTimestamp: UInt64; endTimestamp: UInt64; }; } & { fromValue: (value: { startTimestamp: number | bigint | UInt64; endTimestamp: number | bigint | UInt64; }) => { startTimestamp: UInt64; endTimestamp: UInt64; }; toInput: (x: { startTimestamp: UInt64; endTimestamp: UInt64; }) => { fields?: o1js.Field[] | undefined; packed?: [o1js.Field, number][] | undefined; }; toJSON: (x: { startTimestamp: UInt64; endTimestamp: UInt64; }) => { startTimestamp: string; endTimestamp: string; }; fromJSON: (x: { startTimestamp: string; endTimestamp: string; }) => { startTimestamp: UInt64; endTimestamp: UInt64; }; empty: () => { startTimestamp: UInt64; endTimestamp: UInt64; }; }; declare class FarmingInfo extends FarmingInfo_base { constructor(value: { startTimestamp: UInt64; endTimestamp: UInt64; }); } declare const FarmingEvent_base: (new (value: { sender: PublicKey; amount: UInt64; }) => { sender: PublicKey; amount: UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { sender: PublicKey; amount: UInt64; }; } & { fromValue: (value: { sender: PublicKey | { x: o1js.Field | bigint; isOdd: Bool | boolean; }; amount: number | bigint | UInt64; }) => { sender: PublicKey; amount: UInt64; }; toInput: (x: { sender: PublicKey; amount: UInt64; }) => { fields?: o1js.Field[] | undefined; packed?: [o1js.Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; amount: UInt64; }) => { sender: string; amount: string; }; fromJSON: (x: { sender: string; amount: string; }) => { sender: PublicKey; amount: UInt64; }; empty: () => { sender: PublicKey; amount: UInt64; }; }; declare class FarmingEvent extends FarmingEvent_base { constructor(value: { sender: PublicKey; amount: UInt64; }); } declare const BurnEvent_base: (new (value: { sender: PublicKey; amount: UInt64; }) => { sender: PublicKey; amount: UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { sender: PublicKey; amount: UInt64; }; } & { fromValue: (value: { sender: PublicKey | { x: o1js.Field | bigint; isOdd: Bool | boolean; }; amount: number | bigint | UInt64; }) => { sender: PublicKey; amount: UInt64; }; toInput: (x: { sender: PublicKey; amount: UInt64; }) => { fields?: o1js.Field[] | undefined; packed?: [o1js.Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; amount: UInt64; }) => { sender: string; amount: string; }; fromJSON: (x: { sender: string; amount: string; }) => { sender: PublicKey; amount: UInt64; }; empty: () => { sender: PublicKey; amount: UInt64; }; }; declare class BurnEvent extends BurnEvent_base { constructor(value: { sender: PublicKey; amount: UInt64; }); } declare const UpdateInitEvent_base: (new (value: { owner: PublicKey; }) => { owner: PublicKey; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field_js.Field[]) => { owner: PublicKey; }; } & { fromValue: (value: { owner: PublicKey | { x: o1js.Field | bigint; isOdd: Bool | boolean; }; }) => { owner: PublicKey; }; toInput: (x: { owner: PublicKey; }) => { fields?: o1js.Field[] | undefined; packed?: [o1js.Field, number][] | undefined; }; toJSON: (x: { owner: PublicKey; }) => { owner: string; }; fromJSON: (x: { owner: string; }) => { owner: PublicKey; }; empty: () => { owner: PublicKey; }; }; declare class UpdateInitEvent extends UpdateInitEvent_base { constructor(value: { owner: PublicKey; }); } interface FarmingDeployProps$1 extends Exclude { pool: PublicKey; owner: PublicKey; startSlot: UInt64; endSlot: UInt64; } /** * Farm contract */ declare class Farm extends TokenContract { pool: State; owner: State; startTimestamp: State; endTimestamp: State; timeUnlock: State; events: { upgrade: typeof UpdateVerificationKeyEvent; upgradeInited: typeof UpdateInitEvent; deposit: typeof FarmingEvent; burn: typeof BurnEvent; }; deploy(args: FarmingDeployProps$1): Promise; /** * Transfer is locked only depositor can withdraw his token */ approveBase(updates: AccountUpdateForest): Promise; /** * Init Upgrade to a new version * @param vk new verification key */ initUpdate(startTime: UInt64): Promise; /** * Upgrade to a new version * @param vk new verification key */ updateVerificationKey(vk: VerificationKey): Promise; deposit(amount: UInt64): Promise; /** * Don't call this method directly */ burnLiquidity(sender: PublicKey, amount: UInt64): Promise; } interface FarmRewardDeployProps extends Exclude { merkleRoot: Field; token: PublicKey; owner: PublicKey; } declare const MintEvent_base: (new (value: { sender: PublicKey; }) => { sender: PublicKey; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { sender: PublicKey; }; } & { fromValue: (value: { sender: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; }) => { sender: PublicKey; }; toInput: (x: { sender: PublicKey; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { sender: PublicKey; }) => { sender: string; }; fromJSON: (x: { sender: string; }) => { sender: PublicKey; }; empty: () => { sender: PublicKey; }; }; declare class MintEvent extends MintEvent_base { constructor(value: { sender: PublicKey; }); } declare const ClaimEvent_base: (new (value: { user: PublicKey; amount: UInt64; }) => { user: PublicKey; amount: UInt64; }) & { _isStruct: true; } & Omit, "fromFields"> & { fromFields: (fields: o1js_dist_node_lib_provable_field.Field[]) => { user: PublicKey; amount: UInt64; }; } & { fromValue: (value: { user: PublicKey | { x: Field | bigint; isOdd: Bool | boolean; }; amount: number | bigint | UInt64; }) => { user: PublicKey; amount: UInt64; }; toInput: (x: { user: PublicKey; amount: UInt64; }) => { fields?: Field[] | undefined; packed?: [Field, number][] | undefined; }; toJSON: (x: { user: PublicKey; amount: UInt64; }) => { user: string; amount: string; }; fromJSON: (x: { user: string; amount: string; }) => { user: PublicKey; amount: UInt64; }; empty: () => { user: PublicKey; amount: UInt64; }; }; declare class ClaimEvent extends ClaimEvent_base { constructor(value: { user: PublicKey; amount: UInt64; }); } /** * support 2^32 different claimer (easily adjustable) */ declare const claimerNumber = 32; declare const FarmMerkleWitness_base: typeof o1js_dist_node_lib_provable_merkle_tree.BaseMerkleWitness; declare class FarmMerkleWitness extends FarmMerkleWitness_base { } /** * we can't upgrade the contract before 1 day */ declare const minTimeUnlockFarmReward: UInt64; /** * Farm reward contract */ declare class FarmReward extends TokenContract { owner: State; token: State; merkleRoot: State; timeUnlock: State; events: { upgrade: typeof UpdateVerificationKeyEvent; upgradeInited: typeof UpdateInitEvent; claim: typeof ClaimEvent; mint: typeof MintEvent; }; deploy(args: FarmRewardDeployProps): Promise; /** Approve `AccountUpdate`s that have been created outside of the token contract. * * @argument {AccountUpdateForest} updates - The `AccountUpdate`s to approve. Note that the forest size is limited by the base token contract, @see TokenContract.MAX_ACCOUNT_UPDATES The current limit is 9. */ approveBase(updates: AccountUpdateForest): Promise; /** * Init Upgrade to a new version * @param vk new verification key */ initUpdate(startTime: UInt64): Promise; /** * Upgrade to a new version * @param vk new verification key */ updateVerificationKey(vk: VerificationKey): Promise; claimReward(amount: UInt64, path: FarmMerkleWitness): Promise; /** * Don't call this method directly */ mint(sender: PublicKey): Promise; } /** * Farm reward contract in case of the reward in fungible token */ declare class FarmRewardTokenHolder extends FarmReward { deploy(args: FarmRewardDeployProps): Promise; claimReward(amount: UInt64, path: FarmMerkleWitness): Promise; } interface FarmingDeployProps extends Exclude { owner: PublicKey; } /** * Farm contract */ declare class FarmTokenHolder extends SmartContract { owner: State; timeUnlock: State; events: { upgrade: typeof UpdateVerificationKeyEvent; upgradeInited: typeof UpdateInitEvent; withdraw: typeof FarmingEvent; }; deploy(args: FarmingDeployProps): Promise; /** * Transfer is locked only depositor can withdraw his token */ approveBase(updates: AccountUpdateForest): Promise; /** * Init Upgrade to a new version * @param vk new verification key */ initUpdate(startTime: UInt64): Promise; /** * Upgrade to a new version * @param vk new verification key */ updateVerificationKey(vk: VerificationKey): Promise; withdraw(amount: UInt64): Promise; } interface FaucetDeployProps extends Exclude { amount: UInt64; token: PublicKey; } declare class Faucet extends TokenContract { amount: State; token: State; approveBase(forest: AccountUpdateForest): Promise; deploy(args: FaucetDeployProps): Promise; claim(): Promise; } declare function getAmountOut(amountIn: number, balanceIn: number, balanceOut: number, percent: number): { amountIn: number; amountOut: number; balanceOutMin: number; balanceInMax: number; }; declare function getAmountOutUint(amountIn: UInt64, balanceIn: UInt64, balanceOut: UInt64, percent: UInt64): { amountIn: UInt64; amountOut: UInt64; balanceOutMin: UInt64; balanceInMax: UInt64; }; declare function getAmountLiquidityOut(amountAIn: number, balanceA: number, balanceB: number, supply: number, percent: number): { amountAIn: number; amountBIn: number; balanceAMax: number; balanceBMax: number; supplyMin: number; liquidity: number; }; declare function getFirstAmountLiquidityOut(amountAIn: number, amountBIn: number): { amountAIn: number; amountBIn: number; balanceAMax: number; balanceBMax: number; supplyMin: number; liquidity: number; }; declare function getAmountLiquidityOutUint(amountAIn: UInt64, balanceA: UInt64, balanceB: UInt64, supply: UInt64, percent: UInt64): { amountAIn: UInt64; amountBIn: UInt64; balanceAMax: UInt64; balanceBMax: UInt64; supplyMin: UInt64; liquidity: UInt64; }; declare function getAmountOutFromLiquidity(liquidity: number, balanceA: number, balanceB: number, supply: number, percent: number): { amountAOut: number; amountBOut: number; balanceAMin: number; balanceBMin: number; supplyMax: number; liquidity: number; }; export { AddLiquidityEvent, BalanceEvent, BurnEvent, BurnLiqudityEvent, ClaimEvent, Farm, FarmMerkleWitness, FarmReward, FarmRewardTokenHolder, FarmTokenHolder, FarmingEvent, FarmingInfo, Faucet, type FaucetDeployProps, MintEvent, Multisig, MultisigInfo, MultisigSigner, Pool, PoolCreationEvent, type PoolDeployProps, PoolFactory, PoolTokenHolder, ReceiveMinaEvent, SignatureInfo, SignatureRight, SubWithdrawLiquidityEvent, SwapEvent, UpdateAccountInfo, UpdateFactoryInfo, UpdateSignerData, UpdateSignerEvent, UpdateUserEvent, UpdateVerificationKeyEvent, UpgradeInfo, WithdrawLiquidityEvent, claimerNumber, contractData, contractHash, contractHolderData, contractHolderHash, getAmountLiquidityOut, getAmountLiquidityOutUint, getAmountOut, getAmountOutFromLiquidity, getAmountOutUint, getFirstAmountLiquidityOut, minTimeUnlockFarmReward, mulDiv, mulDivMod, verifySignature };