@hinkal/react-native 0.3.1

package/shims/crypto.cjs

@@ -0,0 +1,102 @@
+// Node `crypto` shim for React Native.
+
+const { sha256, sha512, keccak256 } = require('ethers');
+const { Buffer } = require('buffer');
+
+function ensureRng() {
+  if (!global.crypto || typeof global.crypto.getRandomValues !== 'function') {
+    throw new Error(
+      '[hinkal-rn] global.crypto.getRandomValues is not available. ' +
+        'Import @hinkal/react-native (HinkalProvider) before other SDK code.',
+    );
+  }
+}
+
+function randomBytes(size) {
+  ensureRng();
+  const arr = new Uint8Array(size);
+  global.crypto.getRandomValues(arr);
+  return Buffer.from(arr);
+}
+
+function randomFillSync(buf, offset, size) {
+  ensureRng();
+  const start = offset ?? 0;
+  const end = size != null ? start + size : buf.length;
+  const view = new Uint8Array(buf.buffer || buf, buf.byteOffset || 0, buf.length);
+  const tmp = new Uint8Array(end - start);
+  global.crypto.getRandomValues(tmp);
+  view.set(tmp, start);
+  return buf;
+}
+
+function randomUUID() {
+  // RFC 4122 v4 UUID via crypto-secure bytes.
+  const b = randomBytes(16);
+  b[6] = (b[6] & 0x0f) | 0x40;
+  b[8] = (b[8] & 0x3f) | 0x80;
+  const hex = b.toString('hex');
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+function toBytesLike(input) {
+  if (input == null) return new Uint8Array(0);
+  if (typeof input === 'string') return Buffer.from(input, 'utf8');
+  if (input instanceof Uint8Array) return input;
+  if (Buffer.isBuffer(input)) return input;
+  if (input.buffer) return new Uint8Array(input.buffer, input.byteOffset || 0, input.byteLength || input.length);
+  return Buffer.from(input);
+}
+
+function hexToBuffer(hex) {
+  return Buffer.from(hex.replace(/^0x/, ''), 'hex');
+}
+
+function createHash(algorithm) {
+  const alg = String(algorithm).toLowerCase().replace('-', '');
+  const chunks = [];
+  return {
+    update(chunk) {
+      chunks.push(toBytesLike(chunk));
+      return this;
+    },
+    digest(encoding) {
+      const total = chunks.reduce((acc, c) => acc + c.length, 0);
+      const merged = new Uint8Array(total);
+      let off = 0;
+      for (const c of chunks) {
+        merged.set(c, off);
+        off += c.length;
+      }
+      let hex;
+      if (alg === 'sha256') hex = sha256(merged);
+      else if (alg === 'sha512') hex = sha512(merged);
+      else if (alg === 'keccak256') hex = keccak256(merged);
+      else throw new Error(`[hinkal-rn] unsupported hash algorithm: ${algorithm}`);
+      const buf = hexToBuffer(hex);
+      if (!encoding) return buf;
+      if (encoding === 'hex') return buf.toString('hex');
+      if (encoding === 'base64') return buf.toString('base64');
+      return buf.toString(encoding);
+    },
+  };
+}
+
+function createHmac() {
+  throw new Error('[hinkal-rn] crypto.createHmac is not implemented in the RN shim. Use a JS implementation.');
+}
+
+module.exports = {
+  randomBytes,
+  randomFillSync,
+  randomUUID,
+  createHash,
+  createHmac,
+  webcrypto: typeof global.crypto !== 'undefined' ? global.crypto : undefined,
+  getRandomValues: (arr) => {
+    ensureRng();
+    global.crypto.getRandomValues(arr);
+    return arr;
+  },
+};
+module.exports.default = module.exports;

package/shims/crypto.mjs

@@ -0,0 +1,3 @@
+import mod from "./crypto.cjs";
+export function require_crypto() { return mod; }
+export default mod;

package/shims/dotenv.cjs

@@ -0,0 +1,3 @@
+module.exports = {
+  config: () => ({ parsed: {} }),
+};

package/shims/dotenv.mjs

@@ -0,0 +1,3 @@
+import mod from "./dotenv.cjs";
+export function require_dotenv() { return mod; }
+export default mod;

package/shims/ffjavascript.cjs

@@ -0,0 +1,5 @@
+module.exports = {
+  Scalar: {},
+  F1Field: class {},
+  getCurveFromName: () => { throw new Error("not supported") },
+}

package/shims/ffjavascript.mjs

@@ -0,0 +1,3 @@
+import mod from "./ffjavascript.cjs";
+export function require_ffjavascript() { return mod; }
+export default mod;

package/shims/fs.cjs

@@ -0,0 +1,5 @@
+module.exports = {
+  existsSync: () => false,
+  readFileSync: () => '',
+  writeFileSync: () => {},
+};

package/shims/fs.mjs

@@ -0,0 +1,3 @@
+import mod from "./fs.cjs";
+export function require_fs() { return mod; }
+export default mod;

package/shims/idb-keyval.cjs

@@ -0,0 +1,75 @@
+// idb-keyval shim for React Native 
+const AsyncStorage =
+  require("@react-native-async-storage/async-storage").default;
+
+const PREFIX = "@hinkal/idb-keyval:";
+const key = (k) => `${PREFIX}${typeof k === "string" ? k : JSON.stringify(k)}`;
+
+async function get(k) {
+  const raw = await AsyncStorage.getItem(key(k));
+  if (raw == null) return undefined;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+}
+
+async function set(k, value) {
+  if (value === undefined) {
+    await AsyncStorage.removeItem(key(k));
+    return;
+  }
+  await AsyncStorage.setItem(key(k), JSON.stringify(value));
+}
+
+async function update(k, updater) {
+  const current = await get(k);
+  const next = updater(current);
+  await set(k, next);
+  return next;
+}
+
+async function del(k) {
+  await AsyncStorage.removeItem(key(k));
+}
+
+async function clear() {
+  const all = await AsyncStorage.getAllKeys();
+  const ours = all.filter((x) => x.startsWith(PREFIX));
+  if (ours.length) await AsyncStorage.multiRemove(ours);
+}
+
+async function keys() {
+  const all = await AsyncStorage.getAllKeys();
+  return all.filter((x) => x.startsWith(PREFIX)).map((x) => x.slice(PREFIX.length));
+}
+
+async function values() {
+  const ks = await keys();
+  return Promise.all(ks.map(get));
+}
+
+async function entries() {
+  const ks = await keys();
+  const vs = await Promise.all(ks.map(get));
+  return ks.map((k, i) => [k, vs[i]]);
+}
+
+function createStore() {
+  // idb-keyval lets callers create a store with a custom DB name; we ignore it
+  return undefined;
+}
+
+module.exports = {
+  get,
+  set,
+  update,
+  del,
+  clear,
+  keys,
+  values,
+  entries,
+  createStore,
+};
+module.exports.default = module.exports;

package/shims/idb-keyval.mjs

@@ -0,0 +1,3 @@
+import mod from "./idb-keyval.cjs";
+export function require_idb_keyval() { return mod; }
+export default mod;

package/shims/libsodium-wrappers.cjs

@@ -0,0 +1,2 @@
+// Static CJS subpath bypasses package "import" (ESM) exports. postinstall patches libsodium's node:fs require.
+module.exports = require("libsodium-wrappers/dist/modules/libsodium-wrappers.js");

package/shims/libsodium-wrappers.mjs

@@ -0,0 +1,3 @@
+import mod from "./libsodium-wrappers.cjs";
+export function require_libsodium_wrappers() { return mod; }
+export default mod;

package/shims/multiformats.cjs

@@ -0,0 +1 @@
+module.exports = {};

package/shims/multiformats.mjs

@@ -0,0 +1,3 @@
+import mod from "./multiformats.cjs";
+export function require_multiformats() { return mod; }
+export default mod;

package/shims/os.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  hostname: () => 'localhost',
+  platform: () => 'linux',
+  arch: () => 'arm64',
+  EOL: '\n',
+  tmpdir: () => '/tmp',
+};

