@hinkal/common 0.2.9 → 0.2.11

package/externalABIs/swapAbi.d.mts

@@ -0,0 +1,77 @@
+export declare const ERC20ABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+export declare const WETHABI: ({
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    constant?: undefined;
+    inputs?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    constant?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+    stateMutability?: undefined;
+})[];

package/functions/index.d.mts

@@ -0,0 +1,14 @@
+export * from './kyc';
+export * from './utils';
+export * from './web3';
+export * from './snarkjs';
+export * from './pre-transaction';
+export * from './protocols';
+export * from './staking';
+export * from './private-wallet';
+export * from './pre-transaction/getFlatFees';
+export * from './pre-transaction/outputUtxoProcessing';
+export * from './utils/requireEnv';
+export * from './utils/resolve-sync.utils';
+export * from './utils/getDataFromTransaction';
+export * from './web3/uniswapAPI';

package/functions/kyc/authentoHelper.d.mts

@@ -0,0 +1,12 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+export declare const AUTHENTO: {
+    verifyMessageText: string;
+    domainName: string;
+    type: {
+        Message: {
+            name: string;
+            type: string;
+        }[];
+    };
+};
+export declare const authentoKycHandler: (hinkal: IHinkal, shortName: string, onboardURL: string) => Promise<void>;

package/functions/kyc/index.d.mts

@@ -0,0 +1,3 @@
+export * from '../web3/functionCalls/accessTokenCalls';
+export * from './passportHelper';
+export * from './openDefaultPassportWindow';

package/functions/kyc/openDefaultPassportWindow.d.mts

@@ -0,0 +1 @@
+export declare const openDefaultPassportWindow: (onboardURL: string, shortName: string, height?: number, width?: number) => void;

package/functions/kyc/passportHelper.d.mts

@@ -0,0 +1,3 @@
+import { Passports } from '../../types/kyc.types';
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+export declare const openPassportWindow: (passport: Passports, hinkal: IHinkal, height?: number, width?: number) => void;

package/functions/kyc/zkMeHelper.d.mts

@@ -0,0 +1,4 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+export declare const zkMeKycHandler: (hinkal: IHinkal, shortName: string, onboardURL: string, params: {
+    merchId: string;
+}) => Promise<void>;

package/functions/pre-transaction/getFlatFees.d.mts

@@ -0,0 +1,12 @@
+import { ERC20Token, ExternalActionId, ValidExternalAction } from '../../types';
+/**
+ * Infer INTERACTION type from given @param externalActionId and @param action
+ * and return `flatFee` along with `feeUnit` - the token corespond with the fee,
+ * `priceOfTransactionInToken`, and `priceOfTransactionInUSD`
+ */
+export declare const getFlatFees: (chainId: number, erc20Addresses: string[], externalActionId: ExternalActionId, amountChanges: bigint[], action?: ValidExternalAction, gasTokenAddress?: string) => Promise<{
+    flatFees: bigint[];
+    priceOfTransactionInToken: bigint | undefined;
+    feeUnit: ERC20Token | undefined;
+    priceOfTransactionInUSD: number | undefined;
+}>;

package/functions/pre-transaction/index.d.mts

@@ -0,0 +1,5 @@
+export * from './interaction-to-action';
+export * from './outputUtxoProcessing';
+export * from './process-gas-estimates';
+export * from './processAmountChanges';
+export * from './getFlatFees';

package/functions/pre-transaction/interaction-to-action.d.mts

@@ -0,0 +1,2 @@
+import { ExternalActionId, INTERACTION, ValidExternalAction } from '../../types';
+export declare const getInteractionFromAction: (externalActionId: ExternalActionId, action?: ValidExternalAction) => INTERACTION;

package/functions/pre-transaction/outputUtxoProcessing.d.mts

@@ -0,0 +1,5 @@
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+export declare const outputUtxoProcessing: (userKeys: UserKeys, inputUtxos: Utxo[], amountChange: bigint, timeStamp?: string, tokenId?: number) => {
+    outputUtxos: Utxo[];
+};

package/functions/pre-transaction/process-gas-estimates.d.mts

@@ -0,0 +1,5 @@
+import { ERC20Token, ExternalActionId, ValidExternalAction } from '../../types';
+export declare const processGasEstimates: (chainId: number, token: ERC20Token, externalActionId: ExternalActionId, action: ValidExternalAction | undefined, erc20TokenAddressLength: number, gasAmount?: number) => Promise<{
+    priceOfTransactionInUSD: number | undefined;
+    priceOfTransactionInToken: bigint | undefined;
+}>;

