@gurge/sdk 0.3.5 → 0.3.7

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

@@ -0,0 +1,254 @@
+import { abi as AmTokenABI } from './amToken';
+import { abi as BUSDABI } from './BUSD';
+import { abi as daiABI } from './DAI';
+import { abi as sanctionsListABI } from './SanctionsList';
+import { abi as USDCABI } from './USDC';
+import { abi as USDRABI } from './USDR';
+import { abi as USDR3CRVABI } from './USDR3CRV';
+import { abi as USDTABI } from './USDT';
+import { abi as WETHABI } from './WETH';
+import { default as optimismGasPriceOracleAbi } from './OptimismGasPriceOracle.json';
+import { default as NodeInterfaceABI } from './NodeInterfaceABI.json';
+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;
+})[];
+declare const ERC721ABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    outputs?: undefined;
+    stateMutability?: undefined;
+})[];
+declare const ERC1155ABI: ({
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    outputs?: undefined;
+    stateMutability?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+declare const quoterV2ABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+} | {
+    inputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+})[];
+declare const factoryABI: ({
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    outputs?: undefined;
+    stateMutability?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+declare const ISwapRouterABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+} | {
+    stateMutability: string;
+    type: string;
+    inputs?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+})[];
+declare const BabABI: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+declare const GalxeABI: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+export { quoterV2ABI, factoryABI, AmTokenABI, ERC20ABI, ERC721ABI, USDCABI, daiABI, USDRABI, USDR3CRVABI, USDTABI, WETHABI, BUSDABI, sanctionsListABI, BabABI, GalxeABI, optimismGasPriceOracleAbi, NodeInterfaceABI, ISwapRouterABI, ERC1155ABI, };

package/common/src/externalABIs/swapAbi.d.ts

@@ -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/common/src/functions/auto-deposit-back-helpers/get-gas-token-records.d.ts

@@ -0,0 +1,9 @@
+import { ethers } from 'ethers';
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+import { ERC20Token } from '../../types';
+export declare const getGasTokenRecords: (options: ERC20Token[], chainId: number, hinkal: IHinkal, walletAddress: string, providerAdapter: ethers.JsonRpcProvider, pricesMap: Map<string, number>) => Promise<{
+    erc20Token: ERC20Token;
+    privateUsdBalance: number;
+    publicUsdBalance: number;
+    totalUsdBalance: number;
+}[]>;

package/common/src/functions/auto-deposit-back-helpers/get-tokens-to-deposit-back.d.ts

@@ -0,0 +1,3 @@
+import { TokenBalance, TokenChanges } from '../../types';
+import { ethers } from 'ethers';
+export declare const getTokensToDepositBack: (emporiumTokenChanges: TokenChanges<bigint>[], feeToken: string | undefined, walletAddress: string, providerAdapter: ethers.JsonRpcProvider) => Promise<TokenBalance[]>;

package/common/src/functions/auto-deposit-back-helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './get-tokens-to-deposit-back';
+export * from './get-gas-token-records';
+export * from './select-gas-token';
+export * from './update-hinkal';

package/common/src/functions/auto-deposit-back-helpers/select-gas-token.d.ts

@@ -0,0 +1,13 @@
+import { ERC20Token, FeeStructure } from '../../types';
+interface GasTokenRecord {
+    erc20Token: ERC20Token;
+    totalUsdBalance: number;
+    privateUsdBalance: number;
+    publicUsdBalance: number;
+}
+interface SelectGasTokenResult {
+    feeToken: string | undefined;
+    feeStructure: FeeStructure;
+}
+export declare const selectGasToken: (feeToken: string | undefined, gasFeeInDollar: number, chainId: number, tokens: ERC20Token[], transferOps: string[], gasTokenRecords: GasTokenRecord[], feeStructure: FeeStructure, erc20Addresses: string[], walletAddress: string) => Promise<SelectGasTokenResult | undefined>;
+export {};

package/common/src/functions/auto-deposit-back-helpers/update-hinkal.d.ts

@@ -0,0 +1,3 @@
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+import { CircomDataType } from '../../types/circom-data.types';
+export declare const updateHinkal: (circomData: CircomDataType, chainId: number, hinkal: IHinkal) => void;

package/common/src/functions/connectors.types.d.ts

@@ -0,0 +1,22 @@
+import { Connector } from 'wagmi';
+import { SolanaWallet, TronWallet } from '../types';
+export type EvmConnector = Connector;
+type BaseConnectInput = {
+    id?: string;
+    getChainId: () => number;
+};
+export type SolanaConnectInput = BaseConnectInput & {
+    wallet: SolanaWallet;
+};
+export type TronConnectInput = BaseConnectInput & {
+    wallet: TronWallet;
+};
+export type ConnectInput = EvmConnector | SolanaConnectInput | TronConnectInput;
+export interface WalletGroup {
+    name: string;
+    icon?: string;
+    evmConnector?: Connector;
+    solanaConnector?: Connector;
+    tronConnector?: Connector;
+}
+export {};

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

