@hinkal/common 0.2.10 → 0.2.11

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;
+}[];

package/functions/utils/index.d.mts

@@ -0,0 +1,21 @@
+export * from './amounts.utils';
+export * from './cacheFunctions';
+export * from './create-provider';
+export * from './external-action.utils';
+export * from './erc20tokenFunctions';
+export * from './requireEnv';
+export * from './resolve-sync.utils';
+export * from './convertIntegrationProviderToExternalActionId';
+export * from '../pre-transaction';
+export * from './evmNetworkFunctions';
+export * from './axelar.utils';
+export * from './userAgent';
+export * from './getDataFromTransaction';
+export * from './reloadPage';
+export * from './string.utils';
+export * from './nickname.utils';
+export * from './caseInsensitive.utils';
+export * from './time.utils';
+export * from './volatile-patcher.utils';
+export * from './cacheDevice.utils';
+export * from './process.utils';

package/functions/utils/memoize.utils.d.mts

@@ -0,0 +1 @@
+export declare const memoizeFunc: <T extends any[], R>(fn: (...args: T) => R) => (...args: T) => R;

package/functions/utils/nickname.utils.d.mts

@@ -0,0 +1 @@
+export declare const isNicknameValid: (input: string) => boolean;

package/functions/utils/process.utils.d.mts

@@ -0,0 +1,7 @@
+/** pause execution for a number of miliseconds */
+export declare const wait: (miliseconds: number) => Promise<unknown>;
+/** only call function once with a given number of milliseconds
+ * Ex: let debounceMyFunc = debounce(myFunc, 1000);
+ * debounceMyFunc(); debounceMyFunc();
+ */
+export declare function debounce(func: (...args: any[]) => void, debounceForMs: number): (...args: any[]) => void;

package/functions/utils/reloadPage.d.mts

@@ -0,0 +1 @@
+export declare const reloadPage: () => void;

package/functions/utils/requireEnv.d.mts

@@ -0,0 +1 @@
+export declare const requireEnv: (environmentVariableName: string) => string;

package/functions/utils/resolve-sync.utils.d.mts

@@ -0,0 +1,6 @@
+export declare const resolveSync: (promiseFns: (() => Promise<any>)[]) => Promise<void>;
+export declare const getSequence: (fromBlockNumber: number, lastBlockNumber: number, maxPageSize: number | undefined) => {
+    from: number;
+    to: number;
+}[];
+export declare const promisify: (callback: () => Promise<any>, timeout?: number) => Promise<unknown>;

package/functions/utils/serialize.utils.d.mts

@@ -0,0 +1 @@
+export declare const CustomJSONStringify: (args: any) => string;

package/functions/utils/string.utils.d.mts

@@ -0,0 +1,8 @@
+/** Capitalize the first letter of each word
+ * "This is an example" => "This Is An Example"
+ */
+export declare function toTitleCase(str: string): string;
+/** Capitalize the first letter of a string */
+export declare function capitalizeFirstLetter(str: string): string;
+/** Returns true if a value is null, undefined, or an empty object, array (length 0), or string (e.g. '') */
+export declare function isNullOrEmpty(obj: unknown): boolean;

package/functions/utils/time.utils.d.mts

@@ -0,0 +1 @@
+export declare const waitLittle: (time?: number) => Promise<unknown>;

package/functions/utils/userAgent.d.mts

@@ -0,0 +1,2 @@
+export declare const browserSupported: () => boolean;
+export declare const walletSupported: (provider: any) => boolean;

package/functions/utils/volatile-patcher.utils.d.mts

@@ -0,0 +1 @@
+export declare const patchRegistry: (chainId: number) => Promise<void>;

package/functions/web3/etherFunctions.d.mts

@@ -0,0 +1,20 @@
+import { ERC20Token } from '../../types/token.types';
+export declare const ethToWei: (amount: string) => bigint;
+export declare const randomBigInt: (numberfOfBytes: number) => bigint;
+export declare const getAmountInToken: (token: ERC20Token, amount: bigint) => string;
+export declare const getAmountInWei: (token: ERC20Token, amount: string) => bigint;
+/**
+ * Convert a decimal number into bigint through string method and return a bigint and number of decimal places.
+ * @param decimal
+ * @returns a tuple of [ theBigInt, numberOfDecimalPlaces]
+ */
+export declare const toBigIntWithDecimals: (decimal: number) => [bigint, number];
+/** Return getAmountInWei or 0 if error */
+export declare const getAmountInWeiOrZero: (token: ERC20Token, amount: string) => bigint;
+export declare const getAmountWithPrecision: (balance: bigint, token: ERC20Token, precision: number) => string;
+export declare const calculateDollarValue: (token: ERC20Token, tokenAmount: bigint, tokenPriceDollar: number, precision: number) => {
+    totalValueDollarsBigInt: bigint;
+    precision: number;
+};
+/** Returns same as getAmountWithPrecision but '0' if empty */
+export declare const getAmountWithPrecisionOrZero: (token: ERC20Token | undefined, amount: bigint | undefined) => string;