package/functions/pre-transaction/processAmountChanges.d.mts

@@ -0,0 +1,12 @@
+import { ERC20Token, ExternalActionId, ValidExternalAction } from '../../types';
+export interface ProcessAmountChangesParam {
+    erc20Addresses: string[];
+    amountChanges: bigint[];
+    flatFees: bigint[];
+    feeUnit?: ERC20Token;
+    externalActionId: ExternalActionId;
+    action?: ValidExternalAction;
+    /** if provided, gas will be estimated using this token */
+    gasTokenAddress?: string;
+}
+export declare const processAmountChanges: ({ erc20Addresses, amountChanges, flatFees, feeUnit, externalActionId, action, gasTokenAddress, }: ProcessAmountChangesParam) => bigint[];

package/functions/private-wallet/emporium.helpers.d.mts

@@ -0,0 +1,5 @@
+import { Contract, ContractTransaction } from 'ethers';
+export declare const emporiumOp: <ContractInstance extends Contract, ContractFunctions extends ContractInstance["functions"], ExactFunction extends { [K in keyof ContractFunctions]: ReturnType<ContractFunctions[K]> extends Promise<ContractTransaction> ? K : never; }[keyof ContractFunctions], FunctionArguments extends Parameters<ContractFunctions[ExactFunction]>>(contract: ContractInstance | string, func?: ExactFunction, args?: FunctionArguments extends [
+] ? [
+] : FunctionArguments, invokeWallet?: boolean, value?: bigint) => string;
+export declare const encodeEmporiumMetadata: (ops: string[], walletSalt?: string) => string;

package/functions/private-wallet/index.d.mts

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

package/functions/private-wallet/opProducer.d.mts

@@ -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/functions/protocols/convex.protocols.d.mts

@@ -0,0 +1 @@
+export declare const getCVX: (chainId: number | undefined) => "0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B" | "0x4257ea7637c355f81616050cbb6a9b709fd72683" | "0xb952a807345991bd529fdded05009f5e80fe8f45" | "0x81ab7e0d570b01411fcc4afd3d50ec8c241cb74b";

package/functions/protocols/curve.protocols.d.mts

@@ -0,0 +1 @@
+export declare const getCRV: (chainId: number | undefined) => "0xD533a949740bb3306d119CC777fa900bA034cd52" | "0x0994206dfe8de6ec6920ff4d779b0d950605fb53" | "0x8Ee73c484A26e0A5df2Ee2a4960B789967dd0415" | "0x172370d5Cd63279eFa6d502DAB29171933a610AF" | "0x11cdb42b0eb46d95f990bedd4695a6e3fa034978" | "0x47536F17F4fF30e64A96a7555826b8f9e66ec468";

package/functions/protocols/index.d.mts

@@ -0,0 +1,3 @@
+export * from './curve.protocols';
+export * from './convex.protocols';
+export * from './pendle.helpers';

package/functions/protocols/pendle.helpers.d.mts

@@ -0,0 +1,8 @@
+import { ERC20Token, PendleAsset, PendleAssetType, PendleMarket, PendleSwapType, ValidExternalAction } from '../../types';
+export declare function erc20TokenFromPendleAsset(asset: PendleAsset | undefined): ERC20Token | undefined;
+/** Extract a specific Pendle Asset section from a market */
+export declare function getAssetTypeFromPendleMarket(market: PendleMarket | undefined, selectedMarketAssetType: PendleAssetType | undefined): PendleAsset | undefined;
+export declare const determinePendleSwapType: (market: PendleMarket, inSwapToken: ERC20Token, outSwapToken: ERC20Token) => PendleSwapType | undefined;
+export declare const determinePendleSwapTypeApiRoute: (swapType: PendleSwapType | undefined) => string;
+/** determines which token (by index in a list of tokens) should be used for calcuating gas and */
+export declare const getTokenIndexForPendleFlatFee: (action: ValidExternalAction | undefined, amountChanges: bigint[], erc20Addresses: string[], flatFeeTokenAddressSelectedByUser?: string | undefined) => number;

package/functions/snarkjs/common.snarkjs.d.mts

