@gurge/sdk 0.3.5 → 0.3.8

package/common/src/functions/web3/events/getInputUtxoAndBalance.d.ts

@@ -0,0 +1,38 @@
+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';
+import { TokenWithId } from '../../../types/token-with-id.types';
+interface IGetInputUtxos {
+    hinkal: IHinkal;
+    chainId: number;
+    tokenWithId?: TokenWithId | TokenWithId[];
+    minInput?: number;
+    sliceIfMore6?: boolean;
+    tokenId?: number;
+    passedShieldedPrivateKey?: string;
+    passedShieldedPublicKey?: string;
+    ethAddress?: string;
+    resetCacheBefore?: boolean;
+    allowRemoteDecryption?: boolean;
+    ensuredTokensWithId?: TokenWithId[];
+    useBlockedUtxos?: boolean;
+}
+export declare const getInputUtxosRemotely: (hinkal: IHinkal, userKeys: UserKeys, currentChainId: number, shieldedPublicKey: string) => Promise<Utxo[]>;
+export declare const attemptGetInputUtxosRemotely: (hinkal: IHinkal, userKeys: UserKeys, currentChainId: number, ethereumAddress: string, shieldedPublicKey: string, hinkalOutputs: EncryptedOutputWithSign<boolean>[], cachedEncryptedOutputs: EncryptedOutputWithSign<boolean>[], lastOutput: string, lastOutputIndex: 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, chainId, passedShieldedPublicKey, ethAddress, resetCacheBefore, allowRemoteDecryption, useBlockedUtxos, }: IGetInputUtxos) => Promise<{
+    inputUtxos: Utxo[];
+}>;
+export declare const getInputUtxoAndBalanceOfStuckUtxos: ({ hinkal, chainId, passedShieldedPublicKey, ethAddress, resetCacheBefore, allowRemoteDecryption, }: IGetInputUtxos) => Promise<{
+    inputUtxos: Utxo[];
+}>;
+export declare const getInputUtxoAndBalancePerToken: ({ hinkal, tokenWithId, minInput, sliceIfMore6, chainId, passedShieldedPrivateKey, passedShieldedPublicKey, ethAddress, resetCacheBefore, ensuredTokensWithId, allowRemoteDecryption, useBlockedUtxos, }: IGetInputUtxos) => Promise<Map<string, Utxo[]>>;
+export {};

package/common/src/functions/web3/events/getInputUtxosEnclave.d.ts

@@ -0,0 +1,9 @@
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { Utxo } from '../../../data-structures/utxo/Utxo';
+import { UserKeys } from '../../../data-structures/crypto-keys/keys';
+import { EncryptedOutputWithSign } from '../../../types/commitments.types';
+export declare const getInputUtxosEnclave: (hinkal: IHinkal, chainId: number, userKeys: UserKeys) => Promise<{
+    utxos: Utxo[];
+    encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+    lastOutput: string;
+}>;

package/common/src/functions/web3/events/getShieldedBalance.d.ts

@@ -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, chainId: number, passedShieldedPrivateKey: string, passedShieldedPublicKey: string, ethAddress: string, resetCacheBefore?: boolean, allowRemoteDecryption?: boolean, updateTokensListBefore?: boolean, useBlockedUtxos?: boolean) => Promise<Map<string, 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, chainId: number, erc20Addresses: string[], amountChanges: bigint[], maxInput?: number, tokenIds?: number[], forceEmptyUtxos?: boolean, useBlockedUtxos?: boolean) => Promise<Utxo[][]>;

package/common/src/functions/web3/events/getTransactionLogEvents.d.ts

@@ -0,0 +1,13 @@
+import { ethers } from 'ethers';
+type ABIType = ConstructorParameters<typeof ethers.Interface>[0];
+export declare function getTransactionLogEvents(chainId: number, txHash: string, contractAddress: string, contractABI: ABIType): Promise<{
+    transactionHash: string;
+    from: string;
+    to: string | null;
+    blockNumber: number;
+    events: {
+        name: string;
+        args: ethers.Result;
+    }[];
+}>;
+export {};

package/common/src/functions/web3/events/index.d.ts

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

package/common/src/functions/web3/fetchSolanaMerkleTreeRootHash.d.ts