package/shims/os.mjs

@@ -0,0 +1,3 @@
+import mod from "./os.cjs";
+export function require_os() { return mod; }
+export default mod;

package/shims/path.cjs

@@ -0,0 +1,11 @@
+module.exports = {
+  join: (...args) => args.join("/"),
+  resolve: (...args) => args.join("/"),
+  dirname: (p) => p.split("/").slice(0, -1).join("/"),
+  basename: (p) => p.split("/").pop(),
+  extname: (p) => {
+    const base = p.split("/").pop();
+    const idx = base.lastIndexOf(".");
+    return idx < 0 ? "" : base.slice(idx);
+  },
+};

package/shims/path.mjs

@@ -0,0 +1,3 @@
+import mod from "./path.cjs";
+export function require_path() { return mod; }
+export default mod;

package/shims/readline.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+  createInterface: () => ({
+    on: () => {},
+    close: () => {},
+  }),
+};

package/shims/readline.mjs

@@ -0,0 +1,3 @@
+import mod from "./readline.cjs";
+export function require_readline() { return mod; }
+export default mod;

package/shims/snarkjs.cjs

@@ -0,0 +1,21 @@
+function notSupported(name) {
+  return () => {
+    throw new Error(
+      `[hinkal-rn] snarkjs.${name} is not available on the React Native JS thread. ` +
+        "All proof generation must go through the SnarkJS WebView bridge.",
+    );
+  };
+}
+
+module.exports = {
+  groth16: {
+    fullProve: notSupported("groth16.fullProve"),
+    prove: notSupported("groth16.prove"),
+    verify: notSupported("groth16.verify"),
+    exportSolidityCallData: notSupported("groth16.exportSolidityCallData"),
+  },
+  zKey: {
+    exportVerificationKey: notSupported("zKey.exportVerificationKey"),
+  },
+};
+module.exports.default = module.exports;