@@ -0,0 +1,22 @@
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { MerkleTree } from '../../data-structures/merkle-tree';
+import { CircomDataJsonType, CircomDataType, HookDataType, StealthAddressStructure } from '../../types/circom-data.types';
+import { ExternalActionId } from '../../types/external-action.types';
+export declare const buildInNullifiers: (inputUtxos: Utxo[][], onChainCreation: boolean[]) => string[][];
+export declare const buildOutCommitments: (outputUtxos: Utxo[][], onChainCreation: boolean[]) => string[][];
+export declare const calcAmountChanges: (inputUtxos: Utxo[][], outputUtxos: Utxo[][], forCircomData?: boolean) => bigint[];
+export declare const calcEncryptedOutputs: (outputUtxos: Utxo[][], forceZeroAmount: boolean) => string[][];
+export declare const calcCommitmentsSiblingAndSides: (inputUtxos: Utxo[][], merkleTree: MerkleTree<bigint>) => {
+    inCommitmentSiblings: string[][][];
+    inCommitmentSiblingSides: string[][][];
+};
+export declare const calcAccessTokenSiblingsAndSides: (userKeys: UserKeys, merkleTreeAccessToken: MerkleTree<bigint>) => {
+    accessTokenSiblings: string[];
+    accessTokenSiblingSides: string[];
+};
+export declare const serializeCircomData: (circomData: CircomDataType) => CircomDataJsonType;
+export declare const deserializeCircomData: (circomData: CircomDataJsonType) => CircomDataJsonType;
+export declare const createCallDataHash: (publicSignalCount: number, relay: string, externalAddress: string | undefined, externalActionId: bigint | ExternalActionId, externalActionMetadata: string, encryptedOutputs: string[][], flatFees: bigint[], hookData: HookDataType | undefined) => bigint;
+export declare const calcPublicSignalCount: (verifierName: string, erc20TokenAddresses: string[], amountChanges: bigint[], inNullifiers: string[][], outCommitments: string[][], tokenIdsPositive: number) => number;
+export declare const calcStealthAddressStructure: (extraRandomization: bigint, privateKey: string) => StealthAddressStructure;

package/functions/snarkjs/constant.d.mts