@@ -0,0 +1,3 @@
+import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+export declare const fetchSolanaMerkleTreeRootHash: (hinkalProgram: Program, merkleTreePublicKey: PublicKey) => Promise<bigint>;

package/common/src/functions/web3/functionCalls/approveToken.d.ts

@@ -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, chainId: number, contractToApprove: ethers.Contract, amount: bigint, token: ERC20Token) => Promise<Uint8Array | undefined>;

package/common/src/functions/web3/functionCalls/approveTokensToHinkal.d.ts

@@ -0,0 +1,4 @@
+import { ethers } from 'ethers';
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { ERC20Token } from '../../../types/token.types';
+export declare const approveTokensToHinkal: (hinkal: IHinkal, chainId: number, contractForApproval: ethers.Contract, tokensToApprove: ERC20Token[], amounts: bigint[]) => Promise<void>;

package/common/src/functions/web3/functionCalls/constructBatchCall.d.ts

@@ -0,0 +1,7 @@
+import { ethers } from 'ethers';
+import { CircomDataType, DimDataType, StealthAddressStructure } from '../../../types/circom-data.types';
+import { NewZkCallDataType } from '../../../types/snark.types';
+import { Call } from '../../../types/eip5792.types';
+export declare const buildApproveAndTransactCalls: (tokenAddresses: string[], amounts: bigint[], spenderAddress: string, contractForTransaction: ethers.Contract, zkCallData: NewZkCallDataType, dimData: DimDataType, circomData: CircomDataType, ethValue: bigint) => Call[];
+export declare const buildApproveAndDepositWrapperCalls: (tokenAddresses: string[], amounts: bigint[], wrapperAddress: string, wrapperInterface: ethers.Interface, feeRecipient: string, feeToken: string, feeAmount: bigint, depositErc20Addresses: string[], depositAmounts: bigint[], depositTokenIds: bigint[], stealthAddressStructures: StealthAddressStructure[], ethValue: bigint) => Call[];
+export declare const buildApproveAndProoflessDepositCalls: (tokenAddresses: string[], amounts: bigint[], spenderAddress: string, contractForTransaction: ethers.Contract, prooflessDepositTokenAddresses: string[], prooflessDepositAmountChanges: bigint[], prooflessDepositTokenIds: bigint[], stealthAddressStructures: StealthAddressStructure[], ethValue: bigint) => Call[];

package/common/src/functions/web3/functionCalls/estimateGasRelayer.d.ts

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

package/common/src/functions/web3/functionCalls/getRootHash.d.ts

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

package/common/src/functions/web3/functionCalls/recoverTransactionFromError.d.ts

@@ -0,0 +1,2 @@
+import { ethers } from 'ethers';
+export declare const recoverTransactionFromError: (provider: ethers.Provider, transactionHash: string, confirmations?: number) => Promise<ethers.TransactionResponse | undefined>;

package/common/src/functions/web3/functionCalls/relayFunctions.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+export declare const getRelayPercentage: (contract: ethers.Contract) => Promise<bigint>;
+export declare const getRelay: (hinkalHelperContract: ethers.Contract) => Promise<string>;

package/common/src/functions/web3/functionCalls/transactCallDirect.d.ts

@@ -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, chainId: number, amount: bigint | bigint[], tokenToApprove: ERC20Token | ERC20Token[], newZkCallData: NewZkCallDataType, circomData: CircomDataType, dimData: DimDataType, contractApproval?: ethers.Contract, contractTransaction?: ethers.Contract, preEstimateGas?: boolean, returnTxData?: boolean) => Promise<ethers.TransactionResponse | ethers.TransactionRequest>;

package/common/src/functions/web3/functionCalls/transactCallDirectTron.d.ts

