@gurge/sdk 0.3.5 → 0.3.8

package/common/src/functions/pre-transaction/store-proof.d.ts

@@ -0,0 +1,7 @@
+import { Program } from '@coral-xyz/anchor';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+export declare const storeProof: (connection: Connection, hinkalProgram: Program, signer: Keypair, originalDeployer: PublicKey, id: bigint, encryptedOutputs: number[][], proofAArr: number[], proofBArr: number[], proofCArr: number[], publicInputsArr: number[][]) => Promise<{
+    proofAccountPart1: PublicKey;
+    proofAccountPart2: PublicKey;
+    encryptedOutputsAccount: PublicKey;
+}>;

package/common/src/functions/pre-transaction/waitForDepositedUtxosInMerkleTree.d.ts

@@ -0,0 +1,3 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+import { RecipientUtxo } from '../../types';
+export declare const waitForDepositedUtxosInMerkleTree: (hinkal: IHinkal, chainId: number, userDepositedUtxos: RecipientUtxo[]) => Promise<void>;

package/common/src/functions/private-wallet/emporium.helpers.d.ts

@@ -0,0 +1,47 @@
+import { ethers } from 'ethers';
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+import { AuthorizationData } from '../../types/hinkal.types';
+import { BridgeQuote } from '../../types/bridging-tx.types';
+type EncodableContract = {
+    address?: string;
+    target?: string | {
+        toString(): string;
+    };
+    interface: {
+        encodeFunctionData: (...args: any[]) => string;
+    };
+};
+export declare const emporiumOp: ({ contract, func, args, callDataString, invokeWallet, value, }: {
+    contract: EncodableContract | string;
+    func?: string;
+    args?: unknown[];
+    callDataString?: string;
+    invokeWallet?: boolean;
+    value?: bigint;
+}) => string;
+export declare const encodeEmporiumMetadata: (chainId: number, emporiumAddress: string, privateKey: string | undefined, ops: string[], message?: bigint, signerAddress?: string) => Promise<string>;
+export declare const decodeEmporiumMetadata: (metadata: string) => {
+    v: number;
+    r: string;
+    s: string;
+    message: bigint;
+    signerAddress: string;
+    ops: string[];
+};
+export declare const createTransferToEmporiumOp: (tokenContract: EncodableContract | undefined, to: string, amount: bigint, invokeWallet: boolean) => string;
+export declare const createTransaferEmporiumOpsBatch: (hinkal: IHinkal, chainId: number, erc20TokenAddresses: string[], amounts: bigint[], to?: string) => string[];
+export declare const createApproveEmporiumOp: (tokenContract: EncodableContract, to: string, amount: bigint, invokeWallet: boolean) => string;
+export declare const generateFundAndApproveOps: (hinkal: IHinkal, chainId: number, erc20AddressesToFund: string[], fundAmounts: bigint[], approveTokenAddresses: string[], approveAmounts: bigint[], walletAddress: string, spenderAddress: string | undefined) => string[];
+export declare const createLifiBridgeOps: (hinkal: IHinkal, chainId: number, fromAddress: string, lifiRouterAddress: string, tokenAddress: string, fundAmount: bigint, bridgeAmount: bigint, quote: BridgeQuote) => string[];
+export declare const checkEOAWithDelegation: (chainId: number, eoaAddress: string) => Promise<{
+    delegated: boolean;
+    implementation: undefined;
+    nonce: undefined;
+} | {
+    delegated: boolean;
+    implementation: string;
+    nonce: number;
+}>;
+export declare const getAuthorizationDataIfNeeded: (chainId: number, privateKey: string | undefined) => Promise<AuthorizationData | undefined>;
+export declare const recoverAuthorizationData: (authorizationData: AuthorizationData | undefined) => ethers.Authorization | undefined;
+export {};

package/common/src/functions/private-wallet/emporium.swap.helpers.d.ts

@@ -0,0 +1,4 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+import { ExternalActionId } from '../../types/external-action.types';
+export declare const createSwapToEmporiumOpForUniswap: (routerAddress: string, inputTokenAddress: string, positiveAmountInput: bigint, outputTokenAddress: string, recipient: string, data: string, invokeWallet?: boolean) => string;
+export declare const createSwapToEmporiumOps: (hinkal: IHinkal, chainId: number, externalActionId: ExternalActionId, routerAddress: string, data: string, inputTokenAddress: string, inputAmount: bigint, outputAmount: bigint | undefined, outputTokenAddress: string | undefined, isTheSameChainSwap: boolean, walletAddress: string, relay: string, invokeWallet?: boolean) => Promise<string[]>;

package/common/src/functions/private-wallet/index.d.ts

@@ -0,0 +1,3 @@
+export * from './emporium.helpers';
+export * from './opProducer';
+export * from './emporium.swap.helpers';

package/common/src/functions/private-wallet/opProducer.d.ts

@@ -0,0 +1,5 @@
+export declare enum OpType {
+    Erc20Token = 0,
+    Uniswap = 1
+}
+export declare const produceOp: (opType: OpType, contractAddress: string, func?: string, args?: any[], invokeWallet?: boolean, value?: bigint) => string;