@@ -0,0 +1,151 @@
+export declare const PROOF_GENERATION_EC2_URL = "https://enclave-server.hinkal.pro";
+export declare const prodVerifiers: (chainId: number) => {
+    swapperM1x2x1Zkey: string;
+    swapperM1x2x1Wasm: string;
+    swapperM1x6x1Zkey: string;
+    swapperM1x6x1Wasm: string;
+    swapperME1x2x1Zkey: string;
+    swapperME1x2x1Wasm: string;
+    swapperM2x2x1Zkey: string;
+    swapperM2x2x1Wasm: string;
+    swapperM2x6x1Zkey: string;
+    swapperM2x6x1Wasm: string;
+    swapperMO2x2x1Zkey: string;
+    swapperMO2x2x1Wasm: string;
+    swapperMO2x6x1Zkey: string;
+    swapperMO2x6x1Wasm: string;
+    swapperToken2x2x1Zkey: string;
+    swapperToken2x2x1Wasm: string;
+    swapperToken2x6x1Zkey: string;
+    swapperToken2x6x1Wasm: string;
+    swapperM3x2x1Zkey: string;
+    swapperM3x2x1Wasm: string;
+    swapperM3x6x1Zkey: string;
+    swapperM3x6x1Wasm: string;
+    swapperMO3x2x1Zkey: string;
+    swapperMO3x2x1Wasm: string;
+    swapperMO3x6x1Zkey: string;
+    swapperMO3x6x1Wasm: string;
+    swapperM4x2x1Zkey: string;
+    swapperM4x2x1Wasm: string;
+    swapperM4x6x1Zkey: string;
+    swapperM4x6x1Wasm: string;
+    swapperMO4x2x1Zkey: string;
+    swapperMO4x2x1Wasm: string;
+    swapperMO4x6x1Zkey: string;
+    swapperMO4x6x1Wasm: string;
+    swapperM5x2x1Zkey: string;
+    swapperM5x2x1Wasm: string;
+    swapperM5x6x1Zkey: string;
+    swapperM5x6x1Wasm: string;
+    swapperMO5x2x1Zkey: string;
+    swapperMO5x2x1Wasm: string;
+    swapperMO5x6x1Zkey: string;
+    swapperMO5x6x1Wasm: string;
+    swapperMTS2x2x1Zkey: string;
+    swapperMTS2x2x1Wasm: string;
+    transactionsProverZkey: string;
+    transactionsProverWasm: string;
+    stakeProverZkey: string;
+    stakeProverWasm: string;
+    stakeProverPermissionlessZkey: string;
+    stakeProverPermissionlessWasm: string;
+    swapperMW1x2Wasm: string;
+    swapperMW1x2Zkey: string;
+    swapperMW1x6Wasm: string;
+    swapperMW1x6Zkey: string;
+    swapperMW2x2Wasm: string;
+    swapperMW2x2Zkey: string;
+    swapperMW2x6Wasm: string;
+    swapperMW2x6Zkey: string;
+    swapperMW3x2Wasm: string;
+    swapperMW3x2Zkey: string;
+    swapperMW3x6Wasm: string;
+    swapperMW3x6Zkey: string;
+    swapperMW4x2Wasm: string;
+    swapperMW4x2Zkey: string;
+    swapperMW4x6Wasm: string;
+    swapperMW4x6Zkey: string;
+    swapperMW5x2Wasm: string;
+    swapperMW5x2Zkey: string;
+    swapperMW5x6Wasm: string;
+    swapperMW5x6Zkey: string;
+};
+export declare const localVerifiers: {
+    swapperM1x2x1Zkey: string;
+    swapperM1x2x1Wasm: string;
+    swapperM1x6x1Zkey: string;
+    swapperM1x6x1Wasm: string;
+    swapperMO1x2x1Zkey: string;
+    swapperMO1x2x1Wasm: string;
+    swapperMO1x6x1Zkey: string;
+    swapperMO1x6x1Wasm: string;
+    swapperME1x2x1Zkey: string;
+    swapperME1x2x1Wasm: string;
+    swapperM2x2x1Zkey: string;
+    swapperM2x2x1Wasm: string;
+    swapperM2x6x1Zkey: string;
+    swapperM2x6x1Wasm: string;
+    swapperMO2x2x1Zkey: string;
+    swapperMO2x2x1Wasm: string;
+    swapperMO2x6x1Zkey: string;
+    swapperMO2x6x1Wasm: string;
+    swapperToken2x2x1Zkey: string;
+    swapperToken2x2x1Wasm: string;
+    swapperToken2x6x1Zkey: string;
+    swapperToken2x6x1Wasm: string;
+    swapperM3x2x1Zkey: string;
+    swapperM3x2x1Wasm: string;
+    swapperM3x6x1Zkey: string;
+    swapperM3x6x1Wasm: string;
+    swapperMO3x2x1Zkey: string;
+    swapperMO3x2x1Wasm: string;
+    swapperMO3x6x1Zkey: string;
+    swapperMO3x6x1Wasm: string;
+    swapperM4x2x1Zkey: string;
+    swapperM4x2x1Wasm: string;
+    swapperM4x6x1Zkey: string;
+    swapperM4x6x1Wasm: string;
+    swapperMO4x2x1Zkey: string;
+    swapperMO4x2x1Wasm: string;
+    swapperMO4x6x1Zkey: string;
+    swapperMO4x6x1Wasm: string;
+    swapperM5x2x1Zkey: string;
+    swapperM5x2x1Wasm: string;
+    swapperM5x6x1Zkey: string;
+    swapperM5x6x1Wasm: string;
+    swapperMO5x2x1Zkey: string;
+    swapperMO5x2x1Wasm: string;
+    swapperMO5x6x1Zkey: string;
+    swapperMO5x6x1Wasm: string;
+    swapperMTS2x2x1Zkey: string;
+    swapperMTS2x2x1Wasm: string;
+    transactionsProverZkey: string;
+    transactionsProverWasm: string;
+    stakeProverZkey: string;
+    stakeProverWasm: string;
+    stakeProverPermissionlessZkey: string;
+    stakeProverPermissionlessWasm: string;
+    receiverZkey: string;
+    receiverWasm: string;
+    swapperMW1x2Wasm: string;
+    swapperMW1x2Zkey: string;
+    swapperMW1x6Wasm: string;
+    swapperMW1x6Zkey: string;
+    swapperMW2x2Wasm: string;
+    swapperMW2x2Zkey: string;
+    swapperMW2x6Wasm: string;
+    swapperMW2x6Zkey: string;
+    swapperMW3x2Wasm: string;
+    swapperMW3x2Zkey: string;
+    swapperMW3x6Wasm: string;
+    swapperMW3x6Zkey: string;
+    swapperMW4x2Wasm: string;
+    swapperMW4x2Zkey: string;
+    swapperMW4x6Wasm: string;
+    swapperMW4x6Zkey: string;
+    swapperMW5x2Wasm: string;
+    swapperMW5x2Zkey: string;
+    swapperMW5x6Wasm: string;
+    swapperMW5x6Zkey: string;
+};