@@ -0,0 +1,12 @@
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { createTronCallData } from '../../utils/tron.utils';
+import { CircomDataType, DimDataType } from '../../../types/circom-data.types';
+import { NewZkCallDataType } from '../../../types/snark.types';
+import { ERC20Token } from '../../../types/token.types';
+import { Types as TronWebTypes } from 'tronweb';
+export declare const transactCallDirectTron: (hinkal: IHinkal, chainId: number, amount: bigint | bigint[], tokenToApprove: ERC20Token | ERC20Token[], // in hex format
+newZkCallData: NewZkCallDataType, circomData: CircomDataType, dimData: DimDataType, contractApproval?: TronWebTypes.ContractInstance<any>, // in base58 format
+contractTransaction?: TronWebTypes.ContractInstance<any>, // in base58 format
+preEstimateGas?: boolean) => Promise<string>;
+/** Builds an unsigned Tron `transact` transaction (no approve/send). Used for PAL / deposit-and-withdraw prepare flows. */
+export declare const buildTronUnsignedTransactTransaction: (hinkal: IHinkal, chainId: number, amount: bigint, token: ERC20Token, newZkCallData: NewZkCallDataType, circomData: CircomDataType, dimData: DimDataType, contractAddressHex: string, contractAbi: Parameters<typeof createTronCallData>[0]) => Promise<TronWebTypes.Transaction>;

package/common/src/functions/web3/functionCalls/transactCallRelayer.d.ts

@@ -0,0 +1,37 @@
+import { AdminDataType, AuthorizationData, CircomDataType, CommitmentValidationDataType, DimDataType, NewZkCallDataType } from '../../../types';
+import { SolanaTransactionBody } from '../../../types/solana.types';
+export interface RelayerResponseInterface {
+    status: string;
+    message: string;
+    error?: string;
+}
+export declare const transactCallRelayer: (chainId: number, newZkCallData: NewZkCallDataType, dimData: DimDataType, circomData: CircomDataType, commitmentValidationData?: CommitmentValidationDataType, withUniswapWorkAround?: boolean, authorizationData?: AuthorizationData, adminData?: AdminDataType, tronProofSignature?: {
+    v: number;
+    r: string;
+    s: string;
+}) => Promise<string>;
+export declare const solanaTransactCallRelayer: (body: SolanaTransactionBody) => Promise<string>;
+export interface RelayerBatchResponseInterface {
+    status: string;
+    message: {
+        scheduleId: string;
+    };
+    error?: string;
+}
+export interface BatchTransactionParams {
+    zkCallData: NewZkCallDataType;
+    dimData: DimDataType;
+    circomData: CircomDataType;
+    commitmentValidationData?: CommitmentValidationDataType;
+    withUniswapWorkAround?: boolean;
+    authorizationData?: AuthorizationData;
+    adminData?: AdminDataType;
+    recipientAddress?: string;
+    tronProofSignature?: {
+        v: number;
+        r: string;
+        s: string;
+    };
+}
+export declare const transactCallRelayerBatch: (chainId: number, transactions: BatchTransactionParams[], hashedEthereumAddress: string, txCompletionTime?: number, ref?: string, hashedDashboardAccountId?: string) => Promise<string>;
+export declare const solanaTransactCallRelayerBatch: (chainId: number, transactions: SolanaTransactionBody[], hashedEthereumAddress: string, txCompletionTime?: number, ref?: string, hashedDashboardAccountId?: string) => Promise<string>;

package/common/src/functions/web3/functionCalls/waitForErc20Approvals.d.ts

@@ -0,0 +1,11 @@
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { TronWeb } from 'tronweb';
+type ApprovalRequirement = {
+    tokenAddress: string;
+    requiredAmount: bigint;
+};
+export declare const waitForErc20Approvals: (hinkal: IHinkal, chainId: number, ownerAddress: string, spenderAddress: string, requirements: ApprovalRequirement[], maxAttempts?: number, intervalMs?: number) => Promise<void>;
+export declare const waitForTronErc20Approvals: (tronWeb: TronWeb, ownerAddress: string, // Tron base58 owner address
+spenderAddress: string, // Tron base58 spender address
+requirements: ApprovalRequirement[], maxAttempts?: number, intervalMs?: number) => Promise<void>;
+export {};

package/common/src/functions/web3/getContractMetadata.d.ts

@@ -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, runner?: ethers.ContractRunner) => ethers.Contract;
+export declare const getContractWithFetcherByChainId: (chainId: number, contractType: ContractType, contractAddress?: string | undefined) => ethers.Contract;

package/common/src/functions/web3/getPublicAddressBalance.d.ts

@@ -0,0 +1,2 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+export declare const getPublicAddressBalance: (hinkal: IHinkal, chainId: number, tokenAddress: string, ethereumAddress: string) => Promise<bigint>;