@@ -0,0 +1,13 @@
+export * from './kyc';
+export * from './utils';
+export * from './web3';
+export * from './snarkjs';
+export * from './pre-transaction';
+export * from './private-wallet';
+export * from './connectors.types';
+export * from './auto-deposit-back-helpers';
+export * from './pre-transaction/outputUtxoProcessing';
+export * from './utils/requireEnv';
+export * from './utils/resolve-sync.utils';
+export * from './utils/getDataFromTransaction';
+export * from './web3/uniswapAPI';

package/common/src/functions/kyc/checkTokenLimitsUSD.d.ts

@@ -0,0 +1 @@
+export declare const checkTokenLimitsUSD: (chainId: number, tokenAddresses: string[], amounts: bigint[]) => Promise<boolean>;

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

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

package/common/src/functions/kyc/openDefaultPassportWindow.d.ts

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

package/common/src/functions/kyc/passportHelper.d.ts

@@ -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/common/src/functions/kyc/zkMeHelper.d.ts

@@ -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/common/src/functions/pre-transaction/addressTableLookup.d.ts

@@ -0,0 +1,4 @@
+import { AnchorProvider, Provider } from '@coral-xyz/anchor';
+import { Keypair, PublicKey } from '@solana/web3.js';
+export declare const getAddressLookupTableAccounts: (provider: AnchorProvider, addressLookupTableAccounts: string[] | undefined) => Promise<import('@solana/web3.js').AddressLookupTableAccount[] | undefined>;
+export declare const createAndExtendAddressLookupTable: (provider: Provider, accounts: PublicKey[], payer: Keypair) => Promise<PublicKey>;

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

@@ -0,0 +1,14 @@
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { CommitmentValidationDataType } from '../../types/circom-data.types';
+import { NewZkCallDataType } from '../../types/snark.types';
+interface BuildCommitmentValidationData extends Omit<CommitmentValidationDataType, 'proof'> {
+    verifierName: string;
+    commitmentInput: any;
+}
+export declare const buildCommitmentValidationData: (chainId: number, userKeys: UserKeys, erc20Addresses: string[], inputUtxosArray: Utxo[][]) => Promise<BuildCommitmentValidationData | undefined>;
+export declare const buildCommitmentValidationDataFromProof: (commitmentValidationData: BuildCommitmentValidationData | undefined, commitmentValidationProofResponse: {
+    zkCallData: NewZkCallDataType;
+    publicSignals: string[];
+} | undefined) => CommitmentValidationDataType | undefined;
+export {};

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

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

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

@@ -0,0 +1,3 @@
+import { AdminDataType, AdminTransactionType } from '../../types/admin.types';
+import { ERC20Token } from '../../types';
+export declare const constructAdminData: (action: AdminTransactionType | undefined, chainId: number, erc20TokenAddresses: string[], amountChanges: bigint[], ethereumAddress: string, swapPairTokens?: ERC20Token[]) => AdminDataType | undefined;

package/common/src/functions/pre-transaction/convert-okx-instructions.d.ts

@@ -0,0 +1,11 @@
+import { AccountMeta, PublicKey } from '@solana/web3.js';
+import { OKXSwapResponseInstruction } from '../../types/okx.types';
+export interface HinkalInstruction {
+    accountIndexes: Buffer;
+    data: Buffer;
+    programIndex: number;
+}
+export declare const convertOKXToHinkalInstructions: (okxInstructions: OKXSwapResponseInstruction[], cpiSignerAccount: PublicKey) => {
+    hinkalInstructions: HinkalInstruction[];
+    remainingAccounts: AccountMeta[];
+};

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

@@ -0,0 +1,2 @@
+import { Utxo } from '../../data-structures/utxo/Utxo';
+export declare const ensureAmountChanges: (inputUtxos: Utxo[][], outputUtxos: Utxo[][], amountChanges: bigint[]) => void;

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

@@ -0,0 +1,2 @@
+import { ExternalActionId } from '../../types/external-action.types';
+export declare const getExternalSwapAddress: (chainId: number, externalActionId: ExternalActionId) => string;

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

@@ -0,0 +1,5 @@
+import { FeeStructure } from '../../types/hinkal.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { CallInfo } from '../../types/API.types';
+import { SolanaTransactionParams } from '../../types/solana.types';
+export declare const getFeeStructure: (chainId: number, feeTokenAddress: string | undefined, erc20Addresses: string[], externalActionId: ExternalActionId, calls?: CallInfo[], variableRate?: bigint, solanaTransactionParams?: SolanaTransactionParams) => Promise<FeeStructure>;

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