package/shims/snarkjs.mjs

@@ -0,0 +1,3 @@
+import mod from "./snarkjs.cjs";
+export function require_snarkjs() { return mod; }
+export default mod;

package/shims/url.cjs

@@ -0,0 +1,5 @@
+module.exports = {
+  pathToFileURL: (p) => ({ href: p }),
+  fileURLToPath: (u) => u,
+  URL: typeof URL !== "undefined" ? URL : null,
+};

package/shims/url.mjs

@@ -0,0 +1,3 @@
+import mod from "./url.cjs";
+export function require_url() { return mod; }
+export default mod;

package/shims/web-worker.cjs

@@ -0,0 +1,7 @@
+module.exports = class Worker {
+  constructor() {}
+  postMessage() {}
+  terminate() {}
+  addEventListener() {}
+  removeEventListener() {}
+};

package/shims/web-worker.mjs

@@ -0,0 +1,3 @@
+import mod from "./web-worker.cjs";
+export function require_web_worker() { return mod; }
+export default mod;

package/shims/worker_threads.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+  Worker: class {},
+  workerData: {},
+  parentPort: null,
+  isMainThread: true,
+};

package/shims/worker_threads.mjs

@@ -0,0 +1,3 @@
+import mod from "./worker_threads.cjs";
+export function require_worker_threads() { return mod; }
+export default mod;

package/types/IHinkal.d.ts