package/functions/snarkjs/constructEmporiumProof.d.mts

@@ -0,0 +1,10 @@
+import { MerkleTree } from '../../data-structures/merkle-tree';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { CircomDataType, DimDataType } from '../../types/circom-data.types';
+export declare const constructEmporiumProof: (merkleTree: MerkleTree<bigint>, merkleTreeAccessToken: MerkleTree<bigint>, inputUtxos: Utxo[][], outputUtxos: Utxo[][], userKeys: UserKeys, tokenCount: number, inputCount: number, emporiumAddress: string, operations: string[], generateProofRemotely: boolean, relay?: string, chainId?: number, onChainCreation?: boolean[], flatFees?: bigint[], walletNonce?: bigint, volatileAmounts?: bigint[], volatileAction?: string) => Promise<{
+    zkCallData: import('../../index.ts').NewZkCallDataType;
+    circomData: CircomDataType;
+    dimData: DimDataType;
+    encryptedOutputs: string[][];
+}>;

package/functions/snarkjs/constructGeneralZkProof.d.mts

@@ -0,0 +1,12 @@
+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 { StakeArgs } from '../../types/hinkal.stake.types';
+export declare const constructZkProof: (merkleTree: MerkleTree<bigint>, merkleTreeAccessToken: MerkleTree<bigint>, inputUtxos: Utxo[][], outputUtxos: Utxo[][], userKeys: UserKeys, verifierName: string, externalActionId: ExternalActionId | 0n, externalAddress: string | undefined, externalActionMetadata: string, generateProofRemotely: boolean, relay?: string, chainId?: number, onChainCreation?: boolean[], flatFees?: bigint[], hookData?: HookDataType | undefined, stakeArgs?: StakeArgs, hasAccessToken?: boolean) => Promise<{
+    zkCallData: import('../../index.ts').NewZkCallDataType;
+    circomData: CircomDataType;
+    dimData: DimDataType;
+    encryptedOutputs: string[][];
+}>;

package/functions/snarkjs/generateCircomData.d.mts

@@ -0,0 +1,4 @@
+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: (rootHashHinkal: bigint | undefined, rootHashAccessToken: bigint | undefined, inputUtxos: Utxo[][], outputUtxos: Utxo[][], encryptedOutputs: string[][], flatFees: bigint[], publicSignalCount: number, externalActionId: ExternalActionId | bigint, externalAddress: string | undefined, externalActionMetadata: string, relay: string, calldataHash: bigint, tokenIds: number[], stealthAddressStructure: StealthAddressStructure, onChainCreation: boolean[], hookData: HookDataType | undefined) => Promise<CircomDataType>;

package/functions/snarkjs/generateZkProof.d.mts

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

package/functions/snarkjs/generateZkProofEnclave.d.mts

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

package/functions/snarkjs/generateZkProofSelf.d.mts

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

package/functions/snarkjs/getZKFiles.d.mts

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

package/functions/snarkjs/index.d.mts

@@ -0,0 +1,4 @@
+export * from './constructGeneralZkProof';
+export * from './constructEmporiumProof';
+export * from './common.snarkjs';
+export * from './generateZkProof';

package/functions/staking/index.d.mts

@@ -0,0 +1,11 @@
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+interface StakeDecryptOutput {
+    stakeBlinding: bigint;
+    stakedTokenRecipient: string;
+}
+export declare const encryptStake: (stakeBlinding: bigint, stakedTokenRecipient: string, encryptionKey: string) => string;
+export declare const decryptStake: (encryptedStakeCommitmentContent: string, minterKeys: UserKeys) => StakeDecryptOutput | undefined;
+export declare const createStakeCommitment: (isStake: boolean, stakedTokenRecipient: string, stakeBlinding: bigint, tokenAddress: string, amountChange: bigint, timeStamp: bigint) => bigint;
+export declare const calculateStakeNullifier: (stakeCommitment: bigint, blinding: bigint) => string;
+export declare const encodeHStakeMetadata: (action: 1 | 0, stakeCommitment: bigint, depositorAddress: string, encryptedContent: string, encryptedContentAlt: string) => string;
+export {};

package/functions/utils/amounts.utils.d.mts