@@ -0,0 +1,4 @@
+import { DimDataType } from '../../types/circom-data.types';
+import { AccountMeta, PublicKey } from '@solana/web3.js';
+import { HinkalInstruction } from './convert-okx-instructions';
+export declare const getSolanaCalldataHash: (dimensions: DimDataType, recipient: PublicKey, signer: PublicKey, encryptedOutputs: number[][], relayerFee: bigint, variableRate: bigint, instructions: HinkalInstruction[], remainingAccounts: AccountMeta[]) => bigint;

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

@@ -0,0 +1,9 @@
+import { ERC20Token } from '../../types/token.types';
+/**
+ * Adjusts the token amount changes for volatile tokens based on actual transfer simulation results.
+ *
+ * This function identifies potentially volatile tokens with negative amount changes,
+ * simulates their transfers to estimate the real balance impact, and then updates
+ * the original `amountChanges` array accordingly with the simulated balance differences.
+ */
+export declare const modifyVolatileTokenAmountChanges: (chainId: number, tokens: ERC20Token[], amountChanges: bigint[], targetAddress?: string) => Promise<bigint[]>;

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

@@ -0,0 +1,19 @@
+export * from './interaction-to-action';
+export * from './outputUtxoProcessing';
+export * from './process-gas-estimates';
+export * from './getVolatileTransferAmount';
+export * from './constructAdminData';
+export * from './solana';
+export * from './calculateSolanaNullifierCount';
+export * from './addressTableLookup';
+export * from './solana-public-signals';
+export * from './convert-okx-instructions';
+export * from './sendV0Transaction';
+export * from './store-proof';
+export * from './sendInitNullifiersTransaction';
+export * from './recipientUtxoProcessing';
+export * from './store-instructions';
+export * from './ensureAmountChanges';
+export * from './getFeeStructure';
+export * from './waitForDepositedUtxosInMerkleTree';
+export * from './buildCommitmentValidationData';

package/common/src/functions/pre-transaction/interaction-to-action.d.ts

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

package/common/src/functions/pre-transaction/merge-with-fee-structure-emporium.d.ts

@@ -0,0 +1,3 @@
+import { FeeStructure } from '../../types/hinkal.types';
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+export declare const mergeWithFeeStructureEmporium: (hinkal: IHinkal, chainId: number, walletAddress: string, emporiumOps: string[], erc20Addresses: string[], amountChanges: bigint[], feeStructure: FeeStructure, feeTokenChange: bigint) => Promise<void>;

package/common/src/functions/pre-transaction/merge-with-fee-structure.d.ts

@@ -0,0 +1,2 @@
+import { FeeStructure } from '../../types/hinkal.types';
+export declare const mergeWithFeeStructure: (chainId: number, erc20Addresses: string[], amountChanges: bigint[], feeStructure: FeeStructure) => Promise<void>;

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

@@ -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, revertIfNegative?: boolean, recipientAddress?: string, recipientAmountChange?: bigint) => {
+    outputUtxos: Utxo[];
+};

package/common/src/functions/pre-transaction/process-gas-estimates.d.ts

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

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

@@ -0,0 +1,3 @@
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { PrivateRecipientInfo } from '../../types/token.types';
+export declare const recipientUtxoProcessing: (privateRecipientInfo: PrivateRecipientInfo, outputUtxosArray: Utxo[][], deltaChanges: bigint[], timeStamp: string) => void;

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

@@ -0,0 +1,11 @@
+import { Program } from '@coral-xyz/anchor';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+interface CreatedNullifierAccount {
+    account: PublicKey;
+    nullifier: number[];
+}
+export declare const sendInitNullifiersTransaction: (connection: Connection, program: Program, originalDeployer: PublicKey, signer: Keypair, nullifiers: number[][]) => Promise<{
+    signature: string;
+    createdAccounts: Array<CreatedNullifierAccount>;
+}>;
+export {};

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