package/common/src/functions/snarkjs/common.snarkjs.d.ts

@@ -0,0 +1,23 @@
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { MerkleTree } from '../../data-structures/merkle-tree';
+import { CircomDataJsonType, CircomDataType, HookDataType, StealthAddressStructure } from '../../types/circom-data.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { FeeStructure } from '../../types/hinkal.types';
+import { SignatureData } from '../../types/crypto.types';
+export declare const getUtxoCircuitH0Coords: (utxo: Utxo) => [bigint, bigint];
+export declare const getUtxoCircuitInRandomization: (utxo: Utxo) => string;
+export declare const buildInNullifiers: (inputUtxos: Utxo[][], onChainCreation: boolean[]) => string[][];
+export declare const buildOutCommitments: (outputUtxos: Utxo[][]) => string[][];
+export declare const calcAmountChanges: (inputUtxos: Utxo[][], outputUtxos: Utxo[][], forCircomData?: boolean) => bigint[];
+export declare const getSlippageValues: (amountChanges: bigint[]) => bigint[];
+export declare const calcEncryptedOutputs: (outputUtxos: Utxo[][]) => string[][];
+export declare const calcCommitmentsSiblingAndSides: (inputUtxos: Utxo[][], merkleTree: MerkleTree<bigint>) => {
+    inCommitmentSiblings: string[][][];
+    inCommitmentSiblingSides: string[][][];
+};
+export declare const serializeCircomData: (circomData: CircomDataType) => CircomDataJsonType;
+export declare const deserializeCircomData: (circomData: CircomDataJsonType) => CircomDataType;
+export declare const createCallDataHash: (publicSignalCount: number, relay: string, externalAddress: string | undefined, externalActionId: bigint | ExternalActionId, externalActionMetadata: string, encryptedOutputs: string[][], hookData: HookDataType | undefined, slippageValues: bigint[], onChainCreation: boolean[], feeStructure: FeeStructure, signatureData: SignatureData, _originalSender?: string) => bigint;
+export declare const calcPublicSignalCount: (verifierName: string, erc20TokenAddresses: string[], amountChanges: bigint[], inNullifiers: string[][], outCommitments: string[][]) => number;
+export declare const calcStealthAddressStructure: (extraRandomization: bigint, nullifyingPrivateKey: string, spendingPublicKey: bigint[]) => StealthAddressStructure;
+export declare const getZkProofVerifierName: (inputUtxos: Utxo[][], outputUtxos: Utxo[][]) => string;

package/common/src/functions/snarkjs/constant.d.ts

