@gurge/sdk 0.3.120 → 0.3.142

package/README.md

@@ -22,13 +22,13 @@ With Hinkal SDK, developers can:
 Using npm:
 
 ```sh
-npm install @hinkal/sdk
+npm install @hinkal/common
 ```
 
 Or, yarn:
 
 ```sh
-yarn add @hinkal/sdk
+yarn add @hinkal/common
 ```
 
 ## Usage
@@ -43,10 +43,16 @@ Initializing the SDK creates a `Hinkal` object that encapsulates:
 - Actions the user can perform, such as shielding (depositing), transfers, and swapping
 - Cryptographic keys for privacy-preserving operations
 
+Each provider exposes three prepare helpers:
+
+- `prepare*Hinkal` — signs the Hinkal login message and initializes user keys (deterministic signers)
+- `prepare*HinkalWithEnclaveSignIn` — signs in through the secure enclave and stabilizes identity for non-deterministic signers (smart contract wallets, some hardware wallets)
+- `prepare*HinkalFromSignature` — initializes user keys from a previously stored signature
+
 **ethers.js:**
 
 ```typescript
-import { prepareEthersHinkal } from '@hinkal/sdk/providers/prepareEthersHinkal';
+import { prepareEthersHinkal } from '@hinkal/common/providers/prepareEthersHinkal';
 // signer: ethers.Signer
 const hinkal = await prepareEthersHinkal(signer, hinkalConfig);
 ```
@@ -54,12 +60,31 @@ const hinkal = await prepareEthersHinkal(signer, hinkalConfig);
 **wagmi:**
 
 ```typescript
-import { prepareWagmiHinkal } from '@hinkal/sdk/providers/prepareWagmiHinkal';
+import { prepareWagmiHinkal } from '@hinkal/common/providers/prepareWagmiHinkal';
 // connector: wagmi.Connector
 // wagmiConfig: wagmi.Config
 const hinkal = await prepareWagmiHinkal(connector, wagmiConfig, hinkalConfig);
 ```
 