package/functions/web3/events/balanceChangedHandler.d.mts

@@ -0,0 +1 @@
+export declare const balanceChangedHandler: () => void;

package/functions/web3/events/getInputUtxoAndBalance.d.mts

@@ -0,0 +1,24 @@
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { UserKeys } from '../../../data-structures/crypto-keys/keys';
+import { Utxo } from '../../../data-structures/utxo/Utxo';
+import { EncryptedOutputWithSign } from '../../../types/commitments.types';
+interface IGetInputUtxos {
+    hinkal: IHinkal;
+    erc20TokenAddress?: string;
+    minInput?: number;
+    sliceIfMore6?: boolean;
+    tokenId?: number;
+}
+export declare const getInputUtxosFromEncryptedOutputs: (hinkal: IHinkal, encryptedOutputs: EncryptedOutputWithSign[], userKeys: UserKeys, erc20TokenAddress?: string, tokenId?: number) => Promise<Utxo[]>;
+/**
+ *
+ * @param hinkal instance of the hinkal class
+ * @param erc20TokenAddress erc20 token address
+ * @param minInput min number of input UTXOs
+ * @param sliceIfMore6 max upper bound on input UTXOs controller
+ * @returns UTXOs for particular erc20 token address
+ */
+export declare const getInputUtxoAndBalance: ({ hinkal, erc20TokenAddress, minInput, sliceIfMore6, tokenId, }: IGetInputUtxos) => Promise<{
+    inputUtxos: Utxo[];
+}>;
+export {};

package/functions/web3/events/getShieldedBalance.d.mts

@@ -0,0 +1,18 @@
+import { TokenBalance } from '../../../types/token.types';
+import { Utxo } from '../../../data-structures/utxo/Utxo';
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+/**
+ *
+ * @param UserKeys to access user's encryption keys
+ * @returns shielded balance
+ */
+export declare const getShieldedBalance: (hinkal: IHinkal) => Promise<TokenBalance[]>;
+/**
+ *
+ * @param hinkal hinkal instance to get userKeys
+ * @param erc20Addresses array of erc20 tokens
+ * @param amountChanges array of token amounts
+ * @param maxInput to pad until maxInput number
+ * @returns return padded UTXOs for every erc20 token
+ */
+export declare const addPaddingToUtxos: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], maxInput?: number, tokenIds?: number[], forceEmptyUtxos?: boolean) => Promise<Utxo[][]>;

package/functions/web3/events/index.d.mts

@@ -0,0 +1,4 @@
+export * from './getInputUtxoAndBalance';
+export * from './getShieldedBalance';
+export * from './web3RetrieveEvents';
+export * from './balanceChangedHandler';

package/functions/web3/events/web3RetrieveEvents.d.mts

@@ -0,0 +1,14 @@
+import { Contract, ethers } from 'ethers';
+/**
+ * to get contract events
+ * @param eventName to retrieve specific events
+ * @param eventArgs event arguments
+ * @returns array of the specific events
+ */
+export declare const retrieveEvents: (hinkalContract: ethers.Contract, eventName: string, ...eventArgs: unknown[]) => Promise<ethers.Event[]>;
+/**
+ *
+ * @param web3Provider instance to get hinkal contract
+ * @returns array of deposit timestamps in JS new Date format
+ */
+export declare const getDepositEvents: (hinkalContract: Contract, erc20TokenAddress: string) => Promise<Date[]>;

package/functions/web3/functionCalls/accessTokenCalls.d.mts

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers';
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { AxelarMigrationInfo, SignatureData } from '../../../types';
+export declare const checkHinkalAccessToken: (hinkal: IHinkal) => Promise<any>;
+export declare const mintAccessToken: (hinkal: IHinkal, signatureData: SignatureData) => Promise<ethers.ContractTransaction>;
+export declare const mintTokenCrossChain: (hinkal: IHinkal, signatureData: SignatureData, axelarMigrationInfos: AxelarMigrationInfo[]) => Promise<ethers.ContractTransaction>;

package/functions/web3/functionCalls/approveToken.d.mts