@@ -0,0 +1,149 @@
+export declare const ENCLAVE_URL: string;
+export declare const prodVerifiers: {
+    mainEVMCircuit1x2x1v1x1Wasm: string;
+    mainEVMCircuit1x2x1v1x1Zkey: string;
+    mainEVMCircuit1x6x1v1x1Wasm: string;
+    mainEVMCircuit1x6x1v1x1Zkey: string;
+    mainEVMCircuit2x2x1v1x1Wasm: string;
+    mainEVMCircuit2x2x1v1x1Zkey: string;
+    mainEVMCircuit2x6x1v1x1Wasm: string;
+    mainEVMCircuit2x6x1v1x1Zkey: string;
+    mainEVMCircuit3x2x1v1x1Wasm: string;
+    mainEVMCircuit3x2x1v1x1Zkey: string;
+    mainEVMCircuit3x6x1v1x1Wasm: string;
+    mainEVMCircuit3x6x1v1x1Zkey: string;
+    mainEVMCircuit4x2x1v1x1Wasm: string;
+    mainEVMCircuit4x2x1v1x1Zkey: string;
+    mainEVMCircuit4x6x1v1x1Wasm: string;
+    mainEVMCircuit4x6x1v1x1Zkey: string;
+    mainEVMCircuit5x2x1v1x1Wasm: string;
+    mainEVMCircuit5x2x1v1x1Zkey: string;
+    mainEVMCircuit5x6x1v1x1Wasm: string;
+    mainEVMCircuit5x6x1v1x1Zkey: string;
+    mainEVMCircuit1x2x2v1x1Wasm: string;
+    mainEVMCircuit1x2x2v1x1Zkey: string;
+    mainEVMCircuit1x6x2v1x1Wasm: string;
+    mainEVMCircuit1x6x2v1x1Zkey: string;
+    mainEVMCircuit2x2x2v1x1Wasm: string;
+    mainEVMCircuit2x2x2v1x1Zkey: string;
+    mainEVMCircuit2x6x2v1x1Wasm: string;
+    mainEVMCircuit2x6x2v1x1Zkey: string;
+    mainEVMCircuitMin0v1x1Wasm: string;
+    mainEVMCircuitMin0v1x1Zkey: string;
+    mainSolanaCircuit1x2x1v1x1Zkey: string;
+    mainSolanaCircuit1x2x1v1x1Wasm: string;
+    mainSolanaCircuit1x2x2v1x1Zkey: string;
+    mainSolanaCircuit1x2x2v1x1Wasm: string;
+    mainSolanaCircuit1x6x1v1x1Zkey: string;
+    mainSolanaCircuit1x6x1v1x1Wasm: string;
+    mainSolanaCircuit1x6x2v1x1Zkey: string;
+    mainSolanaCircuit1x6x2v1x1Wasm: string;
+    mainSolanaCircuit2x2x1v1x1Zkey: string;
+    mainSolanaCircuit2x2x1v1x1Wasm: string;
+    mainSolanaCircuit2x6x1v1x1Zkey: string;
+    mainSolanaCircuit2x6x1v1x1Wasm: string;
+    commitmentCalculator1x2v1x1Wasm: string;
+    commitmentCalculator1x2v1x1Zkey: string;
+    commitmentCalculator1x2v1x1VK: string;
+    commitmentCalculator1x6v1x1Wasm: string;
+    commitmentCalculator1x6v1x1Zkey: string;
+    commitmentCalculator1x6v1x1VK: string;
+    commitmentCalculator2x2v1x1Wasm: string;
+    commitmentCalculator2x2v1x1Zkey: string;
+    commitmentCalculator2x2v1x1VK: string;
+    commitmentCalculator2x6v1x1Wasm: string;
+    commitmentCalculator2x6v1x1Zkey: string;
+    commitmentCalculator2x6v1x1VK: string;
+    commitmentCalculator3x2v1x1Wasm: string;
+    commitmentCalculator3x2v1x1Zkey: string;
+    commitmentCalculator3x2v1x1VK: string;
+    commitmentCalculator3x6v1x1Wasm: string;
+    commitmentCalculator3x6v1x1Zkey: string;
+    commitmentCalculator3x6v1x1VK: string;
+    commitmentCalculator4x2v1x1Wasm: string;
+    commitmentCalculator4x2v1x1Zkey: string;
+    commitmentCalculator4x2v1x1VK: string;
+    commitmentCalculator4x6v1x1Wasm: string;
+    commitmentCalculator4x6v1x1Zkey: string;
+    commitmentCalculator4x6v1x1VK: string;
+    commitmentCalculator5x2v1x1Wasm: string;
+    commitmentCalculator5x2v1x1Zkey: string;
+    commitmentCalculator5x2v1x1VK: string;
+    commitmentCalculator5x6v1x1Wasm: string;
+    commitmentCalculator5x6v1x1Zkey: string;
+    commitmentCalculator5x6v1x1VK: string;
+};
+export declare const localVerifiers: {
+    mainEVMCircuit1x2x1v1x1Wasm: string;
+    mainEVMCircuit1x2x1v1x1Zkey: string;
+    mainEVMCircuit1x6x1v1x1Wasm: string;
+    mainEVMCircuit1x6x1v1x1Zkey: string;
+    mainEVMCircuit2x2x1v1x1Wasm: string;
+    mainEVMCircuit2x2x1v1x1Zkey: string;
+    mainEVMCircuit2x6x1v1x1Wasm: string;
+    mainEVMCircuit2x6x1v1x1Zkey: string;
+    mainEVMCircuit3x2x1v1x1Wasm: string;
+    mainEVMCircuit3x2x1v1x1Zkey: string;
+    mainEVMCircuit3x6x1v1x1Wasm: string;
+    mainEVMCircuit3x6x1v1x1Zkey: string;
+    mainEVMCircuit4x2x1v1x1Wasm: string;
+    mainEVMCircuit4x2x1v1x1Zkey: string;
+    mainEVMCircuit4x6x1v1x1Wasm: string;
+    mainEVMCircuit4x6x1v1x1Zkey: string;
+    mainEVMCircuit5x2x1v1x1Wasm: string;
+    mainEVMCircuit5x2x1v1x1Zkey: string;
+    mainEVMCircuit5x6x1v1x1Wasm: string;
+    mainEVMCircuit5x6x1v1x1Zkey: string;
+    mainEVMCircuit1x2x2v1x1Wasm: string;
+    mainEVMCircuit1x2x2v1x1Zkey: string;
+    mainEVMCircuit1x6x2v1x1Wasm: string;
+    mainEVMCircuit1x6x2v1x1Zkey: string;
+    mainEVMCircuit2x2x2v1x1Wasm: string;
+    mainEVMCircuit2x2x2v1x1Zkey: string;
+    mainEVMCircuit2x6x2v1x1Wasm: string;
+    mainEVMCircuit2x6x2v1x1Zkey: string;
+    mainEVMCircuitMin0v1x1Wasm: string;
+    mainEVMCircuitMin0v1x1Zkey: string;
+    mainSolanaCircuit1x2x1v1x1Zkey: string;
+    mainSolanaCircuit1x2x1v1x1Wasm: string;
+    mainSolanaCircuit1x2x2v1x1Zkey: string;
+    mainSolanaCircuit1x2x2v1x1Wasm: string;
+    mainSolanaCircuit1x6x1v1x1Zkey: string;
+    mainSolanaCircuit1x6x1v1x1Wasm: string;
+    mainSolanaCircuit1x6x2v1x1Zkey: string;
+    mainSolanaCircuit1x6x2v1x1Wasm: string;
+    mainSolanaCircuit2x2x1v1x1Zkey: string;
+    mainSolanaCircuit2x2x1v1x1Wasm: string;
+    mainSolanaCircuit2x6x1v1x1Zkey: string;
+    mainSolanaCircuit2x6x1v1x1Wasm: string;
+    commitmentCalculator1x2v1x1Zkey: string;
+    commitmentCalculator1x2v1x1Wasm: string;
+    commitmentCalculator1x2v1x1VK: string;
+    commitmentCalculator1x6v1x1Zkey: string;
+    commitmentCalculator1x6v1x1Wasm: string;
+    commitmentCalculator1x6v1x1VK: string;
+    commitmentCalculator2x2v1x1Zkey: string;
+    commitmentCalculator2x2v1x1Wasm: string;
+    commitmentCalculator2x2v1x1VK: string;
+    commitmentCalculator2x6v1x1Zkey: string;
+    commitmentCalculator2x6v1x1Wasm: string;
+    commitmentCalculator2x6v1x1VK: string;
+    commitmentCalculator3x2v1x1Zkey: string;
+    commitmentCalculator3x2v1x1Wasm: string;
+    commitmentCalculator3x2v1x1VK: string;
+    commitmentCalculator3x6v1x1Zkey: string;
+    commitmentCalculator3x6v1x1Wasm: string;
+    commitmentCalculator3x6v1x1VK: string;
+    commitmentCalculator4x2v1x1Zkey: string;
+    commitmentCalculator4x2v1x1Wasm: string;
+    commitmentCalculator4x2v1x1VK: string;
+    commitmentCalculator4x6v1x1Zkey: string;
+    commitmentCalculator4x6v1x1Wasm: string;
+    commitmentCalculator4x6v1x1VK: string;
+    commitmentCalculator5x2v1x1Zkey: string;
+    commitmentCalculator5x2v1x1Wasm: string;
+    commitmentCalculator5x2v1x1VK: string;
+    commitmentCalculator5x6v1x1Zkey: string;
+    commitmentCalculator5x6v1x1Wasm: string;
+    commitmentCalculator5x6v1x1VK: string;
+};