+**Solana:**
+
+```typescript
+import { prepareSolanaHinkal } from '@hinkal/common/providers/prepareSolanaHinkal';
+// connector: SolanaWallet
+// ethereumAddress: optional linked EVM address
+const hinkal = await prepareSolanaHinkal(connector, ethereumAddress, hinkalConfig);
+```
+
+**Tron:**
+
+```typescript
+import { prepareTronHinkal } from '@hinkal/common/providers/prepareTronHinkal';
+// connector: TronWeb
+const hinkal = await prepareTronHinkal(connector, hinkalConfig);
+```
+
+The same `WithEnclaveSignIn` and `FromSignature` variants are available for each provider (for example, `prepareWagmiHinkalWithEnclaveSignIn`, `prepareSolanaHinkalFromSignature`).
+
 The `hinkalConfig` is defined as follows:
 
 ```typescript
@@ -77,7 +102,7 @@ type HinkalConfig = {
   cacheFilePath?: string;
 
   /**
-   * Indicator controlling wether the proof should be constructed remotely in secure enclave. Defaults to true.
+   * Indicator controlling whether the proof should be constructed remotely in secure enclave. Defaults to true.
    */
   generateProofRemotely?: boolean;
 
@@ -97,7 +122,9 @@ Most wallets return the same signature every time for the same message. Some do
 
 When that happens, a returning user appears as a new account. Funds deposited in an earlier session remain tied to the original identity and are not accessible from the new one.
 
-Use `storeAndGetInitialSignature` to keep identity stable across sessions. It stores the user's first login signature server-side and returns that same signature on every later login. The user still signs each session to prove wallet ownership, but the SDK always initializes with the original signature.
+**Recommended approach:** use `prepare*HinkalWithEnclaveSignIn` instead of `prepare*Hinkal`. It signs the login message, stores the first signature server-side through the secure enclave, and always initializes with the original identity on later sessions. Solana Ledger wallets are handled automatically.
+
+**Manual approach:** if you manage identity yourself, call `storeAndGetInitialSignature` and then either `initUserKeysWithSignature` or `prepare*HinkalFromSignature`:
 
 ```typescript
 function storeAndGetInitialSignature(
@@ -113,16 +140,17 @@ Parameters:
 - `isSolanaLedger` — set to `true` for a Solana Ledger wallet. Defaults to `false`
 - `txMessageForSolanaLedger` — base64-encoded transaction message used for Solana Ledger authentication. Required when `isSolanaLedger` is `true`
 
-Typical flow:
+Typical flow with a stored signature:
 
 ```typescript
-const authSignature = await hinkal.signHinkalMessage();
 const initialSignature = await hinkal.storeAndGetInitialSignature(authSignature);
 hinkal.initUserKeysWithSignature(initialSignature);
 ```
 
 Call this once per session, after wallet connection and before fetching balances or submitting transactions.
 
+You do not need enclave sign-in if your wallet produces deterministic signatures for the same login message on every session — in that case, `prepare*Hinkal` is sufficient. It is also not needed if you persist the signature yourself via `prepare*HinkalFromSignature`, or if you use seed-phrase-based login through `initUserKeysFromSeedPhrases`.
+
 **Security**
 
 The stored signature is protected at every stage. Before leaving the client, the signature is encrypted with hybrid encryption. The payload is encrypted with a symmetric key, and that key is encrypted with the enclave's public key.
@@ -133,52 +161,37 @@ At rest, only the encrypted signature and encrypted key are stored in the databa
 
 Requests that fail this check are rejected. The first signature stored for a given address is never replaced. Later logins only use a fresh signature to authenticate retrieval of the original.
 
-You should use this function in any wallet-connected application where users may reconnect across sessions, especially when supporting smart contract wallets. It is not necessary if your wallet produces deterministic signatures for the same login message on every session — in that case, calling `initUserKeys` or `initUserKeysWithSignature` with the fresh signature is sufficient. It is also not needed if you persist the signature yourself, or if you use seed-phrase-based login through `initUserKeysFromSeedPhrases`.
-
-**Solana Ledger wallets**
-
-For standard EVM and Solana wallets, authentication uses a plain message signature. Call `signHinkalMessage` and pass the result to `storeAndGetInitialSignature` without extra parameters.
+### Shielded balance
 
-Solana Ledger wallets cannot reliably sign arbitrary UTF-8 messages. For those wallets, Hinkal uses a deterministic empty Solana transaction instead. The transaction uses a fixed blockhash and block height, so signing it always returns the same result.
+Shielded balances are encrypted token holdings stored within the Hinkal protocol. Unlike regular blockchain balances that are publicly visible, shielded balances are hidden from external observers.
 
-Use `signSolanaLedgerMessage` to get both the signature and the transaction message, then pass them to `storeAndGetInitialSignature`:
+After initializing the Hinkal object and calling `initUserKeys` (or a prepare helper), fetch balances for a specific chain:
 
 ```typescript
-const isSolanaLedger = hinkal.getProviderAdapter().isSolanaLedger?.() ?? false;
-let authSignature: string;
-let txMessageForSolanaLedger: string | undefined;
-
-if (isSolanaLedger) {
-  const ledgerAuth = await hinkal.signSolanaLedgerMessage();
-  authSignature = ledgerAuth.signature;
-  txMessageForSolanaLedger = ledgerAuth.txMessageForSolanaLedger;
-} else {
-  authSignature = await hinkal.signHinkalMessage();
-}
-
-const initialSignature = await hinkal.storeAndGetInitialSignature(
-  authSignature,
-  isSolanaLedger,
-  txMessageForSolanaLedger,
-);
-
-hinkal.initUserKeysWithSignature(initialSignature);
+function getTotalBalance(
+  chainId: number,
+  resetCacheBefore?: boolean,
+  updateTokensListBefore?: boolean,
+): Promise<TokenBalance[]>;
 ```
 
-On return visits, the user must sign the same deterministic transaction again to authenticate. The enclave verifies the fresh signature against `txMessageForSolanaLedger`, not against a plain login message.
+`TokenBalance` contains `chainId`, `erc20Address`, `balance`, and an optional `timestamp`.
 
-If your application caches the transaction message locally between sessions, pass the cached value as `txMessageForSolanaLedger` so the enclave can verify the correct payload.
+For reactive UI updates, subscribe to balance changes with USD values:
 
-### Shielded balance
+```typescript
+// Current state keyed by chainId
+hinkal.privateBalancesWithUSD;
 
-Shielded balances are encrypted token holdings stored within the Hinkal protocol. Unlike regular blockchain balances that are publicly visible, shielded balances are hidden from external observers, providing privacy for your assets. After initializing the Hinkal object, you can access and calculate your shielded balances:
+// Subscribe to updates; returns unsubscribe function
+const unsubscribe = hinkal.onPrivateBalancesWithUSDChange((state) => {
+  // state: Record<chainId, TokenBalanceWithUsd[]>
+});
 
-```typescript
-const balances: Promise<Map<string, TokenBalance>> = await hinkal.getBalances();
+// Trigger a refresh after a transaction
+hinkal.refreshBalance({ chainIdToUpdate: chainId, updateType: PrivateBalanceUpdateType.Fresh });
 ```
 
-This returns a map from token address to balance for all tokens held by the user, including ERC20 and ERC721 tokens.
-
 ### Shielding: depositing funds to the shielded balance
 
 Shielding is the process of moving your tokens from a public blockchain address into a private, encrypted balance. Once shielded, your tokens are no longer visible on-chain to external observers. This provides privacy for your holdings and subsequent transactions.
@@ -187,31 +200,30 @@ A user can deposit funds to their shielded address using:
 
 ```typescript
 function deposit(
-  erc20Tokens: ERC20Token[],
+  chainId: number,
+  erc20Addresses: string[],
   amountChanges: bigint[],
   preEstimateGas?: boolean,
   returnTxData?: boolean,
-): Promise<ethers.providers.TransactionResponse>;
+): Promise<
+  | ethers.TransactionResponse
+  | ethers.TransactionRequest
+  | string
+  | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>
+>;
 ```
 
 where:
 
-- `erc20Tokens` is an array of tokens to deposit
-- `amountChanges` represents the corresponding token amounts for the deposit
-- `preEstimateGas` If true (default), the gas needed for the operation will be estimated before executing the deposit. This can help avoid failed transactions due to "out of gas" error.
-- `returnTxData` If true, returns unsigned transaction data without executing. Defaults to false.
+- `chainId` — target chain
+- `erc20Addresses` — token contract addresses to deposit
+- `amountChanges` — corresponding deposit amounts in the token's smallest unit
+- `preEstimateGas` — if true (default), gas is estimated before executing the deposit
+- `returnTxData` — if true, returns unsigned transaction data without executing. Defaults to false
 
-The `ERC20Token` type is defined as follows:
+On Solana, use `depositSolana(chainId, erc20Address, amount)`.
 
-```typescript
-type ERC20Token = {
-  chainId: number;
-  erc20TokenAddress: string;
-  name: string;
-  symbol: string;
-  decimals: number;
-};
-```
+To shield funds for another user's private address, use `depositForOther` (EVM/Tron) or `depositSolanaForOther` (Solana) with their `recipientInfo` string from `getRecipientInfo()`.
 
 ### Private Send to Public Address: withdrawing funds from the shielded balance
 
@@ -221,18 +233,22 @@ A user can withdraw funds from their shielded address to a public address using:
 
 ```typescript
 function withdraw(
-  erc20Tokens: ERC20Token[],
+  chainId: number,
+  erc20Addresses: string[],
   deltaAmounts: bigint[],
   recipientAddress: string,
   isRelayerOff: boolean,
-): Promise<string>;
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+): Promise<ethers.TransactionResponse | string>;
 ```
 
 where:
 
-- `recipientAddress` is the public address that will receive the withdrawn funds
-- `isRelayerOff` determines whether to use a relayer for the transaction (when `false`, a relayer handles gas fees; when `true`, the user pays gas directly)
-- `string` type represents the transaction response from the relayer service.
+- `recipientAddress` — public address that receives the withdrawn funds
+- `isRelayerOff` — when `false`, a relayer handles gas fees; when `true`, the user pays gas directly
+- `feeToken` — optional token address used to pay protocol fees
+- `feeStructureOverride` — optional custom fee structure
 
 ### Private Send to Private Address: transfering funds from shielded balance
 
@@ -241,17 +257,24 @@ Private Send to Private Address enables fully confidential transfers between shi
 A user can transfer tokens from their shielded balance to another shielded address using:
 
 ```typescript