@@ -0,0 +1,21 @@
+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;
+/** 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 bigintApplySugar(): void;
+export declare function bigintMax(...values: bigint[]): bigint;
+export declare function fixDecimalsAmount(n: 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 truncateTo18DecimalPlaces: (numStr: string) => string;
+/** 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;

package/functions/utils/axelar.utils.d.mts

@@ -0,0 +1,2 @@
+import { AxelarMigrationInfo, AxelarNetworkSelection } from '../../types';
+export declare const getAxelarMigrationInfo: (networkSelection: AxelarNetworkSelection) => AxelarMigrationInfo | undefined;

package/functions/utils/cacheDevice.utils.d.mts

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

package/functions/utils/cacheFunctions.d.mts

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

package/functions/utils/caseInsensitive.utils.d.mts

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

package/functions/utils/convertIntegrationProviderToExternalActionId.d.mts

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

package/functions/utils/create-provider.d.mts

@@ -0,0 +1,2 @@
+import { ethers } from 'ethers';
+export declare const createProvider: (rpcUrl: string) => ethers.providers.JsonRpcProvider;

package/functions/utils/enum.utils.d.mts

@@ -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;

package/functions/utils/erc20tokenFunctions.d.mts

@@ -0,0 +1,4 @@
+import { ERC20Token } from '../../types/token.types';
+export declare const getERC20Token: (address: string, chainId: number) => ERC20Token | undefined;
+export declare const getERC20TokenBySymbol: (symbol: string, chainId: number) => ERC20Token | undefined;
+export declare const getHToken: (token: ERC20Token, chainId: number) => ERC20Token | undefined;

package/functions/utils/evmNetworkFunctions.d.mts

@@ -0,0 +1,4 @@
+import { EthereumNetworkType } from '../../constants';
+import { EthereumNetwork } from '../../types';
+export declare const getNetworkObject: (chainId: number) => EthereumNetwork;
+export declare const getNetworkType: (network: EthereumNetwork) => EthereumNetworkType;

package/functions/utils/external-action.utils.d.mts

@@ -0,0 +1,8 @@
+import { ethers } from 'ethers';
+import { ExternalActionId } from '../../types/external-action.types';
+import { CircomDataJsonType } from '../../types/circom-data.types';
+export declare const getExternalActionIdHash: (externalActionId: ExternalActionId | 0n) => bigint;
+export declare const getExternalActionIdFromNumber: (externalActionIdNumber: string | bigint) => ExternalActionId | undefined;
+export declare const getActionFromMetadata: (externalActionId: ExternalActionId, circomDataDeserialized: Partial<CircomDataJsonType>) => number | undefined;
+export declare const decodeMetadata: (externalActionId: ExternalActionId, externalActionMetadata: string) => ethers.utils.Result;
+export declare const getExternalMetadataHash: (externalMetadataBuffer: string) => bigint;

package/functions/utils/getDataFromTransaction.d.mts

@@ -0,0 +1,45 @@
+import { BigNumber, utils } from 'ethers';
+import { DecodedTx, DecodedTxWithUtxos } from '../../types';
+export declare const decodeTxInput: (iface: utils.Interface, input: string) => {
+    erc20TokenAddresses: string[];
+    amountChanges: BigNumber[];
+    flatFees: BigNumber[];
+    externalActionId: BigNumber;
+    externalActionMetadata: string;
+    encryptedOutputs: string[];
+    hookData: import('../../types/circom-data.types').HookDataType;
+    stealthAddressStructure: import('../../types/circom-data.types').StealthAddressStructure<bigint>;
+};
+export declare const decodeTxLogs: (chainId: number, transactions: DecodedTx[]) => DecodedTxWithUtxos<bigint, BigNumber>[];
+export declare const deserializeDecodedTxs: (decodedTx: DecodedTxWithUtxos<string, string>) => DecodedTxWithUtxos;
+export declare const serializeDecodedTxs: (decodedTxs: DecodedTx[]) => {
+    input: string;
+    decodedInput: {
+        amountChanges: string[];
+        flatFees: string[];
+        externalActionId: string;
+        stealthAddressStructure: {
+            extraRandomization: string;
+            stealthAddress: string;
+            H0: string;
+            H1: string;
+        };
+        erc20TokenAddresses: string[];
+        externalActionMetadata: string;
+        encryptedOutputs: string[];
+        hookData: import('../../types/circom-data.types').HookDataType;
+    };
+    status: string;
+    blockNumber: number;
+    timeStamp: number;
+    isError: string;
+    methodId: string;
+    logs: {
+        topics: string[];
+        data: string;
+    }[];
+    hash: string;
+    gas: number;
+    gasPrice: number;
+    contract?: string | undefined;
+}[];