package/common/src/functions/snarkjs/constructGeneralZkProof.d.ts

@@ -0,0 +1,13 @@
+import { MerkleTree } from '../../data-structures/merkle-tree';
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { CircomDataType, DimDataType, HookDataType } from '../../types/circom-data.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { FeeStructure } from '../../types/hinkal.types';
+export declare const constructZkProof: <T = CircomDataType>(merkleTree: MerkleTree<bigint>, inputUtxos: Utxo[][], outputUtxos: Utxo[][], userKeys: UserKeys, externalActionId: ExternalActionId | 0n, externalAddress: string | undefined, externalActionMetadata: string | string[], generateProofRemotely: boolean, feeStructure: FeeStructure, relay?: string, chainId?: number, onChainCreation?: boolean[], hookData?: HookDataType | undefined, originalSender?: string, subAccountPrivateKey?: string) => Promise<{
+    zkCallData: import('../..').NewZkCallDataType;
+    circomData: T;
+    dimData: DimDataType;
+    encryptedOutputs: string[][];
+    commitmentValidationData: import('../..').CommitmentValidationDataType | undefined;
+}>;

package/common/src/functions/snarkjs/constructSolanaZkProof.d.ts

@@ -0,0 +1,13 @@
+import { HinkalInstruction } from '../pre-transaction';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { AccountMeta } from '@solana/web3.js';
+import { DimDataType } from '../../types/circom-data.types';
+import { MerkleTree } from '../../data-structures/merkle-tree';
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+export declare const constructSolanaZkProof: (generateProofRemotely: boolean, merkleTreeHinkal: MerkleTree<bigint>, userKeys: UserKeys, mintAddresses: string[], inputUtxosArray: Utxo[][], outputUtxosArray: Utxo[][], extraRandomization: bigint, relayerFee: bigint, variableRate: bigint, recipientAddress: string, signerAddress: string, dimensions: DimDataType, encryptedOutputs: number[][], chainId?: number, instructions?: HinkalInstruction[], remainingAccounts?: AccountMeta[], swapperAccountSalt?: bigint) => Promise<{
+    proofAArr: number[];
+    proofBArr: number[];
+    proofCArr: number[];
+    publicInputsArr: number[][];
+    commitmentValidationData: import('../..').CommitmentValidationDataType | undefined;
+}>;

package/common/src/functions/snarkjs/fetchMerkleTreeSiblings.d.ts

@@ -0,0 +1,11 @@
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+interface MerkleTreeSiblingsResponse {
+    inCommitmentSiblings: string[][][];
+    inCommitmentSiblingSides: string[][][];
+    accessTokenSiblings: string[];
+    accessTokenSiblingSides: string[];
+    rootHashHinkal: string;
+    rootHashAccessToken: string;
+}
+export declare const fetchMerkleTreeSiblings: (chainId: number, inputUtxosSerialized: IUtxoConstructor[][]) => Promise<MerkleTreeSiblingsResponse>;
+export {};

package/common/src/functions/snarkjs/fetchOnChainRootHashes.d.ts