-function transfer(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], privateRecipientAddress: string): Promise<string>;
+function transfer(
+  chainId: number,
+  erc20Addresses: string[],
+  amountChanges: bigint[],
+  recipientAddress: string,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+): Promise<string>;
 ```
 
 where:
 
-- `privateRecipientAddress` is the recipient's private address, formatted as a comma-separated string with five components:
-- `randomization` - a random value for privacy
-- `stealthAddress` - the recipient's stealth address (hex format starting with `0x`)
-- `encryptionKey` - the recipient's encryption key (hex format starting with `0x`, 66 characters)
-- `H0` - the first hash component of elliptic curve point for stealth address derivation
-- `H1` - the second hash component of elliptic curve point for stealth address derivation
+- `recipientAddress` — recipient's private address string from `getRecipientInfo()`. Pass it as-is; do not reformat. It is a comma-separated string with five components:
+  - `stealthAddress` — recipient's stealth address (hex, `0x` prefix, 64–66 characters)
+  - `H0[0]` — first coordinate of the H0 elliptic-curve point
+  - `H0[1]` — second coordinate of the H0 elliptic-curve point
+  - `H1[1]` — second coordinate of the H1 elliptic-curve point
+  - `encryptionKey` — recipient's encryption public key (hex, `0x` prefix, 66 characters)
 
 ### Private Send from Public to Public addresses
 
@@ -261,45 +284,24 @@ A user can perform a private transfer between public addresses using:
 
 ```typescript
 function depositAndWithdraw(
-  erc20Token: ERC20Token,
-  recipientAmounts: bigint[],
-  recipientAddresses: string[],
-  txCompletionTime?: number,
-  preEstimateGas?: boolean,
-): Promise<string>;
-```
-
-where:
-
-- `erc20Token` is the token to transfer (only single token transfers are supported for this method)
-- `recipientAmounts` is an array of amounts to send to each recipient (in the token's smallest unit)
-- `recipientAddresses` is an array of public addresses that will receive the funds
-- `txCompletionTime` (optional) is a Unix timestamp in seconds by which all scheduled withdrawals must complete
-- `preEstimateGas` If true (default), the gas needed for the operation will be estimated before executing the deposit. This can help avoid failed transactions due to "out of gas" error.
-
-### Private Send from Public to Public addresses (extended)
-
-Private Send from Public to Public addresses (extended) follows the same flow as `depositAndWithdraw`. Tokens are shielded from the sender's public address, then withdrawn to one or more recipient public addresses on a relayer schedule. In addition to the deposit transaction hash, it returns a `scheduleId` that you can use to check the status of each scheduled withdrawal.
-
-A user can perform an extended private transfer between public addresses using:
-
-```typescript
-function depositAndWithdrawExtended(
-  erc20Token: ERC20Token,
+  chainId: number,
+  erc20Address: string,
   recipientAmounts: bigint[],
   recipientAddresses: string[],
   txCompletionTime?: number,
+  feeStructureOverride?: FeeStructure,
   preEstimateGas?: boolean,
 ): Promise<DepositAndSendExtendedResult>;
 ```
 
 where:
 
-- `erc20Token` is the token to transfer (only single token transfers are supported for this method)
-- `recipientAmounts` is an array of amounts to send to each recipient (in the token's smallest unit)
-- `recipientAddresses` is an array of public addresses that will receive the funds
-- `txCompletionTime` (optional) is a Unix timestamp in seconds by which all scheduled withdrawals must complete
-- `preEstimateGas` If true (default), the gas needed for the operation will be estimated before executing the deposit. This can help avoid failed transactions due to "out of gas" error.
+- `erc20Address` — token contract address (single-token transfers only)
+- `recipientAmounts` — amounts to send to each recipient in the token's smallest unit
+- `recipientAddresses` — public addresses that receive the funds
+- `txCompletionTime` — optional Unix timestamp in seconds by which all scheduled withdrawals must complete
+- `feeStructureOverride` — optional custom fee structure
+- `preEstimateGas` — if true (default), gas is estimated before executing the deposit
 
 The function returns:
 
@@ -310,14 +312,14 @@ type DepositAndSendExtendedResult = {
 };
 ```
 