package/common/src/functions/web3/getSolanaPriorityFee.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey } from '@solana/web3.js';
+import { SolanaPriorityFeeMode } from '../../types/fee.types';
+export declare const getSolanaPriorityFee: (accounts: PublicKey[], priorityFeeMode?: SolanaPriorityFeeMode) => Promise<number>;

package/common/src/functions/web3/getTokenHolder.d.ts

@@ -0,0 +1 @@
+export declare const getTokenHolder: (chainId: number, tokenAddress: string) => Promise<string | undefined>;

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

@@ -0,0 +1,14 @@
+export * from './etherFunctions';
+export * from './events';
+export * from './uniswapAPI';
+export * from './odosAPI';
+export * from './oneInchAPI';
+export * from './lifiAPI';
+export * from './okxAPI';
+export * from './runContractFunction';
+export * from './getTokenHolder';
+export * from './EIP-712';
+export * from './signAndSendSerializedTransaction';
+export * from './connectors.utils';
+export * from './crypto';
+export * from './getSolanaPriorityFee';

package/common/src/functions/web3/lifiAPI.d.ts

@@ -0,0 +1,6 @@
+import { ERC20Token } from '../../types/token.types';
+export declare const getLifiPrice: (inSwapToken: ERC20Token, outSwapToken: ERC20Token, inSwapAmount: string, bridgingSlippage: number, fromAddress: string, toAddress?: string) => Promise<{
+    lifiDataValue: string;
+    outSwapAmountValue: bigint;
+    extraNativeTokenFee: bigint;
+}>;

package/common/src/functions/web3/odosAPI.d.ts

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

package/common/src/functions/web3/okxAPI.d.ts

@@ -0,0 +1,8 @@
+import { PublicKey } from '@solana/web3.js';
+import { ERC20Token } from '../../types';
+import { OKXQuote } from '../../types/okx.types';
+export declare const createOKXQuote: (fromTokenAddress: PublicKey, toTokenAddress: PublicKey, amount: bigint, userWalletAddress: string, slippagePercent?: number) => OKXQuote;
+export declare const getOKXPrice: (chainId: number, inSwapToken: ERC20Token, outSwapToken: ERC20Token, inSwapAmount: string, slippagePercentage?: number, proxyWalletAddress?: string, isProxyEnvironment?: boolean) => Promise<{
+    outSwapAmountValue: bigint;
+    okxDataValue: string;
+}>;

package/common/src/functions/web3/oneInchAPI.d.ts

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

package/common/src/functions/web3/runContractFunction.d.ts

@@ -0,0 +1,16 @@
+import { ethers } from 'ethers';
+interface IRunTransaction {
+    provider: ethers.Provider;
+    contractFunction: ethers.ContractMethod;
+    args: unknown[];
+    gasLimit?: number;
+    gasPrice?: bigint;
+    confirmations?: number;
+    waitTime?: number;
+    nonce?: number;
+}
+interface IRunContractFunction extends IRunTransaction {
+    provider: ethers.Provider;
+}
+export declare const runContractFunction: ({ provider, contractFunction, args, gasLimit, nonce, confirmations, }: IRunContractFunction) => Promise<ethers.TransactionReceipt>;
+export {};

package/common/src/functions/web3/signAndSendSerializedTransaction.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '@coral-xyz/anchor';
+export declare const signAndSendSerializedTransaction: (provider: Provider, serializedTransaction: string, blockhash: string, lastValidBlockHeight: number) => Promise<string>;

package/common/src/functions/web3/uniswapAPI.d.ts

@@ -0,0 +1,16 @@
+import { ethers } from 'ethers';
+import { ERC20Token } from '../../types';
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+interface PoolAndFee {
+    poolAddress: string;
+    fee: number;
+    token1Balance: bigint;
+}
+export declare const searchPoolAndFee: (token1Contract: ethers.Contract, factory: ethers.Contract, token0Address: string, token1Address: string) => Promise<PoolAndFee>;
+export declare const getUniswapPriceHelper: (hinkal: IHinkal, chainId: number, token0: ERC20Token, token1: ERC20Token, fee: number, inSwapAmount: bigint) => Promise<bigint>;
+export declare const getUniswapFee: (hinkal: IHinkal, chainId: number, token0: ERC20Token, token1: ERC20Token) => Promise<number>;
+export declare const getUniswapPrice: (hinkal: IHinkal, chainId: number, inSwapAmount: string, inSwapToken: ERC20Token, outSwapToken: ERC20Token) => Promise<{
+    tokenPrice: bigint;
+    poolFee: string;
+}>;
+export {};