@@ -0,0 +1,3 @@
+export declare const fetchOnChainRootHashes: (chainId: number) => Promise<{
+    hinkalRootHash: bigint;
+}>;

package/common/src/functions/snarkjs/generateCircomData.d.ts

@@ -0,0 +1,5 @@
+import { FeeStructure } from '../../types/hinkal.types';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { CircomDataType, HookDataType, StealthAddressStructure } from '../../types/circom-data.types';
+import { ExternalActionId } from '../../types/external-action.types';
+export declare const generateCircomData: (outCommitments: string[][], inputNullifiers: string[][], rootHashHinkal: bigint | undefined, amountChanges: bigint[], erc20TokenAddresses: string[], outputUtxos: Utxo[][], encryptedOutputs: string[][], publicSignalCount: number, externalActionId: ExternalActionId | bigint, externalAddress: string | undefined, externalActionMetadata: string, relay: string, calldataHash: bigint, stealthAddressStructure: StealthAddressStructure, onChainCreation: boolean[], hookData: HookDataType | undefined, timeStampFallback: number | undefined, slippageValues: bigint[], feeStructure: FeeStructure, signatureData?: import('../..').SignatureData, originalSender?: string) => CircomDataType;

package/common/src/functions/snarkjs/generateMainAndCommitmentZkProof.d.ts

@@ -0,0 +1,11 @@
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { CommitmentValidationDataType } from '../../types/circom-data.types';
+import { NewZkCallDataType } from '../../types/snark.types';
+interface GenerateMainAndCommitmentZkProofResponse {
+    zkCallData: NewZkCallDataType;
+    publicSignals: string[];
+    commitmentValidationData: CommitmentValidationDataType | undefined;
+}
+export declare const generateMainAndCommitmentZkProof: (chainId: number, userKeys: UserKeys, tokenAddresses: string[], inputUtxos: Utxo[][], mainVerifierName: string, mainCircuitInput: unknown, generateProofRemotely: boolean) => Promise<GenerateMainAndCommitmentZkProofResponse>;
+export {};

package/common/src/functions/snarkjs/generateZkProof.d.ts

@@ -0,0 +1,5 @@
+import { NewZkCallDataType } from '../../types/snark.types';
+export declare const generateZkProof: (chainId: number, verifierNames: string[], inputs: any[], remotely?: boolean) => Promise<{
+    zkCallData: NewZkCallDataType;
+    publicSignals: string[];
+}[]>;

package/common/src/functions/snarkjs/generateZkProofEnclave.d.ts

@@ -0,0 +1,5 @@
+import { NewZkCallDataType } from '../../types/snark.types';
+export declare const generateZkProofEnclave: (chainId: number, verifierNames: string[], inputs: any[]) => Promise<{
+    zkCallData: NewZkCallDataType;
+    publicSignals: string[];
+}[]>;

package/common/src/functions/snarkjs/generateZkProofSelf.d.ts

@@ -0,0 +1,5 @@
+import { NewZkCallDataType } from '../../types';
+export declare const generateZkProofSelf: (chainId: number, verifierName: string, input: any) => Promise<{
+    zkCallData: NewZkCallDataType;
+    publicSignals: string[];
+}>;

package/common/src/functions/snarkjs/getMerkleTreeSiblingsAndRootHashes.d.ts

@@ -0,0 +1,16 @@
+import { MerkleTree } from '../../data-structures/merkle-tree';
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+import { ZKProofWorkerBuildInNullifiersReturn } from '../../webworker/zkProofWorker/zkProofWorker.types';
+interface MerkleTreeSiblingsAndRootHashes {
+    inCommitmentSiblings: string[][][];
+    inCommitmentSiblingSides: string[][][];
+    rootHashHinkal: bigint;
+}
+export declare const getMerkleTreeSiblingsAndRootHashes: (chainId: number, inputUtxosSerialized: IUtxoConstructor[][], merkleTree: MerkleTree<bigint>) => Promise<MerkleTreeSiblingsAndRootHashes>;
+export declare const getDataFromWorkers: (chainId: number, merkleTree: MerkleTree<bigint>, inputUtxosSerialized: IUtxoConstructor[][]) => Promise<{
+    inCommitmentSiblings: string[][][];
+    inCommitmentSiblingSides: string[][][];
+    rootHashHinkal: bigint;
+    inNullifiers: ZKProofWorkerBuildInNullifiersReturn;
+}>;
+export {};

package/common/src/functions/snarkjs/getOriginalSender.d.ts

@@ -0,0 +1 @@
+export declare const getOriginalSender: (externalAddress: string, relay: string) => string;

package/common/src/functions/snarkjs/getZKFiles.d.ts

@@ -0,0 +1,3 @@
+export declare const getWASMFile: (filename: string, chainId: number) => string;
+export declare const getZKeyFile: (filename: string, chainId: number) => string;
+export declare const getVKFile: (filename: string, chainId: number) => string;

package/common/src/functions/snarkjs/index.d.ts