-where:
+- `depositTxHash` — on-chain hash of the deposit transaction
+- `scheduleId` — relayer schedule identifier used to fetch withdrawal status
 
-- `depositTxHash` is the on-chain hash of the deposit transaction
-- `scheduleId` is the relayer schedule identifier used to fetch withdrawal status
+For cross-chain private sends, use `depositAndBridge(chainId, erc20Address, recipientBridges, ...)` with `BridgeRecipient` entries that include bridge quotes and destination addresses.
 
 ### Checking scheduled send status
 
-After calling `depositAndWithdrawExtended`, a user can fetch the current status of the scheduled withdrawals using the returned `scheduleId`:
+After `depositAndWithdraw` or `depositAndBridge`, fetch scheduled withdrawal status using the returned `scheduleId`:
 
 ```typescript
 function checkSendTransactionStatus(scheduleId: string): Promise<ScheduledTransactionByIdResponse>;
@@ -325,7 +327,7 @@ function checkSendTransactionStatus(scheduleId: string): Promise<ScheduledTransa
 
 where:
 
-- `scheduleId` is the schedule identifier returned from an extended deposit-and-send call
+- `scheduleId` — schedule identifier returned from `depositAndWithdraw` or `depositAndBridge`
 
 The function returns:
 
@@ -369,47 +371,70 @@ A user can swap tokens directly from their shielded balance using:
 
 ```typescript
 function swap(
-  erc20Tokens: ERC20Token[],
+  chainId: number,
+  erc20Addresses: string[],
   deltaAmounts: bigint[],
   externalActionId: ExternalActionId,
   swapData: string,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
 ): Promise<string>;
 ```
 
 where:
 
-- `externalActionId` identifies the external swap protocol to use. Possible values include:
-  - `ExternalActionId.Uniswap` - for Uniswap swaps
-  - `ExternalActionId.OneInch` - for 1Inch swaps
-  - `ExternalActionId.Odos` - for Odos swaps
-- `swapData` contains the encoded swap parameters specific to the chosen protocol
+- `externalActionId` — swap protocol to use (`ExternalActionId.Uniswap`, `ExternalActionId.OneInch`, `ExternalActionId.Odos`, etc.)
+- `swapData` — encoded swap parameters for the chosen protocol
+- `feeToken` — optional fee-payment token address
+- `feeStructureOverride` — optional custom fee structure
 
-**Getting swap calldata:**
+**Getting swap quotes and calldata:**
 
-To obtain the swap calldata using the Hinkal SDK, you can use the built-in swap data generation utilities.
+Fetch quotes from all supported aggregators for a chain in one call.
 
-To get swap data for 1Inch, you can use the `getOneInchPrice` function. This function fetches a quote from the 1Inch aggregator and returns both the expected output amount and the encoded swap data that can be passed to the `swap` function:
+**EVM chains:**
 
-**1Inch:**
+```typescript
+function getEvmSwapPrices(
+  chainId: number,
+  inSwapAmount: string,
+  inSwapTokenAddress: string,
+  outSwapTokenAddress: string,
+): Promise<EvmSwapPrices>;
+```
+
+```typescript
+type EvmSwapPrices = {
+  uniswap: { tokenPrice: bigint; poolFee: string } | null;
+  odos: { outSwapAmountValue: bigint; odosDataValue: string } | null;
+  oneInch: { outSwapAmountValue: bigint; oneInchDataValue: string } | null;
+};
+```
+
+Pass the swap calldata from the chosen quote to `swap` as `swapData`, with the matching `externalActionId`:
+
+- **Uniswap** — `uniswap.poolFee` with `ExternalActionId.Uniswap` (`uniswap.tokenPrice` is the quoted output amount)
+- **Odos** — `odos.odosDataValue` with `ExternalActionId.Odos`
+- **1Inch** — `oneInch.oneInchDataValue` with `ExternalActionId.OneInch`
+
+**Solana:**
 
 ```typescript