package/common/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from './API';
+export * from './constants';
+export * from './crypto';
+export * from './data-structures';
+export * from './error-handling';
+export * from './externalABIs';
+export * from './functions';
+export * from './types';
+export * from './mutexes';

package/common/src/mutexes/index.d.ts

@@ -0,0 +1 @@
+export * from './mutex';

package/common/src/mutexes/mutex.d.ts

@@ -0,0 +1,2 @@
+import { Mutex } from 'async-mutex';
+export declare const resetStateMutex: Mutex;

package/common/src/providers/EthersProviderAdapter.d.ts

@@ -0,0 +1,36 @@
+import { ChainEventListener, IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+import { ContractType, EthereumNetwork } from '../types/ethereum-network.types';
+import { ethers } from 'ethers';
+export declare class EthersProviderAdapter implements IProviderAdapter<ethers.Signer> {
+    private signer;
+    private chainId;
+    private fetchProviders;
+    protected chainEventListener?: ChainEventListener;
+    constructor();
+    initConnector(): void;
+    initSigner(signer: ethers.Signer): void;
+    init(chainId?: number): Promise<void>;
+    disconnectFromConnector(): Promise<void>;
+    connectToConnector(): Promise<number>;
+    waitForTransaction(chainId: number, transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    switchNetwork(network: EthereumNetwork): Promise<void>;
+    getAddress(): Promise<string>;
+    setChainEventListener(chainEventListener: ChainEventListener): void;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<unknown>;
+    release(): void;
+    private removeListeners;
+    getContract(chainId: number, contractType: ContractType, contractAddress?: undefined, runner?: ethers.ContractRunner): ethers.Contract;
+    getContractWithSigner(chainId: number, contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcher(chainId: number, contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    sendTransaction(tx: ethers.TransactionRequest): Promise<ethers.TransactionResponse>;
+    connectAndPatchProvider(): Promise<number>;
+    getChainId(): number | undefined;
+    isPermitterAvailable(): boolean;
+    getGasPrice(chainId: number): Promise<bigint>;
+}
+export declare const ethersProvierAdapter: EthersProviderAdapter;
+declare const _default: <T = unknown>() => IProviderAdapter<T>;
+export default _default;

package/common/src/providers/SolanaProviderAdapter.d.ts

@@ -0,0 +1,52 @@
+import { Connection, PublicKey, Transaction } from '@solana/web3.js';
+import { ChainEventListener, IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+import { ContractType, EthereumNetwork } from '../types/ethereum-network.types';
+import { ethers } from 'ethers';
+import { AnchorProvider, Idl, Program } from '@coral-xyz/anchor';
+import { SolanaWallet } from '../types/solana.types';
+export declare class SolanaProviderAdapter implements IProviderAdapter<SolanaWallet> {
+    private chainId;
+    private connection;
+    private wallet;
+    private ethereumAddress;
+    private connectHandler?;
+    private disconnectHandler?;
+    private chainEventListener?;
+    private anchorProvider?;
+    constructor(chainId: number, ethereumAddress?: string);
+    initConnector(connector: SolanaWallet): void;
+    init(chainId?: number): Promise<void>;
+    connectToConnector(): Promise<number>;
+    disconnectFromConnector(): Promise<void>;
+    connectAndPatchProvider(): Promise<number>;
+    getChainId(): number | undefined;
+    waitForTransaction(_chainId: number, transactionHash: string, _confirmations: number): Promise<boolean>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    signTransactionWithoutBroadcast(tx: Transaction): Promise<{
+        signature: string;
+        transactionMessageB64: string;
+    }>;
+    getAddress(): Promise<string>;
+    setChainEventListener(chainEventListener: ChainEventListener): void;
+    switchNetwork(network: EthereumNetwork): Promise<void>;
+    signTypedData(_domain: ethers.TypedDataDomain, _types: Record<string, ethers.TypedDataField[]>, _value: Record<string, unknown>): Promise<string>;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<unknown>;
+    release(): void;
+    getContract(_chainId: number, _contractType: ContractType, _contractAddress?: string, _runner?: ethers.ContractRunner): ethers.Contract;
+    getContractWithSigner(_chainId: number, _contractType: ContractType, _contractAddress?: string): ethers.Contract;
+    getContractWithFetcher(_chainId: number, _contractType: ContractType, _contractAddress?: string): ethers.Contract;
+    sendTransaction(_tx: ethers.TransactionRequest): Promise<ethers.TransactionResponse>;
+    getGasPrice(_chainId: number): Promise<bigint>;
+    isPermitterAvailable(): boolean;
+    getConnection(): Connection;
+    private initializeAnchorProvider;
+    getAnchorProvider(): AnchorProvider;
+    getSolanaProgram(idl: Idl): Program;
+    getSolanaPublicKey(): PublicKey;
+    private setupWalletListeners;
+    private removeWalletListeners;
+    isSolanaLedger(): boolean;
+}
+declare const _default: <T = unknown>(chainId: number, ethereumAddress?: string) => IProviderAdapter<T>;
+export default _default;

package/common/src/providers/TronProviderAdapter.d.ts

@@ -0,0 +1,39 @@
+import { ChainEventListener, IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+import { ContractType, EthereumNetwork } from '../types/ethereum-network.types';
+import { TronWallet } from '../types';
+import { ethers } from 'ethers';
+import { TronWeb } from 'tronweb';
+export declare class TronProviderAdapter implements IProviderAdapter<TronWallet> {
+    private chainId;
+    private tronWeb;
+    private address;
+    private signerAdapter;
+    private chainEventListener?;
+    private accountsChangedHandler?;
+    constructor(_chainId: number);
+    initConnector(_connector: TronWallet): void;
+    init(chainId?: number): Promise<void>;
+    createSignableTronWeb: (chainId: number, address: string) => TronWeb;
+    connectToConnector(): Promise<number>;
+    disconnectFromConnector(): Promise<void>;
+    connectAndPatchProvider(): Promise<number>;
+    getChainId(): number | undefined;
+    waitForTransaction(_chainId: number, transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    getAddress(): Promise<string>;
+    setChainEventListener(chainEventListener: ChainEventListener): void;
+    switchNetwork(network: EthereumNetwork): Promise<void>;
+    signTypedData(_domain: ethers.TypedDataDomain, _types: Record<string, ethers.TypedDataField[]>, _value: Record<string, unknown>): Promise<string>;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(_chainId?: number): Promise<unknown>;
+    release(): void;
+    getContract(chainId: number, contractType: ContractType, contractAddress?: string, runner?: ethers.ContractRunner): ethers.Contract;
+    getContractWithSigner(_chainId: number, _contractType: ContractType, _contractAddress?: string): ethers.Contract;
+    getContractWithFetcher(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
+    sendTransaction(_tx: ethers.TransactionRequest): Promise<ethers.TransactionResponse>;
+    getGasPrice(_chainId: number): Promise<bigint>;
+    isPermitterAvailable(): boolean;
+    getTronWeb(): TronWeb;
+}
+declare const _default: <T = unknown>(chainId: number) => IProviderAdapter<T>;
+export default _default;

package/common/src/providers/WagmiProviderAdapter.d.ts

@@ -0,0 +1,48 @@
+import { ChainEventListener, IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+import { ContractType, EthereumNetwork } from '../types/ethereum-network.types';
+import { ethers } from 'ethers';
+import { Connector } from 'wagmi';
+import { Call } from '../types/eip5792.types';
+export declare class WagmiProviderAdapter implements IProviderAdapter<Connector> {
+    private connector;
+    private chainId;
+    private originalProvider;
+    private fetchProviders;
+    private signer;
+    private chainEventListener?;
+    private config?;
+    private unsubscribeFns;
+    constructor();
+    initConnector(connector: Connector): void;
+    initConfig(config: any): void;
+    init(chainId?: number): Promise<void>;
+    disconnectFromConnector(): Promise<void>;
+    connectToConnector(connector: Connector): Promise<number>;
+    getChainId(): number | undefined;
+    waitForTransaction(chainId: number, transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    switchNetwork(network: EthereumNetwork): Promise<import('viem').Chain>;
+    getAddress(): Promise<string>;
+    setChainEventListener(chainEventListener: ChainEventListener): void;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<unknown>;
+    release(): void;
+    private removeListeners;
+    getContract(chainId: number, contractType: ContractType, contractAddress?: undefined, runner?: ethers.ContractRunner): ethers.Contract;
+    getContractWithSigner(chainId: number, contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcher(chainId: number, contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    sendTransaction(tx: ethers.TransactionRequest): Promise<ethers.TransactionResponse>;
+    connectAndPatchProvider(connector: Connector): Promise<number>;
+    isPermitterAvailable(): boolean;
+    getGasPrice(chainId: number): Promise<bigint>;
+    private static readonly FALLBACK_METHODS;
+    private wrapTransportWithRpcFallback;
+    walletClientToSigner(walletClient: any, chainId: number): Promise<ethers.JsonRpcSigner>;
+    supportsBatchCall(chainId: number): Promise<boolean>;
+    private waitForBatchTransactionStatus;
+    sendBatchCallsTransaction(chainId: number, calls: Call[]): Promise<ethers.TransactionResponse>;
+}
+export declare const wagmiProviderAdapter: WagmiProviderAdapter;
+declare const _default: <T = unknown>() => IProviderAdapter<T>;
+export default _default;

package/common/src/providers/exportProviers.d.ts

@@ -0,0 +1,3 @@
+import { IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+export declare const exportWagmiProvider: <T = unknown>() => Promise<IProviderAdapter<T>>;
+export declare const exportEthersProvider: () => Promise<IProviderAdapter<unknown>>;

package/common/src/types/API.types.d.ts

@@ -0,0 +1,25 @@
+export interface ThirdPartyLeaderBoardItem {
+    nickname: string;
+    points: number;
+}
+interface AssetChange {
+    type: string;
+    amount: string | null;
+    raw_amount: string;
+    dollar_value: string;
+    from: string;
+    to: string;
+    token_info: {
+        standard: string;
+        type: string;
+        contract_address: string;
+    };
+}
+export type AssetChanges = AssetChange[] | null;
+export interface CallInfo<T = bigint> {
+    from: string;
+    to: string;
+    calldata: string;
+    value: T;
+}
+export {};

package/common/src/types/ICacheDevice.d.ts

@@ -0,0 +1,5 @@
+export interface ICacheDevice<T = string> {
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    serialize(): Record<string, string>;
+}

package/common/src/types/IMultiThreadedUtxoUtils.d.ts

@@ -0,0 +1,8 @@
+import { Utxo } from '../data-structures/utxo/Utxo';
+import { UserKeys } from '../data-structures/crypto-keys/keys';
+import { EncryptedOutputWithSign, OutputsWithSignAndLast } from './commitments.types';
+export interface IMultiThreadedUtxoUtils {
+    batchProcess(encryptedOutputs: EncryptedOutputWithSign[], lastOutput: string, userKeys: UserKeys, chainId: number): Promise<OutputsWithSignAndLast>;
+    buildBatchProcess(encryptedOutputs: EncryptedOutputWithSign[], userKeys: UserKeys, chainId: number): Promise<Utxo[]>;
+    batchFilterUtxosWithNullifier(allUtxos: Utxo[], nullifiers: Set<string>): Promise<Utxo[]>;
+}

package/common/src/types/RewardUserEnums.d.ts

@@ -0,0 +1,11 @@
+export declare enum MemberStatus {
+    Owner = "Owner",
+    Member = "Member",
+    Leader = "Leader",
+    None = "None"
+}
+export declare enum Rank {
+    Bronze = "Bronze",
+    Silver = "Silver",
+    Gold = "Gold"
+}

package/common/src/types/TransactionSimulator.types.d.ts

@@ -0,0 +1,16 @@
+import { TokenChanges } from './token.types';
+import { TxParametersBase } from './wc.types';
+export interface TransactionSimulatorResult<T = bigint> {
+    tokenChanges: TokenChanges<T>[];
+    tokenChangesPerTx?: TokenChanges<T>[][];
+    error?: string;
+    errorReason?: string;
+}
+export interface ITransactionSimulator {
+    simulateTransaction(txParameters: TxParametersBase): Promise<TransactionSimulatorResult>;
+}
+export interface VolatileTokenTransferResult {
+    success: boolean;
+    balanceDifference?: bigint;
+    error?: string;
+}