@@ -0,0 +1,8 @@
+export * from './constructGeneralZkProof';
+export * from './common.snarkjs';
+export * from './signedMessageHash';
+export * from './generateZkProof';
+export * from './generateMainAndCommitmentZkProof';
+export * from './constructSolanaZkProof';
+export * from './fetchOnChainRootHashes';
+export * from './verifyCommitmentValidationData';

package/common/src/functions/snarkjs/signedMessageHash.d.ts

@@ -0,0 +1,31 @@
+type EvmSignedMessageHashParams = {
+    rootHashHinkal: bigint;
+    erc20TokenAddresses: string[];
+    amountChanges: bigint[];
+    outTimeStamp: bigint;
+    inNullifiers: string[][];
+    outCommitments: string[][];
+    calldataHash: bigint;
+    message: bigint;
+    outH1Ay: bigint;
+    H0Ax: bigint;
+    H0Ay: bigint;
+};
+type SolanaSignedMessageHashParams = {
+    rootHashHinkal: bigint;
+    mintAccountPart1: bigint[];
+    mintAccountPart2: bigint[];
+    amountChanges: bigint[];
+    outTimeStamp: bigint;
+    inNullifiers: string[][];
+    outCommitments: string[][];
+    calldataHash: bigint;
+    message: bigint;
+    swapperAccountAdditionalSeed: bigint;
+    outH1Ay: bigint;
+    H0Ax: bigint;
+    H0Ay: bigint;
+};
+export declare const computeSignedMessageHashEvm: (params: EvmSignedMessageHashParams) => bigint;
+export declare const computeSignedMessageHashSolana: (params: SolanaSignedMessageHashParams) => bigint;
+export {};

package/common/src/functions/snarkjs/verifyCommitmentValidationData.d.ts

@@ -0,0 +1,4 @@
+import { HinkalTransactionRequestBody } from '../../API/callRelayer';
+import { SolanaTransactionBody } from '../../types/solana.types';
+export declare const verifyCommitmentValidationData: (requestBody: HinkalTransactionRequestBody) => Promise<void>;
+export declare const verifyCommitmentValidationDataSolana: (requestBody: SolanaTransactionBody) => Promise<void>;

package/common/src/functions/utils/addresses.d.ts

@@ -0,0 +1,11 @@
+import { StealthAddressStructure } from '../../types/circom-data.types';
+export declare const isValidPrivateAddress: (address: string) => boolean;
+export declare const isValidOldStylePrivateAddress: (address: string) => boolean;
+export declare const constructStealthAddressStructure: (recipientInfo: string) => StealthAddressStructure;
+export declare const hashEthereumAddress: (ethereumAddress: string) => string;
+export declare const hashString: (string: string) => string;
+export declare const isValidSolanaPublicKey: (str: string) => boolean;
+export declare const isNativePlaceholderAddress: (address: string, chainId?: number) => boolean;
+export declare const formatAddress: (address?: string) => string;
+export declare const isValidTronAddress: (address: string) => boolean;
+export declare const isRecipientAddressInvalid: (address: string, isSolana: boolean, isTron: boolean) => boolean;

package/common/src/functions/utils/aggregateTokenAmounts.d.ts

@@ -0,0 +1,2 @@
+import { Activity } from '../../types/activities.types';
+export declare const aggregateTokensBySymbol: (tokens: Activity["tokensSpend"] | Activity["tokensReceive"]) => NonNullable<typeof tokens>;

package/common/src/functions/utils/amounts.utils.d.ts

@@ -0,0 +1,25 @@
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { BigIntable } from '../../types/big-intable.types';
+export declare const calculateSum: (arr: number[]) => number;
+export declare const beepsToPercentage: (beeps: number) => number;
+export declare const calculateAmountUsingBeeps: (beep: bigint, amount: bigint) => bigint;
+export declare function toBigInt(value: BigIntable): bigint;
+export declare const advancedToBigInt: (value: number[] | string | number | bigint) => bigint;
+/** Converts the value to a BigInt or returns undefined if can't */
+export declare const toBigIntOrUndefined: (value: any) => bigint | undefined;
+/** Converts the value to a number or returns undefined if can't */
+export declare const toNumberOrUndefined: (value: any) => number | undefined;
+export declare const toInt: (param: string | undefined, defaultValue: number) => number;
+export declare function bigintMax(...values: bigint[]): bigint;
+export declare function fixDecimalsAmount(n: number, decimals?: number): number | " < 0.000001";
+export declare const getValueFirstNDigit: (num: number, numberOfDigits: number) => string;
+export declare const trimLeadingZeros: (numberString: string) => string;
+export declare const toCommaSeparatedNumberString: (numberString: string) => string;
+export declare const truncateToDecimalPlaces: (numStr: string, decimalPlaces?: number) => string;
+export declare const formatAmountInput: (valueStr: string, decimals: number | undefined, inputEl?: HTMLInputElement) => string | null;
+/** Return absolute value of BigInt */
+export declare const absBigInt: (n: bigint) => bigint;
+/** Return the smallest values of the 2 or 3 values provided */
+export declare const minBigInt: (a: bigint, b: bigint, c?: bigint) => bigint;
+export declare const maxBigInt: (a: bigint, b: bigint) => bigint;
+export declare const countTotalAmountInUtxos: (utxos: Utxo[]) => bigint;