-function getOneInchPrice(
+function getSolanaSwapPrices(
   chainId: number,
-  inSwapToken: ERC20Token,
-  outSwapToken: ERC20Token,
   inSwapAmount: string,
-  slippagePercentage?: number,
-): Promise<{
-  outSwapAmountValue: bigint;
-  oneInchDataValue: string;
-}>;
+  inSwapTokenAddress: string,
+  outSwapTokenAddress: string,
+): Promise<SolanaSwapPrices>;
 ```
 
-Similar functions are available for other supported swap protocols:
+```typescript
+type SolanaSwapPrices = {
+  okx: { outSwapAmountValue: bigint; okxDataValue: string } | null;
+};
+```
 
-- **Uniswap:** `getUniswapPrice`
-- **Odos:** `getOdosPrice`
-- **LiFi:** `getLifiPrice`
+Pass `okx.okxDataValue` to `swap` as `swapData` with `ExternalActionId.Okx`.
 
 ### Interacting with smart contracts privately
 
@@ -418,44 +443,48 @@ The SDK lets you interact with any smart contract on the blockchain while keepin
 ```typescript
 function actionPrivateWallet(
   chainId: number,
-  erc20Tokens: ERC20Token[],
+  erc20Addresses: string[],
   deltaAmounts: bigint[],
   onChainCreation: boolean[],
   ops: string[],
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
 ): Promise<string>;
 ```
 
 Parameters:
 
-- `chainId` - the blockchain network identifier
-- `onChainCreation` - array of booleans indicating the direction of token changes: `true` for positive changes (tokens received), `false` for negative changes (tokens spent)
-- `ops` - array of encoded user operations to execute (see User operations below)
+- `chainId` — blockchain network identifier
+- `erc20Addresses` — token contract addresses involved in the action
+- `deltaAmounts` — token amount changes
+- `onChainCreation` — `true` for tokens received, `false` for tokens spent
+- `ops` — encoded user operations (see below)
+- `feeToken` — optional fee-payment token address
+- `feeStructureOverride` — optional custom fee structure
 
-User operations (`ops`) are encoded instructions that tell the Emporium contract what actions to perform. Each operation specifies a target contract, the function to call, and any necessary parameters. For example, to stake ETH with Lido, you would create an operation that calls Lido's `submit` function with the appropriate value.
-
-To generate user operations, a user will need the `emporiumOp` function.
+User operations (`ops`) tell the Emporium contract what to execute. Generate them with `emporiumOp`:
 
 ```typescript
 function emporiumOp(
-  contract: ethers.Contract | string;
-  func?: string;
-  args?: any[];
-  callDataString?: string;
-  invokeWallet?: boolean;
-  value?: bigint;
-): Promise<string>;
+  contract: ethers.Contract | string,
+  func?: string,
+  args?: unknown[],
+  callDataString?: string,
+  invokeWallet?: boolean,
+  value?: bigint,
+): string;
 ```
 
-The function accepts the following arguments:
+Arguments:
 
-1. `contract` _(required)_ - target address or contract instance (with address). The contract instance will be used to properly encode the call function, if any, in the custom operation.
-2. `func` _(optional)_ - the name of the function to be called on the target address.
-3. `args` _(optional)_ - arguments of the function to be called on the target address.
-4. `callDataString` _(optional)_ - pre-encoded calldata string. If provided, `func` and `args` should not be used.
-5. `invokeWallet` _(optional)_ - boolean flag that determines the type of interaction (see the stateless/stateful interactions below).
-6. `value` _(optional)_ - the value field to the user operation call.
+1. `contract` _(required)_ — target address or contract instance
+2. `func` _(optional)_ — function name to call
+3. `args` _(optional)_ — function arguments
+4. `callDataString` _(optional)_ — pre-encoded calldata; do not combine with `func` and `args`
+5. `invokeWallet` _(optional)_ — execute from a persistent wallet address (stateful interactions)
+6. `value` _(optional)_ — ETH/value sent with the call
 
-When the Emporium contract executes a user operation, it receives the data in this format:
+When the Emporium contract executes a user operation, it receives:
 
 ```solidity
 (address endpoint, bool invokeWallet, uint256 value, bytes data)
