@hinkal/react-native 0.3.1

package/README.md

@@ -0,0 +1,428 @@
+# Hinkal React Native SDK
+
+Hinkal is a privacy middleware and smart-contract SDK for public blockchains that enables confidential transactions and settlement flows without changing wallets, custody, or chains.
+
+`@hinkal/react-native` is a prebundled build of the Hinkal SDK for React Native and Expo. It includes the polyfills, shims, and worker runtime required on mobile — no custom Metro configuration is needed.
+
+The SDK allows mobile wallets, dApps, and payment apps to integrate protocol-level privacy on Ethereum, Solana, Tron, Polygon, Base, Arbitrum, and Optimism.
+
+With Hinkal SDK, developers can:
+• Enable private sends between public wallets
+• Perform confidential payouts and settlements
+• Route transactions through Hinkal’s privacy contracts without exposing sender, recipient, or amounts
+• Maintain non-custodial control with optional compliance visibility via viewing keys
+
+## Compatibility
+
+| Environment  | Supported | Notes                |
+| ------------ | --------- | -------------------- |
+| React Native | ✅        | v0.74+               |
+| Expo         | ✅        | dev client or bare   |
+
+## Installation
+
+```sh
+npm install @hinkal/react-native
+```
+
+Or, yarn:
+
+```sh
+yarn add @hinkal/react-native
+```
+
+## Usage
+
+### HinkalProvider
+
+Wrap your app with `HinkalProvider` before using any SDK function. It runs the React Native bootstrap and mounts the hidden WebView worker host.
+
+```tsx
+import { WagmiProvider } from 'wagmi';
+import { HinkalProvider } from '@hinkal/react-native';
+import { wagmiConfig } from './wagmiConfig';
+
+export default function App() {
+  return (
+    <WagmiProvider config={wagmiConfig}>
+      <HinkalProvider>
+        <YourApp />
+      </HinkalProvider>
+    </WagmiProvider>
+  );
+}
+```
+
+### Initialization
+
+After the wallet is connected, initialize a `Hinkal` instance with your preferred provider helper.
+
+Initializing the SDK creates a `Hinkal` object that encapsulates:
+
+- The user's shielded balances
+- 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
+
+**wagmi:**
+
+```typescript
+import { prepareWagmiHinkal } from '@hinkal/react-native';
+// connector: wagmi.Connector
+// wagmiConfig: wagmi.Config
+const hinkal = await prepareWagmiHinkal(connector, wagmiConfig, hinkalConfig);
+```
+
+**ethers.js:**
+
+```typescript
+import { prepareEthersHinkal } from '@hinkal/react-native';
+const hinkal = await prepareEthersHinkal(signer, hinkalConfig);
+```
+
+**Solana:**
+
+```typescript
+import { prepareSolanaHinkal } from '@hinkal/react-native';
+// connector: SolanaWallet
+// ethereumAddress: optional linked EVM address
+const hinkal = await prepareSolanaHinkal(connector, ethereumAddress, hinkalConfig);
+```
+
+**Tron:**
+
+```typescript
+import { prepareTronHinkal } from '@hinkal/react-native';
+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
+type HinkalConfig = {
+  /** Disables caching in browser localStorage, storing data only in memory. Front-end only. Defaults to false. */
+  disableCaching?: boolean;
+
+  /** If true, allows caching in a file locally. Node.js only. Defaults to false. */
+  useFileCache?: boolean;
+
+  /**
+   * Path to the cache file used for storing temporary data. Node.js only.
+   * Defaults to hinkalCache.json in the current working directory.
+   */
+  cacheFilePath?: string;
+
+  /**
+   * Indicator controlling whether 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.
+
+**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(
+  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 with a stored signature:
+
+```typescript
+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.
+
+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.
+
+### 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.
+
+After initializing the Hinkal object and calling `initUserKeys` (or a prepare helper), fetch balances for a specific chain:
+
+```typescript
+function getTotalBalance(
+  chainId: number,
+  resetCacheBefore?: boolean,
+  updateTokensListBefore?: boolean,
+): Promise<TokenBalance[]>;
+```
+
+`TokenBalance` contains `chainId`, `erc20Address`, `balance`, and an optional `timestamp`.
+
+For reactive UI updates, subscribe to balance changes with USD values:
+
+```typescript
+// Current state keyed by chainId
+hinkal.privateBalancesWithUSD;
+
+// Subscribe to updates; returns unsubscribe function
+const unsubscribe = hinkal.onPrivateBalancesWithUSDChange((state) => {
+  // state: Record<chainId, TokenBalanceWithUsd[]>
+});
+
+// Trigger a refresh after a transaction
+hinkal.refreshBalance({ chainIdToUpdate: chainId, updateType: PrivateBalanceUpdateType.Fresh });
+```
+
+### Shielding: depositing funds to the shielded balance
+
+Shielding moves tokens from a public blockchain address into a private, encrypted balance. Once shielded, tokens are no longer visible on-chain to external observers.
+
+```typescript
+function deposit(
+  chainId: number,
+  erc20Addresses: string[],
+  amountChanges: bigint[],
+  preEstimateGas?: boolean,
+  returnTxData?: boolean,
+): Promise<
+  | ethers.TransactionResponse
+  | ethers.TransactionRequest
+  | string
+  | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>
+>;
+```
+
+where:
+
+- `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
+
+On Solana, use `depositSolana(chainId, erc20Address, amount)`.
+
+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
+
+Private Send to Public Address sends tokens from a shielded balance to any public blockchain address without exposing the sender.
+
+```typescript
+function withdraw(
+  chainId: number,
+  erc20Addresses: string[],
+  deltaAmounts: bigint[],
+  recipientAddress: string,
+  isRelayerOff: boolean,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+): Promise<ethers.TransactionResponse | string>;
+```
+
+where:
+
+- `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: transferring funds from shielded balance
+
+Private Send to Private Address enables fully confidential transfers between shielded balances.
+
+```typescript
+function transfer(
+  chainId: number,
+  erc20Addresses: string[],
+  amountChanges: bigint[],
+  recipientAddress: string,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+): Promise<string>;
+```
+
+where:
+
+- `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
+
+Private Send from Public to Public transfers tokens between two public addresses through Hinkal's privacy infrastructure. Tokens are shielded from the sender, then withdrawn to recipient public addresses on a relayer schedule.
+
+```typescript
+function depositAndWithdraw(
+  chainId: number,
+  erc20Address: string,
+  recipientAmounts: bigint[],
+  recipientAddresses: string[],
+  txCompletionTime?: number,
+  feeStructureOverride?: FeeStructure,
+  preEstimateGas?: boolean,
+): Promise<DepositAndSendExtendedResult>;
+```
+
+where:
+
+- `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:
+
+```typescript
+type DepositAndSendExtendedResult = {
+  depositTxHash: string;
+  scheduleId: string;
+};
+```
+
+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 `depositAndWithdraw` or `depositAndBridge`, fetch scheduled withdrawal status using the returned `scheduleId`:
+
+```typescript
+function checkSendTransactionStatus(scheduleId: string): Promise<ScheduledTransactionByIdResponse>;
+```
+
+Possible values for `ScheduledTransactionStatus`:
+
+- `pending` — scheduled, waiting for execution time
+- `processing` — relayer is submitting the withdrawal on-chain
+- `waiting_for_relayer` — relayer is busy; withdrawal is queued
+- `sent_on_chain` — submitted on-chain; `txHash` is available
+- `completed` — confirmed on-chain
+- `failed` — withdrawal transaction failed
+
+### Swapping tokens from the shielded balance
+
+```typescript
+function swap(
+  chainId: number,
+  erc20Addresses: string[],
+  deltaAmounts: bigint[],
+  externalActionId: ExternalActionId,
+  swapData: string,
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+): Promise<string>;
+```
+
+**Getting swap quotes and calldata:**
+
+**EVM chains** — `getEvmSwapPrices(chainId, inSwapAmount, inSwapTokenAddress, outSwapTokenAddress)` returns quotes from Uniswap, Odos, and 1Inch. Pass swap calldata with the matching `externalActionId`:
+
+- **Uniswap** — `uniswap.poolFee` with `ExternalActionId.Uniswap`
+- **Odos** — `odos.odosDataValue` with `ExternalActionId.Odos`
+- **1Inch** — `oneInch.oneInchDataValue` with `ExternalActionId.OneInch`
+
+**Solana** — `getSolanaSwapPrices(...)` returns an OKX quote. Pass `okx.okxDataValue` to `swap` with `ExternalActionId.Okx`.
+
+### Interacting with smart contracts privately
+
+```typescript
+function actionPrivateWallet(
+  chainId: number,
+  erc20Addresses: string[],
+  deltaAmounts: bigint[],
+  onChainCreation: boolean[],
+  ops: string[],
+  feeToken?: string,
+  feeStructureOverride?: FeeStructure,
+): Promise<string>;
+```
+
+Generate user operations with `emporiumOp`:
+
+```typescript
+function emporiumOp(
+  contract: ethers.Contract | string,
+  func?: string,
+  args?: unknown[],
+  callDataString?: string,
+  invokeWallet?: boolean,
+  value?: bigint,
+): string;
+```
+
+**Stateless interactions** (swaps, simple staking) use default `invokeWallet: false`.
+
+**Stateful interactions** (reward tracking, voting power) require `invokeWallet: true` so the call runs from a persistent wallet address.
+
+```typescript
+const operations = [
+  hinkal.emporiumOp(usdcContractInstance, 'approve', [swapRouterAddress, amountIn]),
+  hinkal.emporiumOp(swapRouterContractInstance, 'exactInputSingle', [swapSingleParams]),
+];
+```
+
+## Supported Chains
+
+| 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 |
+
+## References
+
+Wallet: [Hinkal Wallet](https://chromewebstore.google.com/detail/hinkal-wallet/khfjgapjfcdoffmklchibpepboholpbe)
+
+Application: [Hinkal Pay](https://pay.hinkal.io)
+
+Docs: [Hinkal Documentation](https://hinkal-team.gitbook.io/hinkal)

package/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),s=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},c=(n,r,a)=>(a=n==null?{}:e(i(n)),s(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));exports.__commonJSMin=o,exports.__toESM=c;

package/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,16 @@
+//#region \0rolldown/runtime.js
+var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, r = Object.getOwnPropertyNames, i = Object.getPrototypeOf, a = Object.prototype.hasOwnProperty, o = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), s = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = r(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !a.call(e, d) && d !== o && t(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = n(i, d)) || s.enumerable
+	});
+	return e;
+}, c = (n, r, a) => (a = n == null ? {} : e(i(n)), s(r || !n || !n.__esModule ? t(a, "default", {
+	value: n,
+	enumerable: !0
+}) : a, n)), l = /* @__PURE__ */ ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (e, t) => (typeof require < "u" ? require : e)[t] }) : e)(function(e) {
+	if (typeof require < "u") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + e + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { o as __commonJSMin, l as __require, c as __toESM };

package/bootstrap.cjs

@@ -0,0 +1 @@
+const e=require(`./_virtual/_rolldown/runtime.cjs`);require(`react-native-get-random-values`);let t=require(`buffer`),n=require(`react-native`);n=e.__toESM(n),globalThis.process?.versions?.node&&delete globalThis.process.versions.node,global.Buffer=t.Buffer,globalThis.indexedDB===void 0&&(globalThis.indexedDB={}),global.require===void 0&&(global.require=e=>{if(e===`react-native`)return n;throw Error(`global.require shim: unsupported module "${e}"`)});

package/bootstrap.mjs

@@ -0,0 +1,8 @@
+import "react-native-get-random-values";
+import { Buffer as e } from "buffer";
+import * as t from "react-native";
+globalThis.process?.versions?.node && delete globalThis.process.versions.node, global.Buffer = e, globalThis.indexedDB === void 0 && (globalThis.indexedDB = {}), global.require === void 0 && (global.require = (e) => {
+	if (e === "react-native") return t;
+	throw Error(`global.require shim: unsupported module "${e}"`);
+});
+//#endregion

package/bridge/HinkalRNWorker.cjs

@@ -0,0 +1 @@
+require("../_virtual/_rolldown/runtime.cjs");const e=require(`./serialization.utils.cjs`);let t=require(`react-native`);var n=class{onmessage=null;onerror=null;requestId=e.nextRequestId();subscription;constructor(e){this.variant=e,this.subscription=t.DeviceEventEmitter.addListener(`FROM_WEBVIEW_WORKER`,e=>{!e||e.requestId!==this.requestId||(e.type===`RESULT`?this.onmessage?.({data:e.data}):e.type===`ERROR`&&this.onerror?.(Error(e.error??`WebView worker error`)))})}postMessage(e){t.DeviceEventEmitter.emit(`TO_WEBVIEW_WORKER`,{__requestId:this.requestId,variant:this.variant,message:e})}terminate(){this.subscription?.remove?.(),this.subscription=null}};exports.HinkalRNWorker=n;

package/bridge/HinkalRNWorker.d.ts

@@ -0,0 +1,13 @@
+import { WorkerVariant } from '../../../common/src/webworker/worker.registry';
+export declare class HinkalRNWorker {
+    private variant;
+    onmessage: ((event: {
+        data: any;
+    }) => void) | null;
+    onerror: ((error: any) => void) | null;
+    private requestId;
+    private subscription;
+    constructor(variant: WorkerVariant);
+    postMessage(message: unknown): void;
+    terminate(): void;
+}

package/bridge/HinkalRNWorker.mjs

@@ -0,0 +1,26 @@
+import { nextRequestId as e } from "./serialization.utils.mjs";
+import { DeviceEventEmitter as t } from "react-native";
+//#region ./bridge/HinkalRNWorker.ts
+var n = class {
+	onmessage = null;
+	onerror = null;
+	requestId = e();
+	subscription;
+	constructor(e) {
+		this.variant = e, this.subscription = t.addListener("FROM_WEBVIEW_WORKER", (e) => {
+			!e || e.requestId !== this.requestId || (e.type === "RESULT" ? this.onmessage?.({ data: e.data }) : e.type === "ERROR" && this.onerror?.(Error(e.error ?? "WebView worker error")));
+		});
+	}
+	postMessage(e) {
+		t.emit("TO_WEBVIEW_WORKER", {
+			__requestId: this.requestId,
+			variant: this.variant,
+			message: e
+		});
+	}
+	terminate() {
+		this.subscription?.remove?.(), this.subscription = null;
+	}
+};
+//#endregion
+export { n as HinkalRNWorker };

package/bridge/serialization.utils.cjs

@@ -0,0 +1 @@
+var e=(e,t)=>typeof t==`bigint`?{__bigint:t.toString()}:t instanceof Set?{__set:Array.from(t)}:t instanceof Map?{__map:Array.from(t.entries())}:t,t=e=>{if(typeof e!=`object`||!e)return e;let n=Object.keys(e);if(n.length===1){if(typeof e.__bigint==`string`)return BigInt(e.__bigint);if(Array.isArray(e.__set))return new Set(e.__set.map(t));if(Array.isArray(e.__map))return new Map(e.__map.map(e=>[t(e[0]),t(e[1])]))}return Array.isArray(e)?e.map(t):Object.fromEntries(n.map(n=>[n,t(e[n])]))},n=()=>`hinkal-rnw-${Date.now().toString(36)}-${Math.random().toString(36).slice(2,10)}`;exports.bigIntReplacer=e,exports.nextRequestId=n,exports.reviveBigInts=t;

package/bridge/serialization.utils.d.ts

@@ -0,0 +1,3 @@
+export declare const bigIntReplacer: (_key: string, value: any) => any;
+export declare const reviveBigInts: (value: any) => any;
+export declare const nextRequestId: () => string;

package/bridge/serialization.utils.mjs

@@ -0,0 +1,13 @@
+//#region ./bridge/serialization.utils.ts
+var e = (e, t) => typeof t == "bigint" ? { __bigint: t.toString() } : t instanceof Set ? { __set: Array.from(t) } : t instanceof Map ? { __map: Array.from(t.entries()) } : t, t = (e) => {
+	if (typeof e != "object" || !e) return e;
+	let n = Object.keys(e);
+	if (n.length === 1) {
+		if (typeof e.__bigint == "string") return BigInt(e.__bigint);
+		if (Array.isArray(e.__set)) return new Set(e.__set.map(t));
+		if (Array.isArray(e.__map)) return new Map(e.__map.map((e) => [t(e[0]), t(e[1])]));
+	}
+	return Array.isArray(e) ? e.map(t) : Object.fromEntries(n.map((n) => [n, t(e[n])]));
+}, n = () => `hinkal-rnw-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+//#endregion
+export { e as bigIntReplacer, n as nextRequestId, t as reviveBigInts };

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;