@rhea-finance/confidential-swap 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rhea Finance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+# @rhea-finance/confidential-swap
+
+Independent TypeScript SDK extracted from the confidential trade flow in `multi-chain-lending`. Browser and Node.js 20+; ESM, CJS and type declarations. No React, browser globals, wallet connections, private keys or RPC credentials are embedded.
+
+## Wallet roles
+
+The linking wallet signs confidential authorization and withdrawal intents. Supported standards are NEAR NEP-413, EVM ERC-191, Solana raw Ed25519, and Tron TIP-191. All signatures are verified locally using Noble cryptography.
+
+The funding wallet performs source-chain transfers, approvals, chain switching and funding swaps. It can be a different wallet on a different chain. BTC, Zcash, Aptos and Sui can fund through a supplied funding adapter; they are not linking wallets.
+
+Default `resolveLinkingWallet` selection prefers the connected source kind, then NEAR, EVM, Solana, Tron. An explicit preferred wallet overrides that priority. Quote plans freeze the selected account and public key; execution will not silently switch identity.
+
+## Setup
+
+```sh
+pnpm install
+pnpm check
+pnpm test:repeat
+pnpm check:live-readonly # optional network-only registry check; no signatures or funds
+```
+
+For package consumers: `pnpm add @rhea-finance/confidential-swap` after publication, or install a locally packed tarball. This repository has not been published automatically.
+
+## Client
+
+```ts
+import {
+  HttpConfidentialApi,
+  createConfidentialSwapClient,
+  type FundingAdapter,
+} from '@rhea-finance/confidential-swap';
+import { createEvmSigningAdapter } from '@rhea-finance/confidential-swap/adapters';
+
+const api = new HttpConfidentialApi({
+  directUrl: 'https://1click.chaindefuser.com/v0',
+  proxyUrl: 'https://api.rhea.finance/proxy/1click/v0',
+  indexerUrl: 'https://api.rhea.finance',
+  nearRpcUrl: 'https://rpc.mainnet.near.org',
+  // Reference app uses signed-payload authorization for POST /private/withdraws.
+  // Select 'bearer' only when that matches your backend contract.
+  withdrawAuthorization: 'signed-payload',
+});
+
+const linking = createEvmSigningAdapter(() => connectedEvmSigner);
+const funding: FundingAdapter = sourceChainAdapter;
+const client = createConfidentialSwapClient({
+  api,
+  signingAdapters: [linking],
+  fundingAdapters: [funding],
+  // Add fundingSwapAdapter for non-DIRECT routes.
+});
+
+const plan = await client.quote({
+  sourceToken,
+  destinationToken,
+  amount: '1000000', // smallest-unit integer string, never a JS floating-point amount
+  sourceWallet: await funding.getIdentity(),
+  linkingWallet: await linking.getIdentity(),
+  recipients: destinationAddresses,
+  slippageBps: 50, // 0.5 percent
+});
+
+// Display plan.previews, plan.minAmountOut and the selected wallet identities for review.
+const result = await client.execute(plan, {
+  signal: controller.signal,
+  onProgress: snapshot => updateProgress(snapshot),
+});
+```
+
+The example assumes the application's existing wallet, asset, funding adapter and progress objects. The SDK does not connect wallets or manage UI. Connect and choose those objects in the application; do not pass private keys into the SDK.
+
+`Token.assetId` identifies the registry asset. `blockchain` names its chain. `contractAddress` identifies its actual on-chain token. For numeric EVM funding identities supply the matching token `swapChain` (e.g. `"1"`); `swapAddress` explicitly maps an asset to the aggregation SDK's token address/native sentinel. No arbitrary EVM chain is guessed from `evm` kind alone.
+
+`preview` accepts an optional linking identity and returns `executable: false`. A placeholder identity is display-only. Preview/quote may allocate deposit addresses on the backend, but neither signs nor broadcasts funds. `quote` requires a real linking identity. Default fees match the reference app: 2 bps to `crosschaindexfee.near`, referral `rhea`; supply `appFees: []` or your own fees explicitly when needed.
+
+## Funding adapters and paths
+
+`FundingAdapter.getIdentity` returns `{ kind, accountId, chain }`. Its `validate` checks capability and the source chain without sending funds. Its `transfer` receives the real source token, smallest-unit amount, deposit address, optional memo and stable execution ID. Return a source transaction hash. Implement chain-specific transfer logic with the application's existing wallet SDK; an adapter must check identity again immediately before signing/broadcasting.
+
+For non-DIRECT funding, the funding adapter still validates the source wallet and chain, while `FundingSwapAdapter` performs quote/build/execute/report/status. Its quote data must be public and JSON-serializable. Its executor must use exactly the supplied source identity, chain and deposit recipient.
+
+| Path | Waiting sequence |
+| --- | --- |
+| DIRECT | Transfer from the source wallet; wait for confidential deposit and credited balance |
+| SAME_CHAIN_SWAP | Swap to FLEX_INPUT, report, wait only for confidential deposit and balance |
+| CROSS_CHAIN_SWAP | Swap to FLEX_INPUT, report, wait for swap record success, then deposit and balance |
+
+All paths authorize the linking identity before sending source funds. Routing prefers registered direct assets, then same-chain USDC/USDT/USDT0, then a NEAR asset or another registry asset. Native NEAR maps to wNEAR. FLEX minimum input is checked against the final aggregation minimum output, with bounded requotes.
+
+`fundingSource: 'balance'` spends only the requested amount from an existing registered confidential balance, without a source transaction. `mode: 'TRANSFER'` requires the same funding and destination asset; otherwise mode defaults to `SWAP`. A batch has 1-10 unique recipients on one destination chain and asset. Randomized positive shares preserve the exact raw total with roughly 80-120 percent equal-share bounds, allowing integer rounding. Frozen random fractions are reused against the actual credited amount.
+
+Supply `addressValidator` for BTC/Zcash or unsupported destination chains, using an established chain library. Known EVM, NEAR, Solana, Tron, Aptos and Sui address formats are checked by default. Case-sensitive addresses are never lowercased or silently truncated.
+
+## Aggregation bridge
+
+The optional `@rhea-finance/confidential-swap/aggregation` entry exposes `createAggregationFundingAdapter` and `HttpFundingReporter`. Install the optional peer `@rhea-finance/cross-chain-aggregation-dex@^2.0.6` when using its bridge/types.
+
+```ts
+import { SwapClient } from '@rhea-finance/cross-chain-aggregation-dex';
+import {
+  createAggregationFundingAdapter,
+  HttpFundingReporter,
+} from '@rhea-finance/confidential-swap/aggregation';
+
+const swapClient = new SwapClient({
+  baseUrl: indexerUrl,
+  apiKey: configuredApiToken,
+  reportMode: 'manual', // no duplicate automatic reports
+  executors: sourceChainExecutors,
+});
+const fundingSwapAdapter = createAggregationFundingAdapter({
+  client: swapClient,
+  reporter: new HttpFundingReporter({ baseUrl: indexerUrl, bearerToken: configuredApiToken }),
+  mapAsset: token => ({ chain: mapSwapChain(token), address: mapSwapAddress(token) }),
+});
+```
+
+Unlike the aggregation SDK's ordinary order query, advanced funding status uses `/api/swap/order-status?recordId=...`. The reporter sends `confidentiality: 'advanced'`. API credentials must be provided by the application, not copied from the reference repository.
+
+## Intent protocol boundary
+
+Withdrawal payloads are signed as returned by `/generate-intent`, matching the reference implementation. The SDK does not enforce a local transfer format or compare intent tokens and amounts against the quote. Signers, standards, nonces, deadlines and signatures are independently validated. NEP-413 withdrawal recipients are signed exactly as returned; authorization still requires the configured verifier. NEP-413 nonces accept Base64 or Base64URL and must decode to 32 bytes.
+
+Applications may opt into additional protocol-specific validation using `verifyWithdrawIntent(data, context)`. Without this hook, generated intent effects are not locally validated. The hook does not bypass signer, standard, nonce, deadline or signature checks.
+
+## Recovery and safety
+
+Use `getExecution(id)` to inspect checkpoints and `resume(id)` to continue polling or signing. Reusing `execute(plan)` for a saved ID resumes it instead of sending another transfer. Default memory stores last only for the client lifetime; supply `ExecutionStore` and `SessionStore` for your own storage.
+
+Checkpoints are saved **before** funding broadcast, report submission and withdrawal submission. A lost response leaves an `*_unknown` stage. Such writes are never automatically retried, including on 401. Supply read-only `reconcile`/`reconcileFunding` and `reconcileReport` lookups keyed by execution ID/transaction/deposit. An unknown batch is recovered only by finding the existing signer-scoped order with all saved withdrawal deposit addresses; a missing match remains unknown.
+
+Timeout and abort stop local waiting, not the chain transaction. Keep the execution ID and resume. Submitted checkpoints can poll without connected wallets. Partial success is retained per recipient; terminal partial failures return `stage: 'failed'` with all available item statuses, never a blind retry.
+
+`discardPrepared(id)` releases only a `created` checkpoint that has attempted no funds. After credited funds suffer price changes, `refreshWithdrawalReview(id)` generates and stores a new withdrawal preview/minimum; show the new review and then explicitly call `resume(id)`. It never repeats source funding.
+
+Progress snapshots exclude session tokens and signed intent payloads, but include public quote/transaction metadata and addresses. Treat them as sensitive and trusted application data. The plan digest catches accidental edits, not malicious forgery. Do not accept arbitrary caller-created snapshots or mutate storage during execution.
+
+Budget locks prevent concurrently running executions of the same identity/asset **within one client**. Stored unfinished executions do not block new executions and their checkpoints are retained. Multiple clients/processes sharing storage require an application-owned atomic/distributed lock; a plain async store is not a distributed lock. External balance changes can also affect confirmation; a balance check is not a cryptographic deposit attribution proof. Successful deposit status must provide actual `swapDetails.amountOut`; quoted output is not accepted as proof of funds.
+
+NEAR named accounts may require an explicit public-key registration transaction on the linking chain. `createNearSigningAdapter` exposes a `registerPublicKey` callback and confirms registration. Implicit NEAR identities must match their Ed25519 key. Registration is not a source-chain funding transaction.
+
+This is confidential-account orchestration, not a guarantee of end-to-end anonymity. Funding transactions, withdrawals, recipient reuse and backend reports can expose associations. Do not log tokens, full signed intents or wallet-provider errors.
+
+## Verification status
+
+Local tests exercise actual cryptographic signatures, the three-path/four-linking-kind matrix, source wallet separation, randomized integer bounds, HTTP fixtures, session recovery, ambiguous writes, partial statuses, price re-review and the published aggregation SDK client with mocked transport/execution. Packed ESM/CJS and consumer declarations are checked without React, wallet SDKs or the aggregation peer installed.
+
+Signature domain implementations follow the primary [NEAR NEP-413 specification](https://github.com/near/NEPs/blob/master/neps/nep-0413.md) and [TronWeb message implementation](https://github.com/tronprotocol/tronweb/blob/master/src/utils/message.ts).
+
+No real wallet signature, source funding transaction or npm publication is performed by tests. Live service checks are separate from fixture coverage. Before production use, verify the deployed intent format, POST withdrawal authorization, swap report schema, final status semantics, registry and fee policy in your environment; then perform explicitly approved small-value end-to-end tests.

package/dist/adapters/index.cjs

@@ -0,0 +1,287 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/index.ts
+var adapters_exports = {};
+__export(adapters_exports, {
+  createCheckedAdapter: () => createCheckedAdapter,
+  createEvmSigningAdapter: () => createEvmSigningAdapter,
+  createNearSigningAdapter: () => createNearSigningAdapter,
+  createSolanaSigningAdapter: () => createSolanaSigningAdapter,
+  createTronSigningAdapter: () => createTronSigningAdapter
+});
+module.exports = __toCommonJS(adapters_exports);
+var import_base4 = require("@scure/base");
+
+// src/errors.ts
+var ConfidentialSwapError = class extends Error {
+  constructor(code, message, status, executionId) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.executionId = executionId;
+  }
+  code;
+  status;
+  executionId;
+  name = "ConfidentialSwapError";
+};
+function assert(condition, message) {
+  if (!condition) throw new ConfidentialSwapError("INVALID_INPUT", message);
+}
+function responseAssert(condition, message) {
+  if (!condition) throw new ConfidentialSwapError("INVALID_RESPONSE", message);
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw new ConfidentialSwapError("ABORTED", "Local operation cancelled; submitted transactions are not cancelled.");
+}
+
+// src/identity.ts
+var import_base = require("@scure/base");
+var import_sha2562 = require("@noble/hashes/sha256");
+
+// src/utils.ts
+var import_sha256 = require("@noble/hashes/sha256");
+var import_utils = require("@noble/hashes/utils");
+function text(value, field) {
+  assert(typeof value === "string" && value.trim().length > 0, `${field} is required.`);
+  return value.trim();
+}
+function clone(value) {
+  return structuredClone(value);
+}
+
+// src/identity.ts
+function deriveConfidentialAccountId(kind, address) {
+  const account = text(address, "Wallet account");
+  if (kind === "near") {
+    assert(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/.test(account) && account.length >= 2 && account.length <= 64, "Invalid NEAR account.");
+    return account;
+  }
+  if (kind === "evm") {
+    assert(/^0x[0-9a-f]{40}$/i.test(account), "Invalid EVM address.");
+    return account.toLowerCase();
+  }
+  if (kind === "solana") {
+    const bytes2 = import_base.base58.decode(account);
+    assert(bytes2.length === 32, "Invalid Solana public key.");
+    return import_base.base16.encode(bytes2).toLowerCase();
+  }
+  assert(kind === "tron", "Unsupported linking wallet kind.");
+  const bytes = (0, import_base.base58check)(import_sha2562.sha256).decode(account);
+  assert(bytes.length === 21 && bytes[0] === 65, "Invalid Tron address.");
+  return `0x${import_base.base16.encode(bytes.slice(1)).toLowerCase()}`;
+}
+function identityKey(identity) {
+  return `${identity.kind}:${deriveConfidentialAccountId(identity.kind, identity.accountId)}:${identity.publicKey ?? ""}`;
+}
+function sameLinking(a, b) {
+  return identityKey(a) === identityKey(b);
+}
+
+// src/signatures.ts
+var import_ed25519 = require("@noble/curves/ed25519");
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_sha2563 = require("@noble/hashes/sha256");
+var import_sha3 = require("@noble/hashes/sha3");
+var import_utils3 = require("@noble/hashes/utils");
+var import_base2 = require("@scure/base");
+var encode = (s) => new TextEncoder().encode(s);
+function u32(value) {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setUint32(0, value, true);
+  return b;
+}
+function borshString(s) {
+  const b = encode(s);
+  return (0, import_utils3.concatBytes)(u32(b.length), b);
+}
+function decodeNep413Nonce(value) {
+  responseAssert(typeof value === "string", "Invalid NEP-413 nonce.");
+  const normalized = value.trim();
+  let nonce;
+  try {
+    nonce = import_base2.base64.decode(normalized);
+  } catch {
+    const unpadded = normalized.replace(/=+$/, "");
+    try {
+      nonce = import_base2.base64urlnopad.decode(unpadded);
+    } catch {
+      try {
+        nonce = import_base2.base64nopad.decode(unpadded);
+      } catch {
+        responseAssert(false, "Invalid NEP-413 nonce encoding.");
+      }
+    }
+  }
+  responseAssert(nonce.length === 32, "The NEP-413 nonce must be 32 bytes.");
+  return nonce;
+}
+function nep413Hash(payload) {
+  const nonce = decodeNep413Nonce(payload.nonce);
+  return (0, import_sha2563.sha256)((0, import_utils3.concatBytes)(u32(2 ** 31 + 413), borshString(payload.message), nonce, borshString(payload.recipient), payload.callbackUrl === void 0 ? new Uint8Array([0]) : (0, import_utils3.concatBytes)(new Uint8Array([1]), borshString(payload.callbackUrl))));
+}
+function personalMessageHash(message, kind) {
+  const bytes = encode(message);
+  return (0, import_sha3.keccak_256)((0, import_utils3.concatBytes)(encode(`${kind === "evm" ? "Ethereum" : "TRON"} Signed Message:
+${bytes.length}`), bytes));
+}
+function decodeEd25519(value, length) {
+  if (value instanceof Uint8Array) {
+    responseAssert(value.length === length, "Invalid Ed25519 byte length.");
+    return new Uint8Array(value);
+  }
+  const raw2 = value.replace(/^ed25519:/, "");
+  for (const decoder of [() => import_base2.base58.decode(raw2), () => import_base2.base64.decode(raw2), () => import_base2.base16.decode(raw2.replace(/^0x/, "").toUpperCase())]) {
+    try {
+      const b = decoder();
+      if (b.length === length) return b;
+    } catch {
+    }
+  }
+  responseAssert(false, "Invalid Ed25519 encoding.");
+}
+function normalizeSecpSignature(value) {
+  const hex = value.replace(/^0x/i, "");
+  responseAssert(/^[0-9a-f]{130}$/i.test(hex), "Expected a 65-byte signature.");
+  const bytes = import_base2.base16.decode(hex.toUpperCase());
+  const v = bytes[64];
+  responseAssert([0, 1, 27, 28].includes(v), "Invalid recovery id.");
+  bytes[64] = v < 27 ? v + 27 : v;
+  return `0x${import_base2.base16.encode(bytes).toLowerCase()}`;
+}
+function verifyWalletSignature(data, identity) {
+  let valid = false;
+  try {
+    if (identity.kind === "near" && data.standard === "nep413") {
+      const key = decodeEd25519(identity.publicKey ?? "", 32);
+      valid = import_ed25519.ed25519.verify(decodeEd25519(data.signature, 64), nep413Hash(data.payload), key);
+      if (/^[0-9a-f]{64}$/.test(identity.accountId)) valid = valid && import_base2.base16.encode(key).toLowerCase() === identity.accountId;
+    } else if (identity.kind === "solana" && data.standard === "raw_ed25519") {
+      valid = import_ed25519.ed25519.verify(decodeEd25519(data.signature, 64), encode(data.payload), import_base2.base58.decode(identity.accountId));
+    } else if ((identity.kind === "evm" || identity.kind === "tron") && typeof data.payload === "string") {
+      const bytes = import_base2.base16.decode(normalizeSecpSignature(data.signature).slice(2).toUpperCase());
+      const sig = import_secp256k1.secp256k1.Signature.fromCompact(bytes.slice(0, 64)).addRecoveryBit(bytes[64] - 27);
+      const publicKey = sig.recoverPublicKey(personalMessageHash(data.payload, identity.kind)).toRawBytes(false);
+      const address = `0x${import_base2.base16.encode((0, import_sha3.keccak_256)(publicKey.slice(1)).slice(-20)).toLowerCase()}`;
+      valid = address === deriveConfidentialAccountId(identity.kind, identity.accountId);
+    }
+  } catch {
+    valid = false;
+  }
+  responseAssert(valid, "Signature does not verify against the frozen wallet identity.");
+}
+
+// src/validation.ts
+var import_base3 = require("@scure/base");
+function validateSigned(unsigned, signed, identity) {
+  responseAssert(signed.standard === unsigned.standard && JSON.stringify(signed.payload) === JSON.stringify(unsigned.payload), "Wallet changed the payload.");
+  text(signed.signature, "Signature");
+  if (identity.kind === "near" || identity.kind === "solana") {
+    const expected = identity.publicKey ?? (identity.kind === "solana" ? `ed25519:${identity.accountId}` : "");
+    responseAssert(expected && signed.public_key === expected, "Signing public key changed.");
+  }
+  verifyWalletSignature(signed, identity);
+}
+
+// src/adapters/index.ts
+function createEvmSigningAdapter(getSigner) {
+  return createCheckedAdapter({
+    getIdentity: async () => ({ kind: "evm", accountId: await (await getSigner()).getAddress() }),
+    sign: async (data) => {
+      assert(data.standard === "erc191", "Expected ERC-191 payload.");
+      return { ...data, signature: normalizeSecpSignature(await (await getSigner()).signMessage(data.payload)) };
+    }
+  });
+}
+function createSolanaSigningAdapter(getWallet) {
+  return createCheckedAdapter({
+    getIdentity: async () => ({ kind: "solana", accountId: getWallet().publicKey.toBase58(), publicKey: `ed25519:${getWallet().publicKey.toBase58()}` }),
+    sign: async (data) => {
+      assert(data.standard === "raw_ed25519", "Expected raw Ed25519 payload.");
+      const wallet = getWallet();
+      const signature = await wallet.signMessage(new TextEncoder().encode(data.payload));
+      return { ...data, public_key: `ed25519:${wallet.publicKey.toBase58()}`, signature: `ed25519:${import_base4.base58.encode(decodeEd25519(signature, 64))}` };
+    }
+  });
+}
+function createTronSigningAdapter(getWallet) {
+  return createCheckedAdapter({
+    getIdentity: async () => ({ kind: "tron", accountId: await getWallet().getAddress() }),
+    sign: async (data) => {
+      assert(data.standard === "tip191", "Expected TIP-191 payload.");
+      return { ...data, signature: normalizeSecpSignature(await getWallet().signMessageV2(data.payload)) };
+    }
+  });
+}
+function createNearSigningAdapter(wallet, api) {
+  const getIdentity = async () => {
+    const identity = await wallet.getIdentity();
+    return { kind: "near", accountId: identity.accountId, publicKey: `ed25519:${import_base4.base58.encode(decodeEd25519(identity.publicKey, 32))}` };
+  };
+  return createCheckedAdapter({
+    getIdentity,
+    prepare: async (signal) => {
+      const identity = await getIdentity();
+      if (/^[0-9a-f]{64}$/.test(identity.accountId)) {
+        const keyHex = Array.from(decodeEd25519(identity.publicKey, 32), (b) => b.toString(16).padStart(2, "0")).join("");
+        assert(keyHex === identity.accountId, "Implicit NEAR account does not match its signing public key.");
+      } else {
+        const registered = await api.viewIntents("has_public_key", { account_id: identity.accountId, public_key: identity.publicKey }, signal);
+        responseAssert(typeof registered === "boolean", "Invalid key registration response.");
+        if (!registered) {
+          assert(wallet.registerPublicKey, "NEAR key registration requires an explicit registerPublicKey callback.");
+          throwIfAborted(signal);
+          await wallet.registerPublicKey(identity.accountId, identity.publicKey, api.intentsContract, signal);
+          responseAssert(await api.viewIntents("has_public_key", { account_id: identity.accountId, public_key: identity.publicKey }, signal) === true, "NEAR signing key registration is not confirmed.");
+        }
+      }
+    },
+    sign: async (data) => {
+      assert(data.standard === "nep413", "Expected NEP-413 payload.");
+      const result = await wallet.signMessage({ ...data.payload, nonce: decodeNep413Nonce(data.payload.nonce) });
+      responseAssert(result.accountId === (await getIdentity()).accountId, "NEAR wallet returned a different account.");
+      return { ...data, public_key: `ed25519:${import_base4.base58.encode(decodeEd25519(result.publicKey, 32))}`, signature: `ed25519:${import_base4.base58.encode(decodeEd25519(result.signature, 64))}` };
+    }
+  });
+}
+function createCheckedAdapter(adapter) {
+  return {
+    getIdentity: () => adapter.getIdentity(),
+    prepare: adapter.prepare?.bind(adapter),
+    sign: async (data, signal) => {
+      throwIfAborted(signal);
+      const identity = await adapter.getIdentity();
+      const signed = await adapter.sign(clone(data), signal);
+      throwIfAborted(signal);
+      if (!sameLinking(identity, await adapter.getIdentity())) throw new ConfidentialSwapError("WALLET_CHANGED", "Wallet identity changed while signing.");
+      validateSigned(data, signed, identity);
+      return signed;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCheckedAdapter,
+  createEvmSigningAdapter,
+  createNearSigningAdapter,
+  createSolanaSigningAdapter,
+  createTronSigningAdapter
+});
+//# sourceMappingURL=index.cjs.map

package/dist/adapters/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/index.ts","../../src/errors.ts","../../src/identity.ts","../../src/utils.ts","../../src/signatures.ts","../../src/validation.ts"],"sourcesContent":["import { base58 } from \"@scure/base\";\nimport { assert, ConfidentialSwapError, responseAssert, throwIfAborted } from \"../errors\";\nimport { sameLinking } from \"../identity\";\nimport { decodeEd25519, decodeNep413Nonce, normalizeSecpSignature } from \"../signatures\";\nimport { clone } from \"../utils\";\nimport { validateSigned } from \"../validation\";\nimport type { HttpConfidentialApi } from \"../api\";\nimport type { LinkingIdentity, SignedData, SigningAdapter, UnsignedData } from \"../types\";\n\nexport interface EvmMessageSigner { getAddress(): Promise<string>; signMessage(message: string): Promise<string> }\nexport function createEvmSigningAdapter(getSigner: () => Promise<EvmMessageSigner> | EvmMessageSigner): SigningAdapter {\n  return createCheckedAdapter({\n    getIdentity: async () => ({ kind: \"evm\", accountId: await (await getSigner()).getAddress() }),\n    sign: async (data) => {\n      assert(data.standard === \"erc191\", \"Expected ERC-191 payload.\");\n      return { ...data, signature: normalizeSecpSignature(await (await getSigner()).signMessage(data.payload)) };\n    },\n  });\n}\nexport interface SolanaMessageSigner { publicKey: { toBase58(): string }; signMessage(message: Uint8Array): Promise<Uint8Array> }\nexport function createSolanaSigningAdapter(getWallet: () => SolanaMessageSigner): SigningAdapter {\n  return createCheckedAdapter({\n    getIdentity: async () => ({ kind: \"solana\", accountId: getWallet().publicKey.toBase58(), publicKey: `ed25519:${getWallet().publicKey.toBase58()}` }),\n    sign: async (data) => {\n      assert(data.standard === \"raw_ed25519\", \"Expected raw Ed25519 payload.\");\n      const wallet = getWallet();\n      const signature = await wallet.signMessage(new TextEncoder().encode(data.payload));\n      return { ...data, public_key: `ed25519:${wallet.publicKey.toBase58()}`, signature: `ed25519:${base58.encode(decodeEd25519(signature, 64))}` };\n    },\n  });\n}\nexport interface TronMessageSigner { getAddress(): Promise<string> | string; signMessageV2(message: string): Promise<string> }\nexport function createTronSigningAdapter(getWallet: () => TronMessageSigner): SigningAdapter {\n  return createCheckedAdapter({\n    getIdentity: async () => ({ kind: \"tron\", accountId: await getWallet().getAddress() }),\n    sign: async (data) => {\n      assert(data.standard === \"tip191\", \"Expected TIP-191 payload.\");\n      return { ...data, signature: normalizeSecpSignature(await getWallet().signMessageV2(data.payload)) };\n    },\n  });\n}\nexport interface NearMessageSigner {\n  getIdentity(): Promise<{ accountId: string; publicKey: string }>;\n  signMessage(params: { message: string; recipient: string; nonce: Uint8Array; callbackUrl?: string }): Promise<{ accountId: string; publicKey: string; signature: string }>;\n  /** Explicit user-approved NEAR transaction: add_public_key on the configured Intents contract. */\n  registerPublicKey?(accountId: string, publicKey: string, contract: string, signal?: AbortSignal): Promise<void>;\n}\nexport function createNearSigningAdapter(wallet: NearMessageSigner, api: Pick<HttpConfidentialApi, \"viewIntents\" | \"intentsContract\">): SigningAdapter {\n  const getIdentity = async (): Promise<LinkingIdentity> => {\n    const identity = await wallet.getIdentity();\n    return { kind: \"near\", accountId: identity.accountId, publicKey: `ed25519:${base58.encode(decodeEd25519(identity.publicKey, 32))}` };\n  };\n  return createCheckedAdapter({\n    getIdentity,\n    prepare: async (signal) => {\n      const identity = await getIdentity();\n      if (/^[0-9a-f]{64}$/.test(identity.accountId)) {\n        const keyHex = Array.from(decodeEd25519(identity.publicKey!, 32), (b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n        assert(keyHex === identity.accountId, \"Implicit NEAR account does not match its signing public key.\");\n      } else {\n        const registered = await api.viewIntents<boolean>(\"has_public_key\", { account_id: identity.accountId, public_key: identity.publicKey }, signal);\n        responseAssert(typeof registered === \"boolean\", \"Invalid key registration response.\");\n        if (!registered) {\n          assert(wallet.registerPublicKey, \"NEAR key registration requires an explicit registerPublicKey callback.\");\n          throwIfAborted(signal);\n          await wallet.registerPublicKey(identity.accountId, identity.publicKey!, api.intentsContract, signal);\n          responseAssert(await api.viewIntents<boolean>(\"has_public_key\", { account_id: identity.accountId, public_key: identity.publicKey }, signal) === true, \"NEAR signing key registration is not confirmed.\");\n        }\n      }\n    },\n    sign: async (data) => {\n      assert(data.standard === \"nep413\", \"Expected NEP-413 payload.\");\n      const result = await wallet.signMessage({ ...data.payload, nonce: decodeNep413Nonce(data.payload.nonce) });\n      responseAssert(result.accountId === (await getIdentity()).accountId, \"NEAR wallet returned a different account.\");\n      return { ...data, public_key: `ed25519:${base58.encode(decodeEd25519(result.publicKey, 32))}`, signature: `ed25519:${base58.encode(decodeEd25519(result.signature, 64))}` };\n    },\n  });\n}\nexport function createCheckedAdapter(adapter: SigningAdapter): SigningAdapter {\n  return {\n    getIdentity: () => adapter.getIdentity(),\n    prepare: adapter.prepare?.bind(adapter),\n    sign: async (data: UnsignedData, signal?: AbortSignal): Promise<SignedData> => {\n      throwIfAborted(signal);\n      const identity = await adapter.getIdentity();\n      const signed = await adapter.sign(clone(data), signal);\n      throwIfAborted(signal);\n      if (!sameLinking(identity, await adapter.getIdentity())) throw new ConfidentialSwapError(\"WALLET_CHANGED\", \"Wallet identity changed while signing.\");\n      validateSigned(data, signed, identity);\n      return signed;\n    },\n  };\n}\n","export type ErrorCode =\n  | \"INVALID_INPUT\" | \"INVALID_RESPONSE\" | \"HTTP_ERROR\" | \"UNAUTHORIZED\"\n  | \"WALLET_CHANGED\" | \"MISSING_WALLET\" | \"QUOTE_EXPIRED\" | \"BUSY\"\n  | \"CONFIRMATION_REQUIRED\" | \"TIMEOUT\" | \"ABORTED\" | \"TERMINAL_FAILURE\";\n\nexport class ConfidentialSwapError extends Error {\n  readonly name = \"ConfidentialSwapError\";\n  constructor(\n    readonly code: ErrorCode,\n    message: string,\n    readonly status?: number,\n    readonly executionId?: string,\n  ) { super(message); }\n}\n\nexport function assert(condition: unknown, message: string): asserts condition {\n  if (!condition) throw new ConfidentialSwapError(\"INVALID_INPUT\", message);\n}\n\nexport function responseAssert(condition: unknown, message: string): asserts condition {\n  if (!condition) throw new ConfidentialSwapError(\"INVALID_RESPONSE\", message);\n}\n\nexport function throwIfAborted(signal?: AbortSignal): void {\n  if (signal?.aborted) throw new ConfidentialSwapError(\"ABORTED\", \"Local operation cancelled; submitted transactions are not cancelled.\");\n}\n","import { base16, base58, base58check } from \"@scure/base\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { assert } from \"./errors\";\nimport { text } from \"./utils\";\nimport type { FundingIdentity, LinkingIdentity, LinkingKind, SigningStandard } from \"./types\";\n\nexport const CONFIDENTIAL_LINKING_KINDS = [\"near\", \"evm\", \"solana\", \"tron\"] as const;\nexport const standards: Record<LinkingKind, SigningStandard> = { near: \"nep413\", evm: \"erc191\", solana: \"raw_ed25519\", tron: \"tip191\" };\nexport function deriveConfidentialAccountId(kind: LinkingKind, address: string): string {\n  const account = text(address, \"Wallet account\");\n  if (kind === \"near\") {\n    assert(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/.test(account) && account.length >= 2 && account.length <= 64, \"Invalid NEAR account.\");\n    return account;\n  }\n  if (kind === \"evm\") { assert(/^0x[0-9a-f]{40}$/i.test(account), \"Invalid EVM address.\"); return account.toLowerCase(); }\n  if (kind === \"solana\") {\n    const bytes = base58.decode(account);\n    assert(bytes.length === 32, \"Invalid Solana public key.\");\n    return base16.encode(bytes).toLowerCase();\n  }\n  assert(kind === \"tron\", \"Unsupported linking wallet kind.\");\n  const bytes = base58check(sha256).decode(account);\n  assert(bytes.length === 21 && bytes[0] === 0x41, \"Invalid Tron address.\");\n  return `0x${base16.encode(bytes.slice(1)).toLowerCase()}`;\n}\nexport function identityKey(identity: LinkingIdentity): string {\n  return `${identity.kind}:${deriveConfidentialAccountId(identity.kind, identity.accountId)}:${identity.publicKey ?? \"\"}`;\n}\nexport function sameLinking(a: LinkingIdentity, b: LinkingIdentity): boolean { return identityKey(a) === identityKey(b); }\nexport function sameFunding(a: FundingIdentity, b: FundingIdentity): boolean {\n  return a.kind === b.kind && a.chain === b.chain && (a.kind === \"evm\" ? a.accountId.toLowerCase() === b.accountId.toLowerCase() : a.accountId === b.accountId);\n}\nexport function resolveLinkingWallet(input: { sourceKind?: string; wallets: readonly LinkingIdentity[]; preferred?: LinkingIdentity }): LinkingIdentity | null {\n  const wallets = input.wallets.filter((w) => CONFIDENTIAL_LINKING_KINDS.includes(w.kind) && w.accountId.trim());\n  if (input.preferred) return wallets.find((w) => sameLinking(w, input.preferred!)) ?? null;\n  return wallets.find((w) => w.kind === input.sourceKind) ?? CONFIDENTIAL_LINKING_KINDS.map((kind) => wallets.find((w) => w.kind === kind)).find(Boolean) ?? null;\n}\n","import { sha256 } from \"@noble/hashes/sha256\";\nimport { bytesToHex } from \"@noble/hashes/utils\";\nimport { assert, throwIfAborted } from \"./errors\";\nimport type { Balance, QuotePlan } from \"./types\";\n\nexport function raw(value: unknown, field = \"Amount\", allowZero = false): bigint {\n  assert(typeof value === \"string\" && /^(0|[1-9]\\d*)$/.test(value), `${field} must be a canonical integer string.`);\n  const result = BigInt(value);\n  assert(allowZero || result > 0n, `${field} must be positive.`);\n  return result;\n}\nexport function text(value: unknown, field: string): string {\n  assert(typeof value === \"string\" && value.trim().length > 0, `${field} is required.`);\n  return value.trim();\n}\nexport function clone<T>(value: T): T { return structuredClone(value); }\nfunction canonical(value: unknown): string {\n  if (Array.isArray(value)) return `[${value.map(canonical).join(\",\")}]`;\n  if (value && typeof value === \"object\") {\n    return `{${Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b))\n      .map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(\",\")}}`;\n  }\n  assert(value === null || [\"string\", \"boolean\", \"number\"].includes(typeof value), \"Plan data must be JSON-serializable.\");\n  if (typeof value === \"number\") assert(Number.isFinite(value), \"Plan numbers must be finite.\");\n  return JSON.stringify(value);\n}\nexport function planDigest(plan: Omit<QuotePlan, \"digest\"> | QuotePlan): string {\n  const { digest: _digest, ...body } = plan as QuotePlan;\n  return bytesToHex(sha256(new TextEncoder().encode(canonical(body))));\n}\nexport function randomFraction(): number {\n  return crypto.getRandomValues(new Uint32Array(1))[0]! / 0xffffffff;\n}\nexport function splitConfidentialRawAmount(totalRaw: string, count: number, values?: readonly number[]): string[] {\n  assert(Number.isInteger(count) && count >= 1 && count <= 10, \"A batch requires 1 to 10 recipients.\");\n  const total = raw(totalRaw);\n  assert(total >= BigInt(count), \"Amount too small for every recipient.\");\n  const minimum = total * 80n / (100n * BigInt(count));\n  const lowBound = minimum > 0n ? minimum : 1n;\n  const denominator = 100n * BigInt(count);\n  const maximum = (total * 120n + denominator - 1n) / denominator;\n  const highBound = maximum > lowBound ? maximum : lowBound;\n  const shares: bigint[] = [];\n  let remaining = total;\n  for (let i = 0; i < count - 1; i++) {\n    const left = BigInt(count - i - 1);\n    const low = remaining - highBound * left > lowBound ? remaining - highBound * left : lowBound;\n    const high = remaining - lowBound * left < highBound ? remaining - lowBound * left : highBound;\n    assert(low <= high, \"Amount cannot be split safely.\");\n    const fraction = values?.[i] ?? randomFraction();\n    assert(Number.isFinite(fraction) && fraction >= 0 && fraction <= 1, \"Random fractions must be within [0, 1].\");\n    const share = low + (high - low) * BigInt(Math.floor(fraction * 1_000_000)) / 1_000_000n;\n    shares.push(share);\n    remaining -= share;\n  }\n  assert(remaining >= lowBound && remaining <= highBound, \"Final share outside safe bounds.\");\n  return [...shares, remaining].map(String);\n}\nexport function availableForAsset(balances: readonly Balance[], assetId: string): string {\n  const exact = balances.find((b) => b.tokenId === assetId);\n  const entry = exact ?? balances.find((b) => b.tokenId.startsWith(\"imt:\") && b.tokenId.endsWith(`:${assetId}`));\n  return raw(entry?.available ?? \"0\", \"Available balance\", true).toString();\n}\nexport async function delay(ms: number, signal?: AbortSignal): Promise<void> {\n  throwIfAborted(signal);\n  await new Promise<void>((resolve, reject) => {\n    const finish = () => { signal?.removeEventListener(\"abort\", abort); resolve(); };\n    const timer = setTimeout(finish, ms);\n    const abort = () => { clearTimeout(timer); signal?.removeEventListener(\"abort\", abort); try { throwIfAborted(signal); } catch (e) { reject(e); } };\n    signal?.addEventListener(\"abort\", abort, { once: true });\n  });\n}\n","import { ed25519 } from \"@noble/curves/ed25519\";\nimport { secp256k1 } from \"@noble/curves/secp256k1\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { keccak_256 } from \"@noble/hashes/sha3\";\nimport { concatBytes } from \"@noble/hashes/utils\";\nimport { base16, base58, base64, base64nopad, base64urlnopad } from \"@scure/base\";\nimport { responseAssert } from \"./errors\";\nimport { deriveConfidentialAccountId } from \"./identity\";\nimport type { LinkingIdentity, SignedData, UnsignedData } from \"./types\";\n\nconst encode = (s: string) => new TextEncoder().encode(s);\nfunction u32(value: number): Uint8Array { const b = new Uint8Array(4); new DataView(b.buffer).setUint32(0, value, true); return b; }\nfunction borshString(s: string): Uint8Array { const b = encode(s); return concatBytes(u32(b.length), b); }\nexport function decodeNep413Nonce(value: string): Uint8Array {\n  responseAssert(typeof value === \"string\", \"Invalid NEP-413 nonce.\");\n  const normalized = value.trim();\n  let nonce: Uint8Array;\n  try { nonce = base64.decode(normalized); }\n  catch {\n    const unpadded = normalized.replace(/=+$/, \"\");\n    try { nonce = base64urlnopad.decode(unpadded); }\n    catch {\n      try { nonce = base64nopad.decode(unpadded); }\n      catch { responseAssert(false, \"Invalid NEP-413 nonce encoding.\"); }\n    }\n  }\n  responseAssert(nonce.length === 32, \"The NEP-413 nonce must be 32 bytes.\");\n  return nonce;\n}\nexport function nep413Hash(payload: Extract<UnsignedData, { standard: \"nep413\" }>[\"payload\"]): Uint8Array {\n  const nonce = decodeNep413Nonce(payload.nonce);\n  return sha256(concatBytes(u32(2 ** 31 + 413), borshString(payload.message), nonce, borshString(payload.recipient), payload.callbackUrl === undefined ? new Uint8Array([0]) : concatBytes(new Uint8Array([1]), borshString(payload.callbackUrl))));\n}\nexport function personalMessageHash(message: string, kind: \"evm\" | \"tron\"): Uint8Array {\n  const bytes = encode(message);\n  return keccak_256(concatBytes(encode(`\\x19${kind === \"evm\" ? \"Ethereum\" : \"TRON\"} Signed Message:\\n${bytes.length}`), bytes));\n}\nexport function decodeEd25519(value: string | Uint8Array, length: number): Uint8Array {\n  if (value instanceof Uint8Array) { responseAssert(value.length === length, \"Invalid Ed25519 byte length.\"); return new Uint8Array(value); }\n  const raw = value.replace(/^ed25519:/, \"\");\n  for (const decoder of [() => base58.decode(raw), () => base64.decode(raw), () => base16.decode(raw.replace(/^0x/, \"\").toUpperCase())]) {\n    try { const b = decoder(); if (b.length === length) return b; } catch { /* Wallets use base58, base64, or hex. */ }\n  }\n  responseAssert(false, \"Invalid Ed25519 encoding.\");\n}\nexport function normalizeSecpSignature(value: string): string {\n  const hex = value.replace(/^0x/i, \"\");\n  responseAssert(/^[0-9a-f]{130}$/i.test(hex), \"Expected a 65-byte signature.\");\n  const bytes = base16.decode(hex.toUpperCase());\n  const v = bytes[64]!;\n  responseAssert([0, 1, 27, 28].includes(v), \"Invalid recovery id.\");\n  bytes[64] = v < 27 ? v + 27 : v;\n  return `0x${base16.encode(bytes).toLowerCase()}`;\n}\nexport function verifyWalletSignature(data: SignedData, identity: LinkingIdentity): void {\n  let valid = false;\n  try {\n    if (identity.kind === \"near\" && data.standard === \"nep413\") {\n      const key = decodeEd25519(identity.publicKey ?? \"\", 32);\n      valid = ed25519.verify(decodeEd25519(data.signature, 64), nep413Hash(data.payload), key);\n      if (/^[0-9a-f]{64}$/.test(identity.accountId)) valid = valid && base16.encode(key).toLowerCase() === identity.accountId;\n    } else if (identity.kind === \"solana\" && data.standard === \"raw_ed25519\") {\n      valid = ed25519.verify(decodeEd25519(data.signature, 64), encode(data.payload), base58.decode(identity.accountId));\n    } else if ((identity.kind === \"evm\" || identity.kind === \"tron\") && typeof data.payload === \"string\") {\n      const bytes = base16.decode(normalizeSecpSignature(data.signature).slice(2).toUpperCase());\n      const sig = secp256k1.Signature.fromCompact(bytes.slice(0, 64)).addRecoveryBit(bytes[64]! - 27);\n      const publicKey = sig.recoverPublicKey(personalMessageHash(data.payload, identity.kind)).toRawBytes(false);\n      const address = `0x${base16.encode(keccak_256(publicKey.slice(1)).slice(-20)).toLowerCase()}`;\n      valid = address === deriveConfidentialAccountId(identity.kind, identity.accountId);\n    }\n  } catch { valid = false; }\n  responseAssert(valid, \"Signature does not verify against the frozen wallet identity.\");\n}\n","import { base58, base64 } from \"@scure/base\";\nimport { assert, responseAssert } from \"./errors\";\nimport { deriveConfidentialAccountId, standards } from \"./identity\";\nimport { normalizeChain } from \"./routing\";\nimport { raw, text } from \"./utils\";\nimport { decodeNep413Nonce, verifyWalletSignature } from \"./signatures\";\nimport type { LinkingIdentity, QuoteResponse, SignedData, Token, UnsignedData } from \"./types\";\n\nconst evmChains = new Set([\"eth\", \"arb\", \"avax\", \"op\", \"pol\", \"bsc\", \"base\", \"gnosis\", \"aurora\", \"bera\", \"berachain\", \"monad\", \"hypercore\", \"hyperliquid\", \"linea\", \"scroll\", \"zksync\", \"mantle\", \"celo\", \"sonic\"]);\nexport type AddressValidator = (address: string, token: Token) => boolean;\nexport function validateRecipients(addresses: readonly string[], token: Token, custom?: AddressValidator): string[] {\n  assert(addresses.length >= 1 && addresses.length <= 10, \"A batch requires 1 to 10 recipients.\");\n  const chain = normalizeChain(token.blockchain);\n  const evm = evmChains.has(chain) || /^\\d+$/.test(token.swapChain ?? chain);\n  const seen = new Set<string>();\n  return addresses.map((value) => {\n    const address = text(value, \"Recipient address\");\n    let valid = false;\n    try {\n      if (custom) valid = custom(address, token);\n      else if (evm) valid = /^0x[0-9a-f]{40}$/i.test(address);\n      else if (chain === \"near\") { deriveConfidentialAccountId(\"near\", address); valid = true; }\n      else if (chain === \"sol\") valid = base58.decode(address).length === 32;\n      else if (chain === \"tron\") { deriveConfidentialAccountId(\"tron\", address); valid = true; }\n      else if (chain === \"aptos\") valid = /^0x[0-9a-f]{1,64}$/i.test(address);\n      else if (chain === \"sui\") valid = /^0x[0-9a-f]{64}$/i.test(address);\n      else assert(false, \"Supply an address validator for this destination chain (including BTC/Zcash).\");\n    } catch (error) { if (!custom && !evm && ![\"near\", \"sol\", \"tron\", \"aptos\", \"sui\"].includes(chain)) throw error; }\n    assert(valid, \"Invalid recipient address for the destination chain.\");\n    const key = evm || [\"aptos\", \"sui\"].includes(chain) ? address.toLowerCase() : address;\n    assert(!seen.has(key), \"Duplicate recipient address.\");\n    seen.add(key);\n    return address;\n  });\n}\nexport function validateToken(token: Token): void {\n  text(token.assetId, \"Asset id\"); text(token.blockchain, \"Blockchain\"); text(token.symbol, \"Symbol\");\n  assert(Number.isInteger(token.decimals) && token.decimals >= 0 && token.decimals <= 255, \"Invalid token decimals.\");\n}\nexport function validateQuote(q: QuoteResponse, requireDeposit: boolean): void {\n  responseAssert(q && typeof q.quote === \"object\" && q.quote, \"Missing quote.\");\n  raw(q.quote.amountIn, \"Quoted input\"); raw(q.quote.amountOut, \"Quoted output\");\n  if (q.quote.minAmountOut !== undefined) assert(raw(q.quote.minAmountOut) <= raw(q.quote.amountOut), \"Minimum output exceeds quoted output.\");\n  if (q.quote.minAmountIn !== undefined) raw(q.quote.minAmountIn);\n  if (requireDeposit) text(q.quote.depositAddress, \"Deposit address\");\n}\nexport function payloadMessage(data: UnsignedData): Record<string, unknown> {\n  let message: unknown;\n  try { message = JSON.parse(typeof data.payload === \"string\" ? data.payload : data.payload.message); }\n  catch { responseAssert(false, \"Invalid intent JSON.\"); }\n  responseAssert(message && typeof message === \"object\" && !Array.isArray(message), \"Invalid intent payload.\");\n  return message as Record<string, unknown>;\n}\nexport function validatePayload(data: UnsignedData, identity: LinkingIdentity, signerId: string, contract: string, now: number, purpose: \"authorization\" | \"withdrawal\" = \"authorization\"): Record<string, unknown> {\n  responseAssert(data.standard === standards[identity.kind], \"Signing standard does not match wallet.\");\n  const msg = payloadMessage(data);\n  responseAssert(msg.signer_id === signerId, \"Intent signer does not match the frozen identity.\");\n  const deadline = Date.parse(String(msg.deadline ?? \"\"));\n  responseAssert(Number.isFinite(deadline) && deadline > now, \"Intent deadline expired or invalid.\");\n  responseAssert(Array.isArray(msg.intents), \"Intent list is missing.\");\n  if (data.standard === \"nep413\") {\n    text(data.payload.recipient, \"NEP-413 recipient\");\n    // Generated withdrawals carry their own signed recipient; only login binds the configured verifier.\n    if (purpose === \"authorization\") responseAssert(data.payload.recipient === contract, \"Invalid NEP-413 authorization verifier.\");\n    decodeNep413Nonce(data.payload.nonce);\n  } else {\n    responseAssert(msg.verifying_contract === contract && typeof msg.nonce === \"string\" && base64.decode(msg.nonce).length === 32, \"Invalid verifier or nonce.\");\n  }\n  return msg;\n}\nexport function validateSigned(unsigned: UnsignedData, signed: SignedData, identity: LinkingIdentity): void {\n  responseAssert(signed.standard === unsigned.standard && JSON.stringify(signed.payload) === JSON.stringify(unsigned.payload), \"Wallet changed the payload.\");\n  text(signed.signature, \"Signature\");\n  if (identity.kind === \"near\" || identity.kind === \"solana\") {\n    const expected = identity.publicKey ?? (identity.kind === \"solana\" ? `ed25519:${identity.accountId}` : \"\");\n    responseAssert(expected && signed.public_key === expected, \"Signing public key changed.\");\n  }\n  verifyWalletSignature(signed, identity);\n}\n"],"mappings":"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","names":["import_base","import_sha256","bytes","import_sha256","import_utils","import_base","raw","import_base"]}