@@ -475,9 +504,9 @@ For example, consider exchanging USDC for ETH using a DEX. To perform a swap, th
 
 ```typescript
 const operations = [
-  emporiumOp({ contract: usdcContractInstance, func: 'approve', args: [swapRouterAddress, amountIn] }),
-  emporiumOp({ contract: swapRouterContractInstance, func: 'exactInputSingle', args: [swapSingleParams] }),
-  emporiumOp({ contract: wethContractInstance, func: 'withdraw', args: [amountOut] }),
+  hinkal.emporiumOp(usdcContractInstance, 'approve', [swapRouterAddress, amountIn]),
+  hinkal.emporiumOp(swapRouterContractInstance, 'exactInputSingle', [swapSingleParams]),
+  hinkal.emporiumOp(wethContractInstance, 'withdraw', [amountOut]),
 ];
 ```
 
@@ -493,13 +522,8 @@ Consider a scenario where you have already staked Curve LP tokens and want to cl
 
 ```typescript
 const operations = [
-  emporiumOp({ contract: lpTokenInstance, func: 'approve', args: [gaugeAddressInstance, amount], invokeWallet: true }),
-  emporiumOp({
-    contract: gaugeAddressInstance,
-    func: 'deposit',
-    args: [amount, invokeWalletAddress],
-    invokeWallet: true,
-  }),
+  hinkal.emporiumOp(lpTokenInstance, 'approve', [gaugeAddressInstance, amount], undefined, true),
+  hinkal.emporiumOp(gaugeAddressInstance, 'deposit', [amount, invokeWalletAddress], undefined, true),
 ];
 ```
 