package/common/src/functions/utils/arraysMatch.d.ts

@@ -0,0 +1 @@
+export declare const arraysMatch: (array1: unknown[], array2: unknown[]) => boolean;

package/common/src/functions/utils/auth.utils.d.ts

@@ -0,0 +1,5 @@
+export declare const getAuthHeaders: (item: string) => {
+    Authorization: string;
+} | {
+    Authorization?: undefined;
+};

package/common/src/functions/utils/bit.operations.d.ts

@@ -0,0 +1,3 @@
+export declare const addHighestBitToNumber: (value: bigint) => bigint;
+export declare const takeOffHighestBit: (value: bigint) => bigint;
+export declare const extractHighestBit: (value: bigint) => bigint;

package/common/src/functions/utils/buildClaimableDepositPlan.d.ts

@@ -0,0 +1,16 @@
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { FallbackRecipientUtxoPlan, StealthAddressStructure } from '../../types';
+interface BuildClaimableDepositPlanParams {
+    userKeys: UserKeys;
+    recipientAmounts: bigint[];
+    recipientAddresses: string[];
+    recipientInfos?: Array<string | undefined>;
+    nonce: bigint;
+    tokenAddress: string;
+}
+export interface ClaimableDepositPlan {
+    stealthAddressStructures: StealthAddressStructure[];
+    fallbackRecipients: FallbackRecipientUtxoPlan[];
+}
+export declare const buildClaimableDepositPlan: ({ userKeys, recipientAmounts, recipientAddresses, recipientInfos, nonce, tokenAddress, }: BuildClaimableDepositPlanParams) => ClaimableDepositPlan;
+export {};

package/common/src/functions/utils/bytes32.utils.d.ts

@@ -0,0 +1,2 @@
+export declare const convertBytes32ToBigInt: (bytes32: number[]) => bigint;
+export declare const convertBigIntToBytes32: (value: bigint) => number[];

package/common/src/functions/utils/cacheDevice.utils.d.ts

@@ -0,0 +1,3 @@
+import { HinkalConfig } from '../../types/hinkal.types';
+import { FileCacheDevice, LocalStorageCacheDevice } from '../../data-structures/cacheDevices';
+export declare const createCacheDevice: (hinkalConfig?: HinkalConfig) => FileCacheDevice | LocalStorageCacheDevice;

package/common/src/functions/utils/cacheFunctions.d.ts

@@ -0,0 +1,16 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+import { DecodedTx } from '../../types/transactions.types';
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+export interface HinkalCacheInterface {
+    encryptedOutputs: EncryptedOutputWithSign[];
+    lastOutput: string;
+}
+export declare const getFilePath: (chainId: number, shortPublicKey: string, shortHinkalAddress: string) => string;
+export declare const getHinkalCache: (hinkal: IHinkal, chainId: number, shieldedPublicKey: string) => HinkalCacheInterface;
+export declare const setHinkalCache: (hinkalCache: HinkalCacheInterface, hinkal: IHinkal, chainId: number, shieldedPublicKey: string) => void;
+export declare const resetCache: (hinkal: IHinkal, chainId: number, shieldedPublicKey: string) => void;
+export declare const saveTxsCache: (txs: DecodedTx[], chainId: number, shieldedPublicKey: string, hinkalAddress: string, lastHash: string, hinkal: IHinkal) => Promise<void>;
+export declare const loadTxsCache: (chainId: number, shieldedPublicKey: string, hinkalAddress: string, hinkal: IHinkal) => Promise<{
+    decodedTxs: import('../..').DecodedTxWithUtxos<bigint, bigint>[];
+    lastHash: string | undefined;
+}>;

package/common/src/functions/utils/caseInsensitive.utils.d.ts

@@ -0,0 +1,3 @@
+export declare const caseInsensitiveEqual: (a?: string | null, b?: string | null) => boolean;
+export declare const lowerCaseIncludes: (array: string[], address?: string) => boolean;
+export declare const lowerCaseStartsWith: (array: string[], s: string) => boolean;

package/common/src/functions/utils/convertEmporiumOpToCallInfo.d.ts

@@ -0,0 +1,2 @@
+import { CallInfo } from '../../types/API.types';
+export declare const convertEmporiumOpToCallInfo: (op: string, walletAddress: string, chainId: number) => CallInfo;

package/common/src/functions/utils/convertIntegrationProviderToExternalActionId.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationProvider } from '../../types/hinkal.types';
+import { ExternalActionId } from '../../types/external-action.types';
+export declare const convertIntegrationProviderToExternalActionId: (integrationProvider: IntegrationProvider) => ExternalActionId | undefined;

package/common/src/functions/utils/create-provider.d.ts

@@ -0,0 +1,4 @@
+import { Commitment, Connection, ConnectionConfig } from '@solana/web3.js';
+import { JsonRpcProvider } from 'ethers';
+export declare const createJsonRpcProvider: (chainId: number) => JsonRpcProvider;
+export declare const createCustomSolanaConnection: (endpoint: string, commitmentOrConfig?: Commitment | ConnectionConfig) => Connection;