package/dist/adapters/index.d.cts

@@ -0,0 +1,42 @@
+import { H as HttpConfidentialApi } from '../api-DenG9sWp.cjs';
+import { S as SigningAdapter } from '../types-Bq8OZRUK.cjs';
+
+interface EvmMessageSigner {
+    getAddress(): Promise<string>;
+    signMessage(message: string): Promise<string>;
+}
+declare function createEvmSigningAdapter(getSigner: () => Promise<EvmMessageSigner> | EvmMessageSigner): SigningAdapter;
+interface SolanaMessageSigner {
+    publicKey: {
+        toBase58(): string;
+    };
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+declare function createSolanaSigningAdapter(getWallet: () => SolanaMessageSigner): SigningAdapter;
+interface TronMessageSigner {
+    getAddress(): Promise<string> | string;
+    signMessageV2(message: string): Promise<string>;
+}
+declare function createTronSigningAdapter(getWallet: () => TronMessageSigner): SigningAdapter;
+interface NearMessageSigner {
+    getIdentity(): Promise<{
+        accountId: string;
+        publicKey: string;
+    }>;
+    signMessage(params: {
+        message: string;
+        recipient: string;
+        nonce: Uint8Array;
+        callbackUrl?: string;
+    }): Promise<{
+        accountId: string;
+        publicKey: string;
+        signature: string;
+    }>;
+    /** Explicit user-approved NEAR transaction: add_public_key on the configured Intents contract. */
+    registerPublicKey?(accountId: string, publicKey: string, contract: string, signal?: AbortSignal): Promise<void>;
+}
+declare function createNearSigningAdapter(wallet: NearMessageSigner, api: Pick<HttpConfidentialApi, "viewIntents" | "intentsContract">): SigningAdapter;
+declare function createCheckedAdapter(adapter: SigningAdapter): SigningAdapter;
+
+export { type EvmMessageSigner, type NearMessageSigner, type SolanaMessageSigner, type TronMessageSigner, createCheckedAdapter, createEvmSigningAdapter, createNearSigningAdapter, createSolanaSigningAdapter, createTronSigningAdapter };

package/dist/adapters/index.d.ts

@@ -0,0 +1,42 @@
+import { H as HttpConfidentialApi } from '../api-cazA5IdP.js';
+import { S as SigningAdapter } from '../types-Bq8OZRUK.js';
+
+interface EvmMessageSigner {
+    getAddress(): Promise<string>;
+    signMessage(message: string): Promise<string>;
+}
+declare function createEvmSigningAdapter(getSigner: () => Promise<EvmMessageSigner> | EvmMessageSigner): SigningAdapter;
+interface SolanaMessageSigner {
+    publicKey: {
+        toBase58(): string;
+    };
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+declare function createSolanaSigningAdapter(getWallet: () => SolanaMessageSigner): SigningAdapter;
+interface TronMessageSigner {
+    getAddress(): Promise<string> | string;
+    signMessageV2(message: string): Promise<string>;
+}
+declare function createTronSigningAdapter(getWallet: () => TronMessageSigner): SigningAdapter;
+interface NearMessageSigner {
+    getIdentity(): Promise<{
+        accountId: string;
+        publicKey: string;
+    }>;
+    signMessage(params: {
+        message: string;
+        recipient: string;
+        nonce: Uint8Array;
+        callbackUrl?: string;
+    }): Promise<{
+        accountId: string;
+        publicKey: string;
+        signature: string;
+    }>;
+    /** Explicit user-approved NEAR transaction: add_public_key on the configured Intents contract. */
+    registerPublicKey?(accountId: string, publicKey: string, contract: string, signal?: AbortSignal): Promise<void>;
+}
+declare function createNearSigningAdapter(wallet: NearMessageSigner, api: Pick<HttpConfidentialApi, "viewIntents" | "intentsContract">): SigningAdapter;
+declare function createCheckedAdapter(adapter: SigningAdapter): SigningAdapter;
+
+export { type EvmMessageSigner, type NearMessageSigner, type SolanaMessageSigner, type TronMessageSigner, createCheckedAdapter, createEvmSigningAdapter, createNearSigningAdapter, createSolanaSigningAdapter, createTronSigningAdapter };