@@ -0,0 +1,59 @@
+import { BridgeRecipient, CallInfo, DepositAndSendExtendedResult, ExternalActionId, FeeStructure, LoginMessageMode, NearBridgeParams, NearBridgeResult, SolanaTransactionParams, StealthAddressStructure } from '../common/src/types';
+import { ethers, TypedDataDomain, TypedDataField } from 'ethers';
+import { Types as TronWebTypes } from 'tronweb';
+import { Utxo } from '../common/src/data-structures/utxo/Utxo';
+import { PublicKey } from '@solana/web3.js';
+import { IProviderAdapter } from './IProviderAdapter';
+import { PrivateBalancesState, PrivateBalanceUpdateEventType, TokenBalance } from './balances.types';
+import { EvmSwapPrices, SolanaSwapPrices } from './swap.types';
+import { ScheduledTransactionByIdResponse } from '../common/src/API';
+export interface IHinkal<ConnectorType = unknown> {
+    getProviderAdapter(chainId?: number): IProviderAdapter;
+    initProviderAdapter(connector: ConnectorType, providerAdapter: IProviderAdapter<ConnectorType>): Promise<void>;
+    initUserKeys(mode?: LoginMessageMode): Promise<void>;
+    initUserKeysWithSignature(signature: string): void;
+    initUserKeysFromSeedPhrases(seedPhrases: string[]): Promise<void>;
+    initUserKeysWithEnclaveSignature(signInMode?: LoginMessageMode): Promise<string | undefined>;
+    storeAndGetInitialSignature(authSignature: string, isSolanaLedger: boolean, txMessageForSolanaLedger?: string): Promise<string>;
+    resetProviderAdapters(): Promise<void>;
+    disconnectFromConnector(): Promise<void>;
+    destroy(): Promise<void>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    getSupportedChains(): number[];
+    isSelectedNetworkSupported(chainId: number): boolean;
+    switchNetwork(chainId: number): Promise<unknown>;
+    resetMerkle(chainIdsToReset?: number[]): Promise<void>;
+    resetMerkleTreesIfNecessary(chainIdsToCheck?: number[]): Promise<void>;
+    privateBalancesWithUSD: PrivateBalancesState;
+    /** Returns unsubscribe. Multiple listeners supported. */
+    onPrivateBalancesWithUSDChange(callback: (state: PrivateBalancesState) => void): () => void;
+    refreshBalance(detail: PrivateBalanceUpdateEventType): void;
+    getTotalBalance(chainId: number, resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<TokenBalance[]>;
+    getStuckShieldedBalances(chainId: number, resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<TokenBalance[]>;
+    getFeeStructure(chainId: number, feeTokenAddress: string | undefined, erc20Addresses: string[], externalActionId: ExternalActionId, calls?: CallInfo[], variableRate?: bigint, solanaTransactionParams?: SolanaTransactionParams): Promise<FeeStructure>;
+    getEvmSwapPrices(chainId: number, inSwapAmount: string, inSwapTokenAddress: string, outSwapTokenAddress: string): Promise<EvmSwapPrices>;
+    getSolanaSwapPrices(chainId: number, inSwapAmount: string, inSwapTokenAddress: string, outSwapTokenAddress: string): Promise<SolanaSwapPrices>;
+    getSolanaPublicKey(): PublicKey;
+    getEthereumAddress(): Promise<string>;
+    getEthereumAddressByChain(chainId: number): Promise<string>;
+    getRecipientInfo(): string;
+    getShieldedPublicKey(): string;
+    prooflessDeposit(chainId: number, erc20Addresses: string[], amountChanges: bigint[], stealthAddressStructures?: StealthAddressStructure[]): Promise<string | ethers.TransactionRequest | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+    prooflessDepositWithPublicFee(chainId: number, erc20Address: string, amounts: bigint[], stealthAddressStructures: StealthAddressStructure[], feeAmount: bigint): Promise<string>;
+    deposit(chainId: number, erc20Addresses: string[], amountChanges: bigint[], preEstimateGas?: boolean, returnTxData?: boolean): Promise<ethers.TransactionResponse | ethers.TransactionRequest | string | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+    depositSolana(chainId: number, erc20Address: string, amount: bigint): Promise<string>;
+    depositForOther(chainId: number, erc20Addresses: string[], amountChanges: bigint[], recipientInfo: string, preEstimateGas?: boolean, returnTxData?: boolean): Promise<ethers.TransactionResponse | ethers.TransactionRequest | string | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+    depositSolanaForOther(chainId: number, erc20Address: string, amount: bigint, recipientInfo: string): Promise<string>;
+    depositAndWithdraw(chainId: number, erc20Address: string, recipientAmounts: bigint[], recipientAddresses: string[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, preEstimateGas?: boolean): Promise<DepositAndSendExtendedResult>;
+    depositAndBridge(chainId: number, erc20Address: string, recipientBridges: BridgeRecipient[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, preEstimateGas?: boolean): Promise<DepositAndSendExtendedResult>;
+    nearDepositAndBridge(chainId: number, erc20Address: string, recipientAmounts: bigint[], recipientAddresses: string[], params: NearBridgeParams, txCompletionTime?: number, feeStructureOverride?: FeeStructure): Promise<NearBridgeResult>;
+    checkSendTransactionStatus(scheduleId: string): Promise<ScheduledTransactionByIdResponse>;
+    claimUtxo(chainId: number, erc20Address: string, utxo: Utxo, feeStructureOverride?: FeeStructure, claimableSignature?: string): Promise<string>;
+    transfer(chainId: number, erc20Addresses: string[], amountChanges: bigint[], recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<string>;
+    withdraw(chainId: number, erc20Addresses: string[], deltaAmounts: bigint[], recipientAddress: string, isRelayerOff: boolean, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<ethers.TransactionResponse | string>;
+    withdrawStuckUtxos(chainId: number, erc20Address: string, recipientAddress: string): Promise<string[]>;
+    swap(chainId: number, erc20Addresses: string[], deltaAmounts: bigint[], externalActionId: ExternalActionId, swapData: string, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<string>;
+    emporiumOp: (contract: ethers.Contract | string, func?: string, args?: unknown[], callDataString?: string, invokeWallet?: boolean, value?: bigint) => string;
+    actionPrivateWallet(chainId: number, erc20Addresses: string[], deltaAmounts: bigint[], onChainCreation: boolean[], ops: string[], feeToken?: string, feeStructureOverride?: FeeStructure): Promise<string>;
+}

package/types/IProviderAdapter.d.ts

@@ -0,0 +1 @@
+export type { IProviderAdapter } from '../common/src/data-structures/provider-adapter/IProviderAdapter';

package/types/balances.types.cjs

@@ -0,0 +1 @@
+require(`../common/src/types/balances.types.cjs`),require(`../common/src/types/index.cjs`);

package/types/balances.types.d.ts

@@ -0,0 +1,15 @@
+import { PrivateBalanceUpdateEventType as CommonPrivateBalanceUpdateEventType } from '../common/src/types';
+export { PrivateBalanceUpdateType } from '../common/src/types';
+export type TokenBalance = {
+    chainId: number;
+    erc20Address: string;
+    balance: bigint;
+    timestamp?: string;
+};
+export type TokenBalanceWithUsd = TokenBalance & {
+    isBalanceLoading?: boolean;
+    usdValue?: number;
+    isUsdValueLoading?: boolean;
+};
+export type PrivateBalancesState = Record<number, TokenBalanceWithUsd[] | undefined>;
+export type PrivateBalanceUpdateEventType = Omit<CommonPrivateBalanceUpdateEventType, 'balanceChangeState'>;

package/types/balances.types.mjs

@@ -0,0 +1,2 @@
+import "../common/src/types/balances.types.mjs";
+import "../common/src/types/index.mjs";

package/types/external-action.types.cjs

@@ -0,0 +1 @@
+require(`../common/src/types/external-action.types.cjs`),require(`../common/src/types/index.cjs`);

package/types/external-action.types.d.ts

@@ -0,0 +1 @@
+export { ExternalActionId, type ExternalActionData } from '../common/src/types';

package/types/external-action.types.mjs

@@ -0,0 +1,2 @@
+import "../common/src/types/external-action.types.mjs";
+import "../common/src/types/index.mjs";

package/types/fee.types.d.ts

@@ -0,0 +1 @@
+export type { FeeStructure } from '../common/src/types/hinkal.types';

package/types/index.cjs

@@ -0,0 +1 @@
+require(`../common/src/types/external-action.types.cjs`),require(`../common/src/types/balances.types.cjs`),require(`./balances.types.cjs`),require(`./external-action.types.cjs`);

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './IHinkal';
+export * from './IProviderAdapter';
+export * from './fee.types';
+export * from './balances.types';
+export * from './external-action.types';
+export * from './swap.types';
+export * from './token.types';

package/types/index.mjs

@@ -0,0 +1,4 @@
+import "../common/src/types/external-action.types.mjs";
+import "../common/src/types/balances.types.mjs";
+import "./balances.types.mjs";
+import "./external-action.types.mjs";

package/types/privateTypes.d.ts

@@ -0,0 +1,5 @@
+import { IHinkal } from './IHinkal';
+import { IHinkal as IHinkalCommon } from '../common/src/data-structures/Hinkal/IHinkal';
+export type IHinkalSDK<ConnectorType = unknown> = IHinkal<ConnectorType> & {
+    hinkalCommon: IHinkalCommon<ConnectorType>;
+};

package/types/swap.types.d.ts

@@ -0,0 +1,25 @@
+type UniswapSwapPrice = {
+    tokenPrice: bigint;
+    poolFee: string;
+};
+type OdosSwapPrice = {
+    outSwapAmountValue: bigint;
+    odosDataValue: string;
+};
+type OneInchSwapPrice = {
+    outSwapAmountValue: bigint;
+    oneInchDataValue: string;
+};
+type OkxSwapPrice = {
+    outSwapAmountValue: bigint;
+    okxDataValue: string;
+};
+export type EvmSwapPrices = {
+    uniswap: UniswapSwapPrice | null;
+    odos: OdosSwapPrice | null;
+    oneInch: OneInchSwapPrice | null;
+};
+export type SolanaSwapPrices = {
+    okx: OkxSwapPrice | null;
+};
+export {};

package/types/token.types.d.ts

@@ -0,0 +1,5 @@
+export type TokenChanges<T = bigint> = {
+    erc20Address: string;
+    amount: T;
+    nftIds?: string[];
+};