package/common/src/crypto/babyJub.cjs

@@ -1 +1 @@
-require(`../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../constants/vite.constants.cjs`),t=require(`./BabyJubRN.cjs`);let n=require(`circomlibjs-hinkal-fork`);var r=new class{babyjub=void 0;async init(){this.babyjub||=e.isReactNative?new t.BabyJubRN:await(0,n.buildBabyjub)()}getJub(){return this.babyjub}},i=()=>r.getJub();exports.babyJubInstance=i,exports.jubHolder=r;
+require(`../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../constants/vite.constants.cjs`);let t=require(`circomlibjs-hinkal-fork`);var n=new class{babyjub=void 0;async init(){this.babyjub||=e.isReactNative?(0,t.buildBabyJubRN)():await(0,t.buildBabyjub)()}getJub(){return this.babyjub}},r=()=>n.getJub();exports.babyJubInstance=r,exports.jubHolder=n;

package/common/src/crypto/babyJub.mjs

@@ -1,10 +1,9 @@
 import { isReactNative as e } from "../constants/vite.constants.mjs";
-import { BabyJubRN as t } from "./BabyJubRN.mjs";
-import { buildBabyjub as n } from "circomlibjs-hinkal-fork";
+import { buildBabyJubRN as t, buildBabyjub as n } from "circomlibjs-hinkal-fork";
 var r = new class {
 	babyjub = void 0;
 	async init() {
-		this.babyjub ||= e ? new t() : await n();
+		this.babyjub ||= e ? t() : await n();
 	}
 	getJub() {
 		return this.babyjub;

package/common/src/crypto/eddsa.cjs

@@ -1 +1 @@
-require(`../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../constants/vite.constants.cjs`),t=require(`./EddsaRN.cjs`);let n=require(`circomlibjs-hinkal-fork`);var r=new class{eddsa=void 0;async init(){this.eddsa||=e.isReactNative?await t.buildEddsaRN():await(0,n.buildEddsa)()}getEddsa(){return this.eddsa}},i=()=>r.getEddsa();exports.eddsaHolder=r,exports.eddsaInstance=i;
+require(`../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../constants/vite.constants.cjs`);let t=require(`circomlibjs-hinkal-fork`);var n=new class{eddsa=void 0;async init(){this.eddsa||=e.isReactNative?await(0,t.buildEddsaRN)():await(0,t.buildEddsa)()}getEddsa(){return this.eddsa}},r=()=>n.getEddsa();exports.eddsaHolder=n,exports.eddsaInstance=r;

package/common/src/crypto/eddsa.mjs

@@ -1,10 +1,9 @@
 import { isReactNative as e } from "../constants/vite.constants.mjs";
-import { buildEddsaRN as t } from "./EddsaRN.mjs";
-import { buildEddsa as n } from "circomlibjs-hinkal-fork";
+import { buildEddsa as t, buildEddsaRN as n } from "circomlibjs-hinkal-fork";
 var r = new class {
 	eddsa = void 0;
 	async init() {
-		this.eddsa ||= e ? await t() : await n();
+		this.eddsa ||= e ? await n() : await t();
 	}
 	getEddsa() {
 		return this.eddsa;

package/common/src/crypto/poseidon.cjs

@@ -1 +1 @@
-const e=require(`../../../_virtual/_rolldown/runtime.cjs`),t=require(`../constants/vite.constants.cjs`),n=require(`../functions/utils/amounts.utils.cjs`);let r=require(`ethers`),i=require(`poseidon-lite`);i=e.__toESM(i);let a=require(`circomlibjs-hinkal-fork`);var o=()=>{let e=e=>{let t=i[`poseidon${e.length}`];if(!t)throw Error(`Poseidon: arity ${e.length} not supported (1..16)`);return t(e.map(e=>BigInt(e)))};return e.F={toString:e=>BigInt(e).toString()},e},s=new class{poseidon=void 0;async init(){this.poseidon||=t.isReactNative?o():await(0,a.buildPoseidon)()}getPoseidon(){return this.poseidon}};function c(...e){let t=s.getPoseidon();return n.toBigInt(t.F.toString(t(e)))}var l=(...e)=>{let t=s.getPoseidon();return r.ethers.toBeHex(t.F.toString(t([...e])))};exports.poseidonFunction=c,exports.poseidonHash=l,exports.poseidonHolder=s;
+require(`../../../_virtual/_rolldown/runtime.cjs`);const e=require(`../constants/vite.constants.cjs`),t=require(`../functions/utils/amounts.utils.cjs`);let n=require(`ethers`),r=require(`circomlibjs-hinkal-fork`);var i=new class{poseidon=void 0;async init(){this.poseidon||=e.isReactNative?(0,r.buildPoseidonRN)():await(0,r.buildPoseidon)()}getPoseidon(){return this.poseidon}};function a(...e){let n=i.getPoseidon();return t.toBigInt(n.F.toString(n(e)))}var o=(...e)=>{let t=i.getPoseidon();return n.ethers.toBeHex(t.F.toString(t([...e])))};exports.poseidonFunction=a,exports.poseidonHash=o,exports.poseidonHolder=i;

package/common/src/crypto/poseidon.mjs

@@ -1,32 +1,23 @@
 import { isReactNative as e } from "../constants/vite.constants.mjs";
 import { toBigInt as t } from "../functions/utils/amounts.utils.mjs";
 import { ethers as n } from "ethers";
-import * as r from "poseidon-lite";
-import { buildPoseidon as i } from "circomlibjs-hinkal-fork";
-//#region libs/shared/common/src/crypto/poseidon.ts
-var a = () => {
-	let e = (e) => {
-		let t = r[`poseidon${e.length}`];
-		if (!t) throw Error(`Poseidon: arity ${e.length} not supported (1..16)`);
-		return t(e.map((e) => BigInt(e)));
-	};
-	return e.F = { toString: (e) => BigInt(e).toString() }, e;
-}, o = new class {
+import { buildPoseidon as r, buildPoseidonRN as i } from "circomlibjs-hinkal-fork";
+var a = new class {
 	poseidon = void 0;
 	async init() {
-		this.poseidon ||= e ? a() : await i();
+		this.poseidon ||= e ? i() : await r();
 	}
 	getPoseidon() {
 		return this.poseidon;
 	}
 }();
-function s(...e) {
-	let n = o.getPoseidon();
+function o(...e) {
+	let n = a.getPoseidon();
 	return t(n.F.toString(n(e)));
 }
-var c = (...e) => {
-	let t = o.getPoseidon();
+var s = (...e) => {
+	let t = a.getPoseidon();
 	return n.toBeHex(t.F.toString(t([...e])));
 };
 //#endregion
-export { s as poseidonFunction, c as poseidonHash, o as poseidonHolder };
+export { o as poseidonFunction, s as poseidonHash, a as poseidonHolder };