@@ -0,0 +1,4 @@
+import { ethers } from 'ethers';
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { ERC20Token } from '../../../types/token.types';
+export declare const approveTokenToHinkal: (hinkal: IHinkal, contractToApprove: ethers.Contract, amount: bigint, token: ERC20Token) => Promise<Uint8Array | undefined>;

package/functions/web3/functionCalls/estimateGasRelayer.d.mts

@@ -0,0 +1,4 @@
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { CircomDataType, DimDataType } from '../../../types/circom-data.types';
+import { NewZkCallDataType } from '../../../types/snark.types';
+export declare const estimateGasRelayer: (hinkal: IHinkal, newZkCallData: NewZkCallDataType, dimData: DimDataType, circomData: CircomDataType) => Promise<bigint>;

package/functions/web3/functionCalls/getRootHash.d.mts

@@ -0,0 +1,2 @@
+import { Contract } from 'ethers';
+export declare const getRootHash: (merkleTreeContract: Contract) => Promise<bigint>;

package/functions/web3/functionCalls/relayFunctions.d.mts

@@ -0,0 +1,17 @@
+import { ethers } from 'ethers';
+export interface RelayEntryData {
+    relayAddress: string;
+    url: string;
+    priority: number;
+}
+export interface RelayEntryWithIndex extends RelayEntryData {
+    lowerIndex: number;
+}
+export declare const getRelayPercentage: (contract: ethers.Contract) => Promise<bigint>;
+export declare const chooseRandomRelay: (entries: RelayEntryData[]) => {
+    lowerIndex: number;
+    relayAddress: string;
+    url: string;
+    priority: number;
+};
+export declare const getRelay: (hinkalHelperContract: ethers.Contract) => Promise<RelayEntryWithIndex>;

package/functions/web3/functionCalls/transactCallDirect.d.mts

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers';
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { CircomDataType, DimDataType } from '../../../types/circom-data.types';
+import { ERC20Token } from '../../../types/token.types';
+import { NewZkCallDataType } from '../../../types/snark.types';
+export declare const transactCallDirect: (hinkal: IHinkal, amount: bigint, tokenToApprove: ERC20Token, newZkCallData: NewZkCallDataType, circomData: CircomDataType, dimData: DimDataType, contractApproval?: ethers.Contract, contractTransaction?: ethers.Contract, hasAccessToken?: boolean) => Promise<any>;

package/functions/web3/functionCalls/transactCallRelayer.d.mts

@@ -0,0 +1,7 @@
+import { CircomDataType, DimDataType, NewZkCallDataType, RelayerTransaction } from '../../../types';
+export interface RelayerResponseInterface {
+    status: string;
+    message: RelayerTransaction;
+    error?: string;
+}
+export declare const transactCallRelayer: (chainId: number, newZkCallData: NewZkCallDataType, dimData: DimDataType, circomData: CircomDataType, withPrivateMempool?: boolean) => Promise<RelayerTransaction>;

package/functions/web3/getContractMetadata.d.mts

@@ -0,0 +1,5 @@
+import { ContractMetadata, ContractType } from '../../types/ethereum-network.types';
+import { ethers } from 'ethers';
+export declare const getContractMetadata: (contractType: ContractType, chainId: number) => ContractMetadata;
+export declare const getContract: (contractType: ContractType, chainId: number, contractAddress?: string) => ethers.Contract;
+export declare const getContractWithFetcherByChainId: (chainId: number, contractType: ContractType, contractAddress?: undefined) => ethers.Contract;

package/functions/web3/index.d.mts

@@ -0,0 +1,6 @@
+export * from './etherFunctions';
+export * from './events';
+export * from './uniswapAPI';
+export * from './odosAPI';
+export * from './oneInchAPI';
+export * from './runContractFunction';

package/functions/web3/odosAPI.d.mts

@@ -0,0 +1,5 @@
+import { ERC20Token } from '../../types';
+export declare const getOdosPrice: (chainId: number, inSwapToken: ERC20Token, outSwapToken: ERC20Token, inSwapAmount: string) => Promise<{
+    outSwapAmountValue: bigint;
+    odosDataValue: string;
+}>;

package/functions/web3/oneInchAPI.d.mts

@@ -0,0 +1,5 @@
+import { ERC20Token } from '../../types';
+export declare const getOneInchPrice: (chainId: number, inSwapToken: ERC20Token, outSwapToken: ERC20Token, inSwapAmount: string) => Promise<{
+    outSwapAmountValue: bigint;
+    oneInchDataValue: string;
+}>;