package/common/src/functions/utils/customEnclaveFunctionsRegister.d.ts

@@ -0,0 +1,18 @@
+import { RemoteProofType } from '../../types/remote-proof.types';
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+import { NewZkCallDataType } from '../../types/snark.types';
+export type ProofGeneratorFn = (inputs: any[], circuitWasmFilenames: string[], circuitZkeyFilenames: string[]) => Promise<{
+    proof: RemoteProofType;
+    publicSignals: string[];
+    zkCallData: NewZkCallDataType;
+}[]>;
+export type UtxoDecryptorFn = (chainId: number, keysData: Uint8Array) => Promise<{
+    utxos: IUtxoConstructor<string>[];
+    encryptedOutputs: EncryptedOutputWithSign[];
+    lastOutput: string;
+}>;
+export declare const setCustomProofGenerator: (fn: ProofGeneratorFn) => void;
+export declare const getCustomProofGenerator: () => ProofGeneratorFn | undefined;
+export declare const setCustomUtxoDecryptor: (fn: UtxoDecryptorFn) => void;
+export declare const getCustomUtxoDecryptor: () => UtxoDecryptorFn | undefined;

package/common/src/functions/utils/deposit-claimable.utils.d.ts

@@ -0,0 +1,6 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+import { AdminTransactionType, ERC20Token, PendingEnclaveUtxo } from '../../types';
+export declare const depositClaimableUtxos: (hinkal: IHinkal, erc20Token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], nonce: bigint, recipientInfos?: Array<string | undefined>, action?: AdminTransactionType) => Promise<{
+    pendingEnclaveUtxos: PendingEnclaveUtxo[];
+    txHash: string;
+}>;

package/common/src/functions/utils/dispatchBalanceRefreshes.d.ts

@@ -0,0 +1,4 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+export declare const initialMerkleAndPrivateBalanceRefresh: (hinkal: IHinkal, skipMerkleReset?: boolean) => Promise<void>;
+export declare const refreshPrivateBalance: (hinkal: IHinkal, makeHardRefresh?: boolean) => Promise<void>;
+export declare const hardRefreshPrivateBalance: (hinkal: IHinkal) => Promise<void>;

package/common/src/functions/utils/enclave-recipient-info-storage.d.ts

@@ -0,0 +1,2 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+export declare const ensureRecipientInfoPool: (hinkal: IHinkal, address: string, isSolanaLedger: boolean, txMessageForSolanaLedger: string | undefined) => Promise<void>;

package/common/src/functions/utils/enclave-signature-storage.d.ts

@@ -0,0 +1 @@
+export declare const storeAndGetSignatureFromEnclave: (ethAddress: string, authSignature: string, isSolanaLedger: boolean, txMessageForSolanaLedger?: string) => Promise<string>;

package/common/src/functions/utils/enclave-utxo-storage.d.ts

@@ -0,0 +1,7 @@
+import { IUtxoConstructor, Utxo } from '../../data-structures/utxo/Utxo';
+export type UtxoConstructorParamsWithSenderAddress = IUtxoConstructor<string> & {
+    senderAddress: string;
+    claimableSignature?: string;
+};
+export declare const storeUtxoInEnclave: (senderAddress: string, recipientEthAddress: string, utxo: Utxo, chainId: number, claimableSignature?: string) => Promise<void>;
+export declare const getUtxosFromEnclave: (ethAddress: string, signature: string, chainId: number, isSolanaLedger: boolean, txMessageForSolanaLedger?: string) => Promise<UtxoConstructorParamsWithSenderAddress[]>;

package/common/src/functions/utils/encodeTokenWithId.d.ts

@@ -0,0 +1,2 @@
+import { TokenWithId } from '../../types/token-with-id.types';
+export declare const encodeTokenWithId: (chainId: number, tokenWithId: TokenWithId) => string;

package/common/src/functions/utils/encryptInputForEnclave.d.ts

@@ -0,0 +1,8 @@
+export declare const makeEnclaveHandshakeAndEncryptInput: (input: any) => Promise<{
+    keyCiphertext: string;
+    inputCiphertext: string;
+}>;
+export declare const makeEnclaveHandshakeAndEncryptUint8Array: (inputUint8Array: Uint8Array) => Promise<{
+    keyCiphertext: string;
+    inputCiphertext: string;
+}>;

package/common/src/functions/utils/enum.utils.d.ts

@@ -0,0 +1,9 @@
+/** Verifies that the value is in the enumType specified */
+export declare function isInEnum<T>(enumType: T, value: any): value is T[keyof T];
+/** Converts a string value to an Enum member
+ *  If a value can't be matched to a valid option in the enum, returns undefined (or throws if throwIfInvalid = true) */
+export declare function toEnumValue<T>(e: T, value: any, throwIfInvalid?: boolean): T[keyof T] | undefined;
+/** returns first item in an enum that is included somewhere in the target string
+ * e.g. enumInString(ErrorCode, '001-badpassword: error') => ErrorCode.BadPassword
+ */
+export declare function enumInString<T extends Record<string, string>>(enumType: T, searchString: any): T[keyof T] | undefined;