@gurge/sdk 0.3.14 → 0.3.16

package/README.md

@@ -22,13 +22,13 @@ With Hinkal SDK, developers can:
 Using npm:
 
 ```sh
-npm install @hinkal/common
+npm install @hinkal/sdk
 ```
 
 Or, yarn:
 
 ```sh
-yarn add @hinkal/common
+yarn add @hinkal/sdk
 ```
 
 ## Usage
@@ -46,7 +46,7 @@ Initializing the SDK creates a `Hinkal` object that encapsulates:
 **ethers.js:**
 
 ```typescript
-import { prepareEthersHinkal } from '@hinkal/common/providers/prepareEthersHinkal';
+import { prepareEthersHinkal } from '@hinkal/sdk/providers/prepareEthersHinkal';
 // signer: ethers.Signer
 const hinkal = await prepareEthersHinkal(signer, hinkalConfig);
 ```
@@ -54,7 +54,7 @@ const hinkal = await prepareEthersHinkal(signer, hinkalConfig);
 **wagmi:**
 
 ```typescript
-import { prepareWagmiHinkal } from '@hinkal/common/providers/prepareWagmiHinkal';
+import { prepareWagmiHinkal } from '@hinkal/sdk/providers/prepareWagmiHinkal';
 // connector: wagmi.Connector
 // wagmiConfig: wagmi.Config
 const hinkal = await prepareWagmiHinkal(connector, wagmiConfig, hinkalConfig);
@@ -80,9 +80,95 @@ type HinkalConfig = {
    * Indicator controlling wether the proof should be constructed remotely in secure enclave. Defaults to true.
    */
   generateProofRemotely?: boolean;
+
+  /** Disables automatic merkle tree updates. Defaults to false. */
+  disableMerkleTreeUpdates?: boolean;
+
+  /** Override which Tron chain this Hinkal instance targets. */
+  tronChainOverride?: number;
 };
 ```
 
+### Identity persistence
+
+When a user connects their wallet, they sign a fixed login message to authenticate with Hinkal. That signature defines their Hinkal identity. Their shielded balances, transaction ability, and all private operations depend on it.
+
+Most wallets return the same signature every time for the same message. Some do not. Smart contract wallets, certain hardware wallets, and other non-deterministic signers may produce a different signature on each login, even for the same address and message.
+
+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.
+
+```typescript
+function storeAndGetInitialSignature(
+  authSignature: string,
+  isSolanaLedger?: boolean,
+  txMessageForSolanaLedger?: string,
+): Promise<string>;
+```
+
+Parameters:
+
+- `authSignature` — signature from the current login session
+- `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:
+
+```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.
+
+**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.
+
+Inside the secure enclave, Google Cloud KMS decrypts the symmetric key. Only then is the signature decrypted. The plaintext signature never leaves the enclave unprotected.
+
+At rest, only the encrypted signature and encrypted key are stored in the database. A caller cannot retrieve a stored signature by wallet address alone. Each request must include any valid signature that proves wallet ownership.
+
+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.
+
+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.
+
+Use `signSolanaLedgerMessage` to get both the signature and the transaction message, then pass them to `storeAndGetInitialSignature`:
+
+```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);
+```
+
+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.
+
+If your application caches the transaction message locally between sessions, pass the cached value as `txMessageForSolanaLedger` so the enclave can verify the correct payload.
+
 ### Shielded balance
 
 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:
@@ -188,9 +274,93 @@ 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) specifies a delay in milliseconds before the withdrawal completes
+- `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,
+  recipientAmounts: bigint[],
+  recipientAddresses: string[],
+  txCompletionTime?: number,
+  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.
 
+The function returns:
+
+```typescript
+type DepositAndSendExtendedResult = {
+  depositTxHash: string;
+  scheduleId: string;
+};
+```
+
+where:
+
+- `depositTxHash` is the on-chain hash of the deposit transaction
+- `scheduleId` is the relayer schedule identifier used to fetch withdrawal status
+
+### Checking scheduled send status
+
+After calling `depositAndWithdrawExtended`, a user can fetch the current status of the scheduled withdrawals using the returned `scheduleId`:
+
+```typescript
+function checkSendTransactionStatus(scheduleId: string): Promise<ScheduledTransactionByIdResponse>;
+```
+
+where:
+
+- `scheduleId` is the schedule identifier returned from an extended deposit-and-send call
+
+The function returns:
+
+```typescript
+type ScheduledTransactionByIdResponse = {
+  scheduleId: string;
+  chainId: number;
+  transactions: ScheduledTransactionItemStatus[];
+};
+
+type ScheduledTransactionItemStatus = {
+  status: ScheduledTransactionStatus;
+  scheduledTime: string;
+  txHash: string | null;
+};
+```
+
+where:
+
+- `scheduleId` is the schedule identifier
+- `chainId` is the chain on which the scheduled transactions are executed
+- `transactions` is the list of scheduled withdrawals, one entry per recipient
+  - `status` indicates the current state of a scheduled withdrawal
+  - `scheduledTime` is the planned execution time in ISO 8601 format
+  - `txHash` is the on-chain transaction hash once the withdrawal is sent on-chain, or `null` before submission
+
+Possible values for `ScheduledTransactionStatus` are:
+
+- `pending` — the withdrawal is scheduled and waiting for its execution time
+- `processing` — the relayer is currently submitting the withdrawal transaction on-chain
+- `waiting_for_relayer` — the relayer is busy; the withdrawal is queued to start
+- `sent_on_chain` — the withdrawal was submitted on-chain and `txHash` is available
+- `completed` — the withdrawal was confirmed on-chain
+- `failed` — the withdrawal transaction failed
+
 ### Swapping tokens from the shielded balance
 
 Swapping allows you to exchange tokens directly from your shielded balance without revealing your identity. The swap is executed through integrated DEX protocols (Uniswap, 1Inch, Odos) while keeping your transaction private. Your tokens are withdrawn from your shielded balance, swapped through the specified protocol, and the resulting tokens are deposited back into your shielded balance—all in a single private transaction.
@@ -338,41 +508,23 @@ In this example:
 - First operation approves the gauge contract to spend LP tokens, executed from the persistent wallet
 - Second operation deposits LP tokens into the gauge, with the wallet address as the recipient for reward tracking
 
-## Access Tokens
-
-Access tokens are required credentials that allow users to interact with Hinkal's privacy smart contracts. Think of them as a "passport" that proves you've completed the necessary compliance verification.
-
-Before you can deposit funds, make transfers, or perform any private transactions through Hinkal, you must have a valid access token associated with your wallet. This is a one-time requirement—once you have an access token, you can use Hinkal's features without needing to verify again.
-
-To check whether a user already has an access token on a specific chain, use the `checkAccessToken` function:
-
-```typescript
-function checkAccessToken(): Promise<boolean>;
-```
-
-If the user does not have an access token, they need to complete a compliance verification through one of Hinkal's supported compliance providers. This is a one-time process that verifies the user meets regulatory requirements before they can use the privacy features.
-
-To get a list of all available compliance providers that can be used for verification:
-
-```typescript
-function getSupportedPassportLinks(): string[];
-```
-
-After passing the compliance check with one of the supported providers, the access token will be automatically minted during the user's first transaction with Hinkal. This token is stored on-chain and grants the user permission to interact with Hinkal's privacy contracts.
-
 ## Supported Chains
 
 Hinkal SDK is available on the following blockchain networks:
 
-| Chain    | Chain ID | Status  |
-| -------- | -------- | ------- |
-| Ethereum | 1        | ✅ Live |
-| Polygon  | 137      | ✅ Live |
-| Base     | 8453     | ✅ Live |
-| Arbitrum | 42161    | ✅ Live |
-| Optimism | 10       | ✅ Live |
-| Solana   | -        | ✅ Live |
-| Tron     | -        | ✅ Live |
+| Chain           | Chain ID   | Status  |
+| --------------- | ---------- | ------- |
+| Ethereum        | 1          | ✅ Live |
+| Arbitrum        | 42161      | ✅ Live |
+| Optimism        | 10         | ✅ Live |
+| Polygon         | 137        | ✅ Live |
+| Base            | 8453       | ✅ Live |
+| Solana          | 501        | ✅ Live |
+| Tron            | 728126428  | ✅ Live |
+| Tempo           | 4217       | ✅ Live |
+| Arc Testnet     | 5042002    | ✅ Live |
+| Sepolia Testnet | 11155111   | ✅ Live |
+| Tron Nile       | 3448148188 | ✅ Live |
 
 Each chain supports the full suite of Hinkal privacy features including shielding, transfers, and confidential interactions with DeFi protocols.
 

package/common/src/API/API.cjs

@@ -0,0 +1 @@
+const e=require(`./scheduled-transactions-calls.cjs`),t=require(`./relayCalls.cjs`),n=require(`./getTokenPrice.cjs`),r=require(`./callOdosAPI.cjs`),i=require(`./simulate-transaction.cjs`),a=require(`./simulate-batch-tx.cjs`),o=require(`./token-calls.cjs`),s=require(`./get-token-data.cjs`),c=require(`./enclaveUtxoCalls.cjs`),l=require(`./generate-trading-points.cjs`),u=require(`./brotherhoodCalls.cjs`),d=require(`./leaderboardCalls.cjs`),f=require(`./referralsCalls.cjs`),p=require(`./accessCodeCalls.cjs`),m=require(`./rewardsUserCalls.cjs`),h=require(`./weeklyAnalyticCalls.cjs`),g=require(`./send-telegram-callback.cjs`),_=require(`./proxyAccountsCalls.cjs`),v=require(`./callMonitor.cjs`),y=require(`./callRelayer.cjs`),b=require(`./seedless-calls.cjs`),x=require(`./temporaryWalletCalls.cjs`),S=require(`./onrampCalls.cjs`),C=require(`./get-token-price-chart-data.cjs`),w=require(`./privacy-score-calls.cjs`),T=require(`./privateSendRecipientInfoCalls.cjs`),E=require(`./privateSendNonceCalls.cjs`),D=require(`./snapshot-event-calls.cjs`),O=require(`./privateSendEmailNotificationsCalls.cjs`),k=require(`./tronSubsidyCalls.cjs`),A=require(`./dashboardAccountCalls.cjs`),j=require(`./dashboardContactCalls.cjs`),M=require(`./dashboardPayoutCalls.cjs`),N=require(`./dashboardAccountMemberCalls.cjs`),P=require(`./dashboardBalanceCalls.cjs`),F=require(`./dashboardTransactionCalls.cjs`);var I={getTokenPrices:n.getTokenPrices,getOdosPriceForToken:r.getOdosPriceForToken,getTokenPriceChartData:C.getTokenPriceChartData,getTokenPreviousDayPrices:n.getTokenPreviousDayPrices,getIdleRelay:t.getIdleRelay,generateTradingPoints:l.generateTradingPoints,generateAumPoints:l.generateAumPoints,getBrotherhoodUsers:u.getBrotherhoodUsers,getCurrentUserBrotherhoodUsers:u.getCurrentUserBrotherhoodUsers,getBrotherhood:u.getBrotherhood,editBrotherhood:u.editBrotherhood,createBrotherhood:u.createBrotherhood,getCurrentUserBrotherhood:u.getCurrentUserBrotherhood,getPublicBrotherhoods:u.getPublicBrotherhoods,leaveBrotherhood:u.leaveBrotherhood,joinBrotherhood:u.joinBrotherhood,getUserAnalytics:h.getUserAnalytics,getBrotherhoodAnalytics:h.getBrotherhoodAnalytics,connectRewardsUser:m.connectRewardsUser,updateRewardsUser:m.updateRewardsUser,getRewardsUser:m.getRewardsUser,checkUsernameAvailability:m.checkUsernameAvailability,disconnectSocialNetwork:m.disconnectSocialNetwork,getUserCurrentLeaderboard:d.getUserCurrentLeaderboard,getBrotherhoodsLeaderboard:d.getBrotherhoodsLeaderboard,getCurrentUserReferral:f.getCurrentUserReferral,submitReferralCode:f.submitReferralCode,getCurrentUserAppliedReferralCode:f.getCurrentUserAppliedReferralCode,submitAccessCode:p.submitAccessCode,getAccessCodeBenefits:p.getAccessCodeBenefits,simulateTransaction:i.simulateTransaction,simulateBatchTx:a.simulateBatchTx,tokensInfoCall:o.tokensInfoCall,getTokenData:s.getTokenData,decryptUtxoEnclaveCall:c.decryptUtxoEnclaveCall,storeUtxoEnclaveCall:c.storeUtxoEnclaveCall,getUtxosEnclaveCall:c.getUtxosEnclaveCall,sendTelegramCallback:g.sendTelegramCallback,getTasksProgress:m.getTasksProgress,getSwapStreak:m.getSwapStreak,getProxyAccounts:_.getProxyAccounts,updateProxyAccounts:_.updateProxyAccounts,getNftMultiplier:m.getNftMultiplier,monitor:v.monitor,callRelayerSolanaTransactBatchAPI:y.callRelayerSolanaTransactBatchAPI,seedlessInit:b.seedlessInit,seedlessBackup:b.seedlessBackup,seedlessCheckPassword:b.seedlessCheckPassword,seedlessStatus:b.seedlessStatus,seedlessSalt:b.seedlessSalt,getScheduledTransactions:e.getScheduledTransactions,getTemporaryWalletNonces:x.getTemporaryWalletNonces,addTemporaryWalletNonce:x.addTemporaryWalletNonce,removeTemporaryWalletNonce:x.removeTemporaryWalletNonce,encodeMoonPayBuyUrl:S.encodeMoonPayBuyUrl,generateMoonPayQuote:S.generateMoonPayQuote,getPrivateTransactionRatio:w.getPrivateTransactionRatio,savePrivacyScoreAndGetPrivacyRank:w.savePrivacyScoreAndGetPrivacyRank,allocatePrivateSendRecipientInfos:T.allocatePrivateSendRecipientInfos,syncPrivateSendNonce:E.syncPrivateSendNonce,reservePrivateSendNonceRange:E.reservePrivateSendNonceRange,getSnapshotServerEvents:D.getSnapshotServerEvents,sendPrivateSendEmailNotifications:O.sendPrivateSendEmailNotifications,checkTronSubsidyEligibility:k.checkTronSubsidyEligibility,recordTronSubsidyUsage:k.recordTronSubsidyUsage,getDashboardAccount:A.getDashboardAccount,updateDashboardAccount:A.updateDashboardAccount,addDashboardContact:j.addDashboardContact,deleteDashboardContact:j.deleteDashboardContact,deleteDashboardAccount:A.deleteDashboardAccount,updateDashboardContact:j.updateDashboardContact,getDashboardContacts:j.getDashboardContacts,updateUserProfile:N.updateUserProfile,sendDashboardInvitationEmail:N.sendDashboardInvitationEmail,removeMember:N.removeMember,editMember:N.editMember,createDashboardPayout:M.createDashboardPayout,getDashboardPayouts:M.getDashboardPayouts,syncDashboardBalances:P.syncDashboardBalances,getDashboardBalances:P.getDashboardBalances,changePayoutStatus:M.changePayoutStatus,createDashboardTransactions:F.createDashboardTransactions,getDashboardTransactions:F.getDashboardTransactions};exports.API=I;

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

@@ -0,0 +1,122 @@
+import { getIdleRelay } from './relayCalls';
+import { getTokenPreviousDayPrices, getTokenPrices } from './getTokenPrice';
+import { getOdosPriceForToken } from './callOdosAPI';
+import { simulateTransaction } from './simulate-transaction';
+import { simulateBatchTx } from './simulate-batch-tx';
+import { tokensInfoCall } from './token-calls';
+import { getTokenData } from './get-token-data';
+import { decryptUtxoEnclaveCall, getUtxosEnclaveCall, storeUtxoEnclaveCall } from './enclaveUtxoCalls';
+import { generateAumPoints, generateTradingPoints } from './generate-trading-points';
+import { createBrotherhood, editBrotherhood, getBrotherhood, getBrotherhoodUsers, getCurrentUserBrotherhood, getCurrentUserBrotherhoodUsers, getPublicBrotherhoods, joinBrotherhood, leaveBrotherhood } from './brotherhoodCalls';
+import { getBrotherhoodsLeaderboard, getUserCurrentLeaderboard } from './leaderboardCalls';
+import { getCurrentUserAppliedReferralCode, getCurrentUserReferral, submitReferralCode } from './referralsCalls';
+import { getAccessCodeBenefits, submitAccessCode } from './accessCodeCalls';
+import { checkUsernameAvailability, connectRewardsUser, disconnectSocialNetwork, getNftMultiplier, getRewardsUser, getSwapStreak, getTasksProgress, updateRewardsUser } from './rewardsUserCalls';
+import { getBrotherhoodAnalytics, getUserAnalytics } from './weeklyAnalyticCalls';
+import { sendTelegramCallback } from './send-telegram-callback';
+import { getProxyAccounts, updateProxyAccounts } from './proxyAccountsCalls';
+import { monitor } from './callMonitor';
+import { callRelayerSolanaTransactBatchAPI } from './callRelayer';
+import { seedlessBackup, seedlessCheckPassword, seedlessInit, seedlessSalt, seedlessStatus } from './seedless-calls';
+import { getScheduledTransactions } from './scheduled-transactions-calls';
+import { addTemporaryWalletNonce, getTemporaryWalletNonces, removeTemporaryWalletNonce } from './temporaryWalletCalls';
+import { encodeMoonPayBuyUrl, generateMoonPayQuote } from './onrampCalls';
+import { getTokenPriceChartData } from './get-token-price-chart-data';
+import { getPrivateTransactionRatio, savePrivacyScoreAndGetPrivacyRank } from './privacy-score-calls';
+import { allocatePrivateSendRecipientInfos } from './privateSendRecipientInfoCalls';
+import { reservePrivateSendNonceRange, syncPrivateSendNonce } from './privateSendNonceCalls';
+import { getSnapshotServerEvents } from './snapshot-event-calls';
+import { sendPrivateSendEmailNotifications } from './privateSendEmailNotificationsCalls';
+import { checkTronSubsidyEligibility, recordTronSubsidyUsage } from './tronSubsidyCalls';
+import { deleteDashboardAccount, getDashboardAccount, updateDashboardAccount } from './dashboardAccountCalls';
+import { addDashboardContact, deleteDashboardContact, getDashboardContacts, updateDashboardContact } from './dashboardContactCalls';
+import { changePayoutStatus, createDashboardPayout, getDashboardPayouts } from './dashboardPayoutCalls';
+import { editMember, removeMember, sendDashboardInvitationEmail, updateUserProfile } from './dashboardAccountMemberCalls';
+import { getDashboardBalances, syncDashboardBalances } from './dashboardBalanceCalls';
+import { createDashboardTransactions, getDashboardTransactions } from './dashboardTransactionCalls';
+export type IAPI = {
+    getTokenPrices: typeof getTokenPrices;
+    getOdosPriceForToken: typeof getOdosPriceForToken;
+    getTokenPriceChartData: typeof getTokenPriceChartData;
+    getTokenPreviousDayPrices: typeof getTokenPreviousDayPrices;
+    getIdleRelay: typeof getIdleRelay;
+    simulateTransaction: typeof simulateTransaction;
+    simulateBatchTx: typeof simulateBatchTx;
+    tokensInfoCall: typeof tokensInfoCall;
+    getTokenData: typeof getTokenData;
+    decryptUtxoEnclaveCall: typeof decryptUtxoEnclaveCall;
+    storeUtxoEnclaveCall: typeof storeUtxoEnclaveCall;
+    getUtxosEnclaveCall: typeof getUtxosEnclaveCall;
+    generateTradingPoints: typeof generateTradingPoints;
+    getBrotherhoodUsers: typeof getBrotherhoodUsers;
+    getCurrentUserBrotherhoodUsers: typeof getCurrentUserBrotherhoodUsers;
+    editBrotherhood: typeof editBrotherhood;
+    createBrotherhood: typeof createBrotherhood;
+    getCurrentUserBrotherhood: typeof getCurrentUserBrotherhood;
+    getPublicBrotherhoods: typeof getPublicBrotherhoods;
+    leaveBrotherhood: typeof leaveBrotherhood;
+    joinBrotherhood: typeof joinBrotherhood;
+    getUserAnalytics: typeof getUserAnalytics;
+    connectRewardsUser: typeof connectRewardsUser;
+    getBrotherhood: typeof getBrotherhood;
+    updateRewardsUser: typeof updateRewardsUser;
+    getRewardsUser: typeof getRewardsUser;
+    checkUsernameAvailability: typeof checkUsernameAvailability;
+    getUserCurrentLeaderboard: typeof getUserCurrentLeaderboard;
+    getBrotherhoodsLeaderboard: typeof getBrotherhoodsLeaderboard;
+    getCurrentUserReferral: typeof getCurrentUserReferral;
+    submitReferralCode: typeof submitReferralCode;
+    getCurrentUserAppliedReferralCode: typeof getCurrentUserAppliedReferralCode;
+    submitAccessCode: typeof submitAccessCode;
+    getAccessCodeBenefits: typeof getAccessCodeBenefits;
+    sendTelegramCallback: typeof sendTelegramCallback;
+    generateAumPoints: typeof generateAumPoints;
+    getSwapStreak: typeof getSwapStreak;
+    getBrotherhoodAnalytics: typeof getBrotherhoodAnalytics;
+    getTasksProgress: typeof getTasksProgress;
+    disconnectSocialNetwork: typeof disconnectSocialNetwork;
+    getProxyAccounts: typeof getProxyAccounts;
+    updateProxyAccounts: typeof updateProxyAccounts;
+    getNftMultiplier: typeof getNftMultiplier;
+    monitor: typeof monitor;
+    callRelayerSolanaTransactBatchAPI: typeof callRelayerSolanaTransactBatchAPI;
+    seedlessInit: typeof seedlessInit;
+    seedlessBackup: typeof seedlessBackup;
+    seedlessCheckPassword: typeof seedlessCheckPassword;
+    seedlessStatus: typeof seedlessStatus;
+    seedlessSalt: typeof seedlessSalt;
+    getScheduledTransactions: typeof getScheduledTransactions;
+    getTemporaryWalletNonces: typeof getTemporaryWalletNonces;
+    addTemporaryWalletNonce: typeof addTemporaryWalletNonce;
+    removeTemporaryWalletNonce: typeof removeTemporaryWalletNonce;
+    encodeMoonPayBuyUrl: typeof encodeMoonPayBuyUrl;
+    generateMoonPayQuote: typeof generateMoonPayQuote;
+    getPrivateTransactionRatio: typeof getPrivateTransactionRatio;
+    savePrivacyScoreAndGetPrivacyRank: typeof savePrivacyScoreAndGetPrivacyRank;
+    allocatePrivateSendRecipientInfos: typeof allocatePrivateSendRecipientInfos;
+    syncPrivateSendNonce: typeof syncPrivateSendNonce;
+    reservePrivateSendNonceRange: typeof reservePrivateSendNonceRange;
+    getSnapshotServerEvents: typeof getSnapshotServerEvents;
+    sendPrivateSendEmailNotifications: typeof sendPrivateSendEmailNotifications;
+    checkTronSubsidyEligibility: typeof checkTronSubsidyEligibility;
+    recordTronSubsidyUsage: typeof recordTronSubsidyUsage;
+    getDashboardAccount: typeof getDashboardAccount;
+    updateDashboardAccount: typeof updateDashboardAccount;
+    deleteDashboardAccount: typeof deleteDashboardAccount;
+    updateUserProfile: typeof updateUserProfile;
+    addDashboardContact: typeof addDashboardContact;
+    deleteDashboardContact: typeof deleteDashboardContact;
+    updateDashboardContact: typeof updateDashboardContact;
+    getDashboardContacts: typeof getDashboardContacts;
+    sendDashboardInvitationEmail: typeof sendDashboardInvitationEmail;
+    removeMember: typeof removeMember;
+    editMember: typeof editMember;
+    createDashboardPayout: typeof createDashboardPayout;
+    getDashboardPayouts: typeof getDashboardPayouts;
+    syncDashboardBalances: typeof syncDashboardBalances;
+    getDashboardBalances: typeof getDashboardBalances;
+    changePayoutStatus: typeof changePayoutStatus;
+    createDashboardTransactions: typeof createDashboardTransactions;
+    getDashboardTransactions: typeof getDashboardTransactions;
+};
+export declare const API: IAPI;

package/common/src/API/API.mjs

@@ -0,0 +1,124 @@
+import { getScheduledTransactions as e } from "./scheduled-transactions-calls.mjs";
+import { getIdleRelay as t } from "./relayCalls.mjs";
+import { getTokenPreviousDayPrices as n, getTokenPrices as r } from "./getTokenPrice.mjs";
+import { getOdosPriceForToken as i } from "./callOdosAPI.mjs";
+import { simulateTransaction as a } from "./simulate-transaction.mjs";
+import { simulateBatchTx as o } from "./simulate-batch-tx.mjs";
+import { tokensInfoCall as s } from "./token-calls.mjs";
+import { getTokenData as c } from "./get-token-data.mjs";
+import { decryptUtxoEnclaveCall as l, getUtxosEnclaveCall as u, storeUtxoEnclaveCall as d } from "./enclaveUtxoCalls.mjs";
+import { generateAumPoints as f, generateTradingPoints as p } from "./generate-trading-points.mjs";
+import { createBrotherhood as m, editBrotherhood as h, getBrotherhood as g, getBrotherhoodUsers as _, getCurrentUserBrotherhood as v, getCurrentUserBrotherhoodUsers as y, getPublicBrotherhoods as b, joinBrotherhood as x, leaveBrotherhood as S } from "./brotherhoodCalls.mjs";
+import { getBrotherhoodsLeaderboard as C, getUserCurrentLeaderboard as w } from "./leaderboardCalls.mjs";
+import { getCurrentUserAppliedReferralCode as T, getCurrentUserReferral as E, submitReferralCode as D } from "./referralsCalls.mjs";
+import { getAccessCodeBenefits as O, submitAccessCode as k } from "./accessCodeCalls.mjs";
+import { checkUsernameAvailability as A, connectRewardsUser as j, disconnectSocialNetwork as M, getNftMultiplier as N, getRewardsUser as P, getSwapStreak as F, getTasksProgress as I, updateRewardsUser as L } from "./rewardsUserCalls.mjs";
+import { getBrotherhoodAnalytics as R, getUserAnalytics as z } from "./weeklyAnalyticCalls.mjs";
+import { sendTelegramCallback as B } from "./send-telegram-callback.mjs";
+import { getProxyAccounts as V, updateProxyAccounts as H } from "./proxyAccountsCalls.mjs";
+import { monitor as U } from "./callMonitor.mjs";
+import { callRelayerSolanaTransactBatchAPI as W } from "./callRelayer.mjs";
+import { seedlessBackup as G, seedlessCheckPassword as K, seedlessInit as q, seedlessSalt as J, seedlessStatus as Y } from "./seedless-calls.mjs";
+import { addTemporaryWalletNonce as X, getTemporaryWalletNonces as Z, removeTemporaryWalletNonce as Q } from "./temporaryWalletCalls.mjs";
+import { encodeMoonPayBuyUrl as $, generateMoonPayQuote as ee } from "./onrampCalls.mjs";
+import { getTokenPriceChartData as te } from "./get-token-price-chart-data.mjs";
+import { getPrivateTransactionRatio as ne, savePrivacyScoreAndGetPrivacyRank as re } from "./privacy-score-calls.mjs";
+import { allocatePrivateSendRecipientInfos as ie } from "./privateSendRecipientInfoCalls.mjs";
+import { reservePrivateSendNonceRange as ae, syncPrivateSendNonce as oe } from "./privateSendNonceCalls.mjs";
+import { getSnapshotServerEvents as se } from "./snapshot-event-calls.mjs";
+import { sendPrivateSendEmailNotifications as ce } from "./privateSendEmailNotificationsCalls.mjs";
+import { checkTronSubsidyEligibility as le, recordTronSubsidyUsage as ue } from "./tronSubsidyCalls.mjs";
+import { deleteDashboardAccount as de, getDashboardAccount as fe, updateDashboardAccount as pe } from "./dashboardAccountCalls.mjs";
+import { addDashboardContact as me, deleteDashboardContact as he, getDashboardContacts as ge, updateDashboardContact as _e } from "./dashboardContactCalls.mjs";
+import { changePayoutStatus as ve, createDashboardPayout as ye, getDashboardPayouts as be } from "./dashboardPayoutCalls.mjs";
+import { editMember as xe, removeMember as Se, sendDashboardInvitationEmail as Ce, updateUserProfile as we } from "./dashboardAccountMemberCalls.mjs";
+import { getDashboardBalances as Te, syncDashboardBalances as Ee } from "./dashboardBalanceCalls.mjs";
+import { createDashboardTransactions as De, getDashboardTransactions as Oe } from "./dashboardTransactionCalls.mjs";
+//#region libs/shared/common/src/API/API.ts
+var ke = {
+	getTokenPrices: r,
+	getOdosPriceForToken: i,
+	getTokenPriceChartData: te,
+	getTokenPreviousDayPrices: n,
+	getIdleRelay: t,
+	generateTradingPoints: p,
+	generateAumPoints: f,
+	getBrotherhoodUsers: _,
+	getCurrentUserBrotherhoodUsers: y,
+	getBrotherhood: g,
+	editBrotherhood: h,
+	createBrotherhood: m,
+	getCurrentUserBrotherhood: v,
+	getPublicBrotherhoods: b,
+	leaveBrotherhood: S,
+	joinBrotherhood: x,
+	getUserAnalytics: z,
+	getBrotherhoodAnalytics: R,
+	connectRewardsUser: j,
+	updateRewardsUser: L,
+	getRewardsUser: P,
+	checkUsernameAvailability: A,
+	disconnectSocialNetwork: M,
+	getUserCurrentLeaderboard: w,
+	getBrotherhoodsLeaderboard: C,
+	getCurrentUserReferral: E,
+	submitReferralCode: D,
+	getCurrentUserAppliedReferralCode: T,
+	submitAccessCode: k,
+	getAccessCodeBenefits: O,
+	simulateTransaction: a,
+	simulateBatchTx: o,
+	tokensInfoCall: s,
+	getTokenData: c,
+	decryptUtxoEnclaveCall: l,
+	storeUtxoEnclaveCall: d,
+	getUtxosEnclaveCall: u,
+	sendTelegramCallback: B,
+	getTasksProgress: I,
+	getSwapStreak: F,
+	getProxyAccounts: V,
+	updateProxyAccounts: H,
+	getNftMultiplier: N,
+	monitor: U,
+	callRelayerSolanaTransactBatchAPI: W,
+	seedlessInit: q,
+	seedlessBackup: G,
+	seedlessCheckPassword: K,
+	seedlessStatus: Y,
+	seedlessSalt: J,
+	getScheduledTransactions: e,
+	getTemporaryWalletNonces: Z,
+	addTemporaryWalletNonce: X,
+	removeTemporaryWalletNonce: Q,
+	encodeMoonPayBuyUrl: $,
+	generateMoonPayQuote: ee,
+	getPrivateTransactionRatio: ne,
+	savePrivacyScoreAndGetPrivacyRank: re,
+	allocatePrivateSendRecipientInfos: ie,
+	syncPrivateSendNonce: oe,
+	reservePrivateSendNonceRange: ae,
+	getSnapshotServerEvents: se,
+	sendPrivateSendEmailNotifications: ce,
+	checkTronSubsidyEligibility: le,
+	recordTronSubsidyUsage: ue,
+	getDashboardAccount: fe,
+	updateDashboardAccount: pe,
+	addDashboardContact: me,
+	deleteDashboardContact: he,
+	deleteDashboardAccount: de,
+	updateDashboardContact: _e,
+	getDashboardContacts: ge,
+	updateUserProfile: we,
+	sendDashboardInvitationEmail: Ce,
+	removeMember: Se,
+	editMember: xe,
+	createDashboardPayout: ye,
+	getDashboardPayouts: be,
+	syncDashboardBalances: Ee,
+	getDashboardBalances: Te,
+	changePayoutStatus: ve,
+	createDashboardTransactions: De,
+	getDashboardTransactions: Oe
+};
+//#endregion
+export { ke as API };

package/common/src/API/TokenCallsCachedHelper.cjs

@@ -0,0 +1 @@
+const e=require(`../functions/utils/caseInsensitive.utils.cjs`),t=require(`../constants/server.constants.cjs`),n=require(`./getServerURL.cjs`),r=require(`../data-structures/http/HttpClient.cjs`);require(`../data-structures/http/index.cjs`);var i=new class{tokenCache=new Map;requestCache=new Map;post(e,t){return r.httpClient.post(`${n.SERVER_URL}${e}`,t)}cachedPost(e,t,n){let r=this.requestCache.get(e);if(r)return r;let i=this.postWithCacheCleanupOnError(e,t,n);return this.requestCache.set(e,i),i}async postWithCacheCleanupOnError(e,t,n){try{return await this.post(t,n)}catch(t){throw this.requestCache.delete(e),t}}storeTokensInCache(t,n){if(!n.length)return;let r=(this.tokenCache.get(t)??[]).filter(t=>!n.some(n=>e.caseInsensitiveEqual(t.erc20TokenAddress,n.erc20TokenAddress)));this.tokenCache.set(t,[...r,...n])}async getCachedOrFetch(e,t,n,r,i){let a=e=>this.tokenCache.get(t)?.find(t=>r(t,e)),o=e.filter(e=>!a(e));if(o.length){let e=`${n}:${t}:${[...o].sort().join(`,`)}`;try{let r=await this.cachedPost(e,n,i(o));this.storeTokensInCache(t,r.filter(e=>!!e))}finally{this.requestCache.delete(e)}}return e.map(a)}async tokensInfoCall(n,r,i=!1){return r.length?this.getCachedOrFetch(r,n,t.API_CONFIG.ROUTES.getTokensInfo,(t,n)=>e.caseInsensitiveEqual(t.erc20TokenAddress,n),e=>({chainId:n,tokenAddresses:e,waitForOffsetUpdate:i})):[]}getTokensBySymbolsCall(n,r){return r.length?this.getCachedOrFetch(r,n,t.API_CONFIG.ROUTES.getTokensBySymbols,(t,n)=>e.caseInsensitiveEqual(t.symbol,n),e=>({chainId:n,symbols:e})):Promise.resolve([])}async getTokensForChainCall(e){let n=(await this.cachedPost(`tokens-for-chain:${e}`,t.API_CONFIG.ROUTES.getTokensForChain,{chainId:e})).filter(e=>!!e);return this.storeTokensInCache(e,n),n}};exports.tokenCallsCachedHelper=i;

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

@@ -0,0 +1,15 @@
+import { ERC20Token } from '../types';
+declare class TokenCallsCachedHelper {
+    private tokenCache;
+    private requestCache;
+    private post;
+    private cachedPost;
+    private postWithCacheCleanupOnError;
+    private storeTokensInCache;
+    private getCachedOrFetch;
+    tokensInfoCall(chainId: number, tokenAddresses: string[], waitForOffsetUpdate?: boolean): Promise<(ERC20Token | undefined)[]>;
+    getTokensBySymbolsCall(chainId: number, symbols: string[]): Promise<(ERC20Token | undefined)[]>;
+    getTokensForChainCall(chainId: number): Promise<ERC20Token[]>;
+}
+export declare const tokenCallsCachedHelper: TokenCallsCachedHelper;
+export {};

package/common/src/API/TokenCallsCachedHelper.mjs

@@ -0,0 +1,62 @@
+import { caseInsensitiveEqual as e } from "../functions/utils/caseInsensitive.utils.mjs";
+import { API_CONFIG as t } from "../constants/server.constants.mjs";
+import { SERVER_URL as n } from "./getServerURL.mjs";
+import { httpClient as r } from "../data-structures/http/HttpClient.mjs";
+import "../data-structures/http/index.mjs";
+var i = new class {
+	tokenCache = /* @__PURE__ */ new Map();
+	requestCache = /* @__PURE__ */ new Map();
+	post(e, t) {
+		return r.post(`${n}${e}`, t);
+	}
+	cachedPost(e, t, n) {
+		let r = this.requestCache.get(e);
+		if (r) return r;
+		let i = this.postWithCacheCleanupOnError(e, t, n);
+		return this.requestCache.set(e, i), i;
+	}
+	async postWithCacheCleanupOnError(e, t, n) {
+		try {
+			return await this.post(t, n);
+		} catch (t) {
+			throw this.requestCache.delete(e), t;
+		}
+	}
+	storeTokensInCache(t, n) {
+		if (!n.length) return;
+		let r = (this.tokenCache.get(t) ?? []).filter((t) => !n.some((n) => e(t.erc20TokenAddress, n.erc20TokenAddress)));
+		this.tokenCache.set(t, [...r, ...n]);
+	}
+	async getCachedOrFetch(e, t, n, r, i) {
+		let a = (e) => this.tokenCache.get(t)?.find((t) => r(t, e)), o = e.filter((e) => !a(e));
+		if (o.length) {
+			let e = `${n}:${t}:${[...o].sort().join(",")}`;
+			try {
+				let r = await this.cachedPost(e, n, i(o));
+				this.storeTokensInCache(t, r.filter((e) => !!e));
+			} finally {
+				this.requestCache.delete(e);
+			}
+		}
+		return e.map(a);
+	}
+	async tokensInfoCall(n, r, i = !1) {
+		return r.length ? this.getCachedOrFetch(r, n, t.ROUTES.getTokensInfo, (t, n) => e(t.erc20TokenAddress, n), (e) => ({
+			chainId: n,
+			tokenAddresses: e,
+			waitForOffsetUpdate: i
+		})) : [];
+	}
+	getTokensBySymbolsCall(n, r) {
+		return r.length ? this.getCachedOrFetch(r, n, t.ROUTES.getTokensBySymbols, (t, n) => e(t.symbol, n), (e) => ({
+			chainId: n,
+			symbols: e
+		})) : Promise.resolve([]);
+	}
+	async getTokensForChainCall(e) {
+		let n = (await this.cachedPost(`tokens-for-chain:${e}`, t.ROUTES.getTokensForChain, { chainId: e })).filter((e) => !!e);
+		return this.storeTokensInCache(e, n), n;
+	}
+}();
+//#endregion
+export { i as tokenCallsCachedHelper };

package/common/src/API/admin-calls.cjs

@@ -0,0 +1 @@
+const e=require(`../constants/server.constants.cjs`),t=require(`./getServerURL.cjs`),n=require(`../data-structures/http/HttpClient.cjs`);require(`../data-structures/http/index.cjs`);var r=r=>n.httpClient.post(`${t.RELAYER_URL}${e.RELAYER_CONFIG.emitTxPublicData}`,{adminData:r});exports.emitTxPublicData=r;

package/common/src/API/admin-calls.mjs

@@ -0,0 +1,8 @@
+import { RELAYER_CONFIG as e } from "../constants/server.constants.mjs";
+import { RELAYER_URL as t } from "./getServerURL.mjs";
+import { httpClient as n } from "../data-structures/http/HttpClient.mjs";
+import "../data-structures/http/index.mjs";
+//#region libs/shared/common/src/API/admin-calls.ts
+var r = (r) => n.post(`${t}${e.emitTxPublicData}`, { adminData: r });
+//#endregion
+export { r as emitTxPublicData };

package/common/src/API/callLifiAPI.cjs

@@ -0,0 +1 @@
+require(`../constants/server.constants.cjs`),require(`./getServerURL.cjs`),require(`../data-structures/http/index.cjs`);

package/common/src/API/callLifiAPI.mjs

@@ -0,0 +1,3 @@
+import "../constants/server.constants.mjs";
+import "./getServerURL.mjs";
+import "../data-structures/http/index.mjs";

package/common/src/API/callMonitor.cjs

@@ -0,0 +1 @@
+const e=require(`../constants/server.constants.cjs`),t=require(`./getServerURL.cjs`),n=require(`../data-structures/http/HttpClient.cjs`);require(`../data-structures/http/index.cjs`);var r=r=>n.httpClient.post(`${t.SERVER_URL}${e.API_CONFIG.ROUTES.monitor}`,{address:r});exports.monitor=r;

package/common/src/API/callMonitor.mjs

@@ -0,0 +1,8 @@
+import { API_CONFIG as e } from "../constants/server.constants.mjs";
+import { SERVER_URL as t } from "./getServerURL.mjs";
+import { httpClient as n } from "../data-structures/http/HttpClient.mjs";
+import "../data-structures/http/index.mjs";
+//#region libs/shared/common/src/API/callMonitor.ts
+var r = (r) => n.post(`${t}${e.ROUTES.monitor}`, { address: r });
+//#endregion
+export { r as monitor };