@@ -0,0 +1,18 @@
+import { AddressLookupTableAccount, Connection, Finality, Keypair, PublicKey, TransactionInstruction, VersionedTransactionResponse } from '@solana/web3.js';
+import { SubAccount } from '../../types/proxy.types';
+export declare const fetchSolanaTransaction: (connection: Connection, signature: string, finality?: Finality) => Promise<VersionedTransactionResponse | null>;
+export declare const estimateComputeUnitLimit: (connection: Connection, payerKey: PublicKey, instructions: TransactionInstruction[], lookupTableAccounts?: AddressLookupTableAccount[], requestHeapFrame?: boolean) => Promise<number>;
+export declare const getAccountsFromInstructions: (instructions: TransactionInstruction[], payerKey?: PublicKey, additionalAccounts?: PublicKey[], lookupTableAccounts?: AddressLookupTableAccount[]) => PublicKey[];
+export declare const sendV0Transaction: (connection: Connection, instructions: TransactionInstruction[], payer: Keypair, signers: Keypair[], lookupTableAccounts?: AddressLookupTableAccount[], requestHeapFrame?: boolean) => Promise<string>;
+export declare const ensureAtaExists: (connection: Connection, payer: Keypair, mintPubkey: PublicKey | null, owner: PublicKey) => Promise<PublicKey | null>;
+type SendProxyV0TransactionParams = {
+    connection: Connection;
+    chainId: number;
+    subAccount: SubAccount;
+    payerPublicKey: PublicKey;
+    instructions: TransactionInstruction[];
+    lookupTableAccounts?: AddressLookupTableAccount[];
+};
+export declare const sendProxyV0Transaction: ({ connection, chainId, subAccount, payerPublicKey, instructions, lookupTableAccounts, }: SendProxyV0TransactionParams) => Promise<string>;
+export declare const serializeProxyV0Transaction: (connection: Connection, payerPublicKey: PublicKey, instructions: TransactionInstruction[], lookupTableAccounts?: AddressLookupTableAccount[]) => Promise<string>;
+export {};

package/common/src/functions/pre-transaction/solana-public-signals.d.ts

@@ -0,0 +1,21 @@
+export declare const convertSolanaPublicSignals: (publicInputsArr: number[][], dimensions: {
+    tokenNumber: number;
+    nullifierAmount: number;
+    outputAmount: number;
+}) => {
+    outH1Ay: number[];
+    outStealthAddress: number[];
+    message: number[];
+    swapperAccountAdditionalSeed: number[];
+    rootHash: number[];
+    signedMessageHash: number[];
+    mintAccountPart1: number[][];
+    mintAccountPart2: number[][];
+    amountChanges: number[][];
+    inNullifiers: number[][][];
+    outTimestamp: number[];
+    outCommitments: number[][][];
+    calldataHash: number[];
+    h0Ax: number[];
+    h0Ay: number[];
+};

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

@@ -0,0 +1,14 @@
+import { AnchorStealthAddressStructure, StealthAddressStructure } from '../../types/circom-data.types';
+import { PublicKey } from '@solana/web3.js';
+export declare const encodeToByte32Array: (value: bigint) => number[];
+export declare const buildAnchorStealthAddressStructure: (structure: StealthAddressStructure) => AnchorStealthAddressStructure;
+export declare const getNullifierAccount: (nullifier: bigint, originalDeployer: PublicKey, programId: PublicKey) => PublicKey;
+export declare const getStorageAccountPublicKey: (programId: PublicKey, originalDeployer: PublicKey) => PublicKey;
+export declare const getMerkleAccountPublicKey: (programId: PublicKey, originalDeployer: PublicKey) => PublicKey;
+export declare const getSwapperAccountPublicKey: (programId: PublicKey, originalDeployer: PublicKey, swapperAccountAdditionalSeed: bigint) => PublicKey;
+export declare const getSwapperAccountPublicKeyFromSalt: (programId: PublicKey, originalDeployer: PublicKey, swapperAccountSalt: bigint) => PublicKey;
+export declare const getStorageVaultPublicKey: (programId: PublicKey, originalDeployer: PublicKey) => PublicKey;
+export declare const getProofAccountPart1PublicKey: (programId: PublicKey, originalDeployer: PublicKey, signer: PublicKey, id: bigint) => PublicKey;
+export declare const getProofAccountPart2PublicKey: (programId: PublicKey, originalDeployer: PublicKey, signer: PublicKey, id: bigint) => PublicKey;
+export declare const getEncryptedOutputsAccountPublicKey: (programId: PublicKey, originalDeployer: PublicKey, signer: PublicKey, id: bigint) => PublicKey;
+export declare const getInstructionsAccountPublicKey: (programId: PublicKey, originalDeployer: PublicKey, signer: PublicKey, id: bigint) => PublicKey;

package/common/src/functions/pre-transaction/solanaTransfer.utils.d.ts

@@ -0,0 +1,6 @@
+import { Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { ERC20Token } from '../../types/token.types';
+export declare const buildSolanaTransferInstructions: (connection: Connection, fromPubkey: PublicKey, toPubkey: PublicKey, token: ERC20Token, amount: bigint) => Promise<{
+    instructions: TransactionInstruction[];
+    programId: PublicKey;
+}>;

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

@@ -0,0 +1,4 @@
+import { Program } from '@coral-xyz/anchor';
+import { HinkalInstruction } from './convert-okx-instructions';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+export declare const storeInstructions: (connection: Connection, hinkalProgram: Program, signer: Keypair, originalDeployer: PublicKey, id: bigint, instructions: HinkalInstruction[]) => Promise<PublicKey>;