@piprail/sdk 1.0.0

package/dist/near-4P5XNMMB.cjs

@@ -0,0 +1,346 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+var _chunkWQWNPAYQcjs = require('./chunk-WQWNPAYQ.cjs');
+
+// src/drivers/near/index.ts
+var _nearapijs = require('near-api-js');
+
+// src/drivers/near/chains.ts
+var NEAR_DECIMALS = 24;
+var NEAR_MAINNET = {
+  caip2: "near:mainnet",
+  defaultRpc: "https://free.rpc.fastnear.com",
+  tokens: {
+    // Circle USDC — native (NOT the .factory.bridge.near bridge). Contract + 6dp
+    // verified live via ft_metadata before shipping.
+    USDC: {
+      contractId: "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+      decimals: 6,
+      symbol: "USDC"
+    },
+    // Tether USDt — native (Tether's official tether-token.near account). On-chain
+    // symbol is "USDt"; contract + 6dp verified live via ft_metadata before shipping.
+    USDT: {
+      contractId: "usdt.tether-token.near",
+      decimals: 6,
+      symbol: "USDT"
+    }
+  }
+};
+
+// src/drivers/near/pay.ts
+var FT_TRANSFER_GAS = 30000000000000n;
+var ONE_YOCTO = 1n;
+async function payNear(params) {
+  const { client, accept, gas } = params;
+  try {
+    const res = await client.ftTransfer({
+      contractId: accept.asset,
+      receiverId: accept.payTo,
+      amount: accept.amount,
+      memo: accept.extra.nonce,
+      // nonce binding (Template A)
+      gas: _nullishCoalesce(gas, () => ( FT_TRANSFER_GAS)),
+      deposit: ONE_YOCTO
+    });
+    return res.hash;
+  } catch (err) {
+    if (isNearRegistrationError(err)) {
+      throw new Error(
+        `NEAR ft_transfer failed: recipient ${accept.payTo} isn't registered on token ${accept.asset} (NEP-145 storage_deposit). Register it once (\u22480.00125 NEAR) before it can receive.`,
+        { cause: err }
+      );
+    }
+    if (isNearAffordability(err)) {
+      throw new (0, _chunkWQWNPAYQcjs.InsufficientFundsError)(
+        err instanceof Error ? err.message : "Insufficient NEAR balance for the payment.",
+        { cause: err }
+      );
+    }
+    throw _nullishCoalesce(_chunkWQWNPAYQcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+  }
+}
+function isNearRegistrationError(err) {
+  const m = err instanceof Error ? err.message : String(err);
+  return /not registered|storage_?deposit|The account .* is not registered/i.test(m);
+}
+function isNearAffordability(err) {
+  const m = err instanceof Error ? err.message : String(err);
+  return /not enough|doesn't have enough|does not have enough|lack ?balance|exceeds .*balance|insufficient/i.test(m);
+}
+
+// src/drivers/near/verify.ts
+function parseFtTransferEvent(line) {
+  const marker = "EVENT_JSON:";
+  const i = line.indexOf(marker);
+  if (i < 0) return null;
+  try {
+    const ev = JSON.parse(line.slice(i + marker.length));
+    if (ev.standard === "nep141" && ev.event === "ft_transfer" && Array.isArray(ev.data)) {
+      return ev.data;
+    }
+  } catch (e) {
+  }
+  return null;
+}
+async function verifyNear(params) {
+  const { reader, hash, senderId, accept } = params;
+  const required = BigInt(accept.amount);
+  const nonce = accept.extra.nonce;
+  let tx;
+  try {
+    tx = await reader.txStatus(hash, senderId);
+  } catch (e2) {
+    return txNotFound(hash);
+  }
+  if (!tx) return txNotFound(hash);
+  if (!tx.success) {
+    return { ok: false, error: "tx_reverted", detail: `NEAR tx ${hash} failed on-chain.` };
+  }
+  if (typeof tx.timestampMs === "number") {
+    const ageSeconds = Math.floor(Date.now() / 1e3) - Math.floor(tx.timestampMs / 1e3);
+    if (ageSeconds > accept.maxTimeoutSeconds) {
+      return {
+        ok: false,
+        error: "payment_expired",
+        detail: `Payment is ${ageSeconds}s old; max allowed is ${accept.maxTimeoutSeconds}s.`
+      };
+    }
+  }
+  let paid = 0n;
+  let payer = "";
+  for (const r of tx.receipts) {
+    if (r.executorId !== accept.asset) continue;
+    for (const line of r.logs) {
+      const data = parseFtTransferEvent(line);
+      if (!data) continue;
+      for (const d of data) {
+        if (d.new_owner_id === accept.payTo && (_nullishCoalesce(d.memo, () => ( ""))) === nonce) {
+          try {
+            paid += BigInt(_nullishCoalesce(d.amount, () => ( "0")));
+          } catch (e3) {
+          }
+          if (!payer) payer = _nullishCoalesce(d.old_owner_id, () => ( ""));
+        }
+      }
+    }
+  }
+  if (paid < required) {
+    return {
+      ok: false,
+      error: "transfer_not_found",
+      detail: `No NEP-141 ft_transfer of >= ${required} (token ${accept.asset}) to ${accept.payTo} carrying our nonce in ${hash}.`
+    };
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "onchain-proof",
+      success: true,
+      network: accept.network,
+      transaction: hash,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer,
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function txNotFound(hash) {
+  return {
+    ok: false,
+    error: "tx_not_found",
+    detail: `NEAR tx ${hash} not found or not yet executed \u2014 retry.`
+  };
+}
+
+// src/drivers/near/wallet.ts
+
+function assertNearWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is NEAR; wallet must be { accountId, privateKey } (privateKey = ed25519:\u2026).`
+    );
+  }
+  if ("walletClient" in wallet) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is NEAR; a viem { walletClient } can't be used \u2014 pass { accountId, privateKey }.`
+    );
+  }
+  if ("secretKey" in wallet || "signer" in wallet || "mnemonic" in wallet || "keyPair" in wallet || "secret" in wallet || "seed" in wallet || "keypair" in wallet) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is NEAR; that looks like another family's wallet \u2014 pass { accountId, privateKey }.`
+    );
+  }
+  if (!("accountId" in wallet) || !("privateKey" in wallet)) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is NEAR; wallet must be { accountId, privateKey } (privateKey = ed25519:\u2026).`
+    );
+  }
+  return wallet;
+}
+function resolveNearWallet(config) {
+  if (!config.accountId || !config.privateKey) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)("NEAR wallet needs { accountId, privateKey } (privateKey = ed25519:\u2026).");
+  }
+  let signer;
+  try {
+    signer = _nearapijs.KeyPairSigner.fromSecretKey(config.privateKey);
+  } catch (cause) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)("NEAR wallet { privateKey } is not a valid ed25519:\u2026 secret key.", {
+      cause
+    });
+  }
+  return { accountId: config.accountId, signer };
+}
+
+// src/drivers/near/index.ts
+var nearDriver = {
+  family: "near",
+  resolve(opts) {
+    if (opts.chain !== "near") return null;
+    const rpcUrl = _nullishCoalesce(opts.rpcUrl, () => ( NEAR_MAINNET.defaultRpc));
+    return makeNearNetwork(NEAR_MAINNET, rpcUrl);
+  }
+};
+function isValidNearAccountId(id) {
+  if (id.startsWith("0x")) return false;
+  if (id.length < 2 || id.length > 64) return false;
+  return /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/.test(id);
+}
+function makeNearNetwork(preset, rpcUrl) {
+  const provider = new (0, _nearapijs.JsonRpcProvider)({ url: rpcUrl });
+  const network = preset.caip2;
+  const reader = {
+    async txStatus(hash, senderId) {
+      const outcome = await provider.viewTransactionStatusWithReceipts({
+        txHash: hash,
+        accountId: senderId,
+        waitUntil: "EXECUTED_OPTIMISTIC"
+      });
+      if (!outcome) return null;
+      const status = outcome.status;
+      const success = typeof status === "object" && status !== null && "SuccessValue" in status;
+      const receipts = (_nullishCoalesce(outcome.receipts_outcome, () => ( []))).map((r) => ({
+        executorId: r.outcome.executor_id,
+        logs: _nullishCoalesce(r.outcome.logs, () => ( []))
+      }));
+      return { success, receipts };
+    }
+  };
+  return {
+    family: "near",
+    network,
+    supports: (n) => n === network,
+    resolveToken(token) {
+      if (token === "native") {
+        throw new (0, _chunkWQWNPAYQcjs.UnknownTokenError)(
+          `NEAR payments are NEP-141 token only \u2014 native NEAR isn't a built-in payment asset (a native transfer carries no memo to bind the payment). Use 'USDC' / 'USDT' or a custom { contractId, decimals }.`
+        );
+      }
+      if (typeof token === "string") {
+        const info = preset.tokens[token.toUpperCase()];
+        if (!info) {
+          const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
+          throw new (0, _chunkWQWNPAYQcjs.UnknownTokenError)(
+            `token "${token}" isn't built in for NEAR (known: ${known}). Pass { contractId, decimals } for a custom NEP-141.`
+          );
+        }
+        return { asset: info.contractId, decimals: info.decimals, symbol: info.symbol };
+      }
+      _chunkWQWNPAYQcjs.rejectForeignToken.call(void 0, token, "near", network);
+      const t = token;
+      if (!t.contractId || typeof t.decimals !== "number") {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is NEAR; a custom token must be { contractId, decimals }.`
+        );
+      }
+      return {
+        asset: t.contractId,
+        decimals: t.decimals,
+        ...t.symbol ? { symbol: t.symbol } : {}
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") return null;
+      for (const info of Object.values(preset.tokens)) {
+        if (info.contractId === asset) return { symbol: info.symbol, decimals: info.decimals };
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (payTo.startsWith("0x")) {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is NEAR, but payTo "${payTo}" looks like an EVM/Sui 0x address.`
+        );
+      }
+      if (!isValidNearAccountId(payTo)) {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is NEAR, but payTo "${payTo}" is not a valid NEAR account id.`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      return { _native: assertNearWallet(wallet, network) };
+    },
+    async send(wallet, accept) {
+      const { accountId, signer } = resolveNearWallet(wallet._native);
+      const account = new (0, _nearapijs.Account)(accountId, provider, signer);
+      const client = {
+        async ftTransfer({ contractId, receiverId, amount, memo, gas, deposit }) {
+          const outcome = await account.signAndSendTransaction({
+            receiverId: contractId,
+            actions: [
+              _nearapijs.actions.functionCall("ft_transfer", { receiver_id: receiverId, amount, memo }, gas, deposit)
+            ]
+          });
+          const hash2 = _optionalChain([outcome, 'access', _ => _.transaction, 'optionalAccess', _2 => _2.hash]);
+          if (!hash2) throw new Error("NEAR: signAndSendTransaction returned no tx hash.");
+          return { hash: hash2 };
+        }
+      };
+      const hash = await payNear({ client, accept });
+      return encodeRef(accountId, hash);
+    },
+    async confirm(ref) {
+      const { senderId, hash } = decodeRef(ref);
+      try {
+        const tx = await reader.txStatus(hash, senderId);
+        if (tx && tx.success) return { height: "0" };
+      } catch (e4) {
+      }
+      throw new (0, _chunkWQWNPAYQcjs.ConfirmationTimeoutError)(`NEAR tx ${hash} not confirmed in time.`);
+    },
+    async estimateCost() {
+      return _chunkWQWNPAYQcjs.nativeCost.call(void 0, {
+        symbol: "NEAR",
+        decimals: NEAR_DECIMALS,
+        fee: 1500000000000000000000n,
+        basis: "heuristic",
+        detail: "~14 TGas for ft_transfer (\u22480.0015 NEAR) + 1 yoctoNEAR deposit"
+      });
+    },
+    async verify(ref, accept) {
+      const { senderId, hash } = decodeRef(ref);
+      return verifyNear({ reader, hash, senderId, accept });
+    }
+  };
+}
+function encodeRef(accountId, hash) {
+  return `${accountId}:${hash}`;
+}
+function decodeRef(ref) {
+  const i = ref.indexOf(":");
+  if (i < 0) return { senderId: "", hash: ref };
+  return { senderId: ref.slice(0, i), hash: ref.slice(i + 1) };
+}
+
+
+exports.nearDriver = nearDriver;

package/dist/near-RVXGF7TW.js

@@ -0,0 +1,346 @@
+import {
+  ConfirmationTimeoutError,
+  InsufficientFundsError,
+  UnknownTokenError,
+  WrongFamilyError,
+  nativeCost,
+  rejectForeignToken,
+  toInsufficientFundsError
+} from "./chunk-3TQJJ4SQ.js";
+
+// src/drivers/near/index.ts
+import { JsonRpcProvider, Account, actions } from "near-api-js";
+
+// src/drivers/near/chains.ts
+var NEAR_DECIMALS = 24;
+var NEAR_MAINNET = {
+  caip2: "near:mainnet",
+  defaultRpc: "https://free.rpc.fastnear.com",
+  tokens: {
+    // Circle USDC — native (NOT the .factory.bridge.near bridge). Contract + 6dp
+    // verified live via ft_metadata before shipping.
+    USDC: {
+      contractId: "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+      decimals: 6,
+      symbol: "USDC"
+    },
+    // Tether USDt — native (Tether's official tether-token.near account). On-chain
+    // symbol is "USDt"; contract + 6dp verified live via ft_metadata before shipping.
+    USDT: {
+      contractId: "usdt.tether-token.near",
+      decimals: 6,
+      symbol: "USDT"
+    }
+  }
+};
+
+// src/drivers/near/pay.ts
+var FT_TRANSFER_GAS = 30000000000000n;
+var ONE_YOCTO = 1n;
+async function payNear(params) {
+  const { client, accept, gas } = params;
+  try {
+    const res = await client.ftTransfer({
+      contractId: accept.asset,
+      receiverId: accept.payTo,
+      amount: accept.amount,
+      memo: accept.extra.nonce,
+      // nonce binding (Template A)
+      gas: gas ?? FT_TRANSFER_GAS,
+      deposit: ONE_YOCTO
+    });
+    return res.hash;
+  } catch (err) {
+    if (isNearRegistrationError(err)) {
+      throw new Error(
+        `NEAR ft_transfer failed: recipient ${accept.payTo} isn't registered on token ${accept.asset} (NEP-145 storage_deposit). Register it once (\u22480.00125 NEAR) before it can receive.`,
+        { cause: err }
+      );
+    }
+    if (isNearAffordability(err)) {
+      throw new InsufficientFundsError(
+        err instanceof Error ? err.message : "Insufficient NEAR balance for the payment.",
+        { cause: err }
+      );
+    }
+    throw toInsufficientFundsError(err) ?? err;
+  }
+}
+function isNearRegistrationError(err) {
+  const m = err instanceof Error ? err.message : String(err);
+  return /not registered|storage_?deposit|The account .* is not registered/i.test(m);
+}
+function isNearAffordability(err) {
+  const m = err instanceof Error ? err.message : String(err);
+  return /not enough|doesn't have enough|does not have enough|lack ?balance|exceeds .*balance|insufficient/i.test(m);
+}
+
+// src/drivers/near/verify.ts
+function parseFtTransferEvent(line) {
+  const marker = "EVENT_JSON:";
+  const i = line.indexOf(marker);
+  if (i < 0) return null;
+  try {
+    const ev = JSON.parse(line.slice(i + marker.length));
+    if (ev.standard === "nep141" && ev.event === "ft_transfer" && Array.isArray(ev.data)) {
+      return ev.data;
+    }
+  } catch {
+  }
+  return null;
+}
+async function verifyNear(params) {
+  const { reader, hash, senderId, accept } = params;
+  const required = BigInt(accept.amount);
+  const nonce = accept.extra.nonce;
+  let tx;
+  try {
+    tx = await reader.txStatus(hash, senderId);
+  } catch {
+    return txNotFound(hash);
+  }
+  if (!tx) return txNotFound(hash);
+  if (!tx.success) {
+    return { ok: false, error: "tx_reverted", detail: `NEAR tx ${hash} failed on-chain.` };
+  }
+  if (typeof tx.timestampMs === "number") {
+    const ageSeconds = Math.floor(Date.now() / 1e3) - Math.floor(tx.timestampMs / 1e3);
+    if (ageSeconds > accept.maxTimeoutSeconds) {
+      return {
+        ok: false,
+        error: "payment_expired",
+        detail: `Payment is ${ageSeconds}s old; max allowed is ${accept.maxTimeoutSeconds}s.`
+      };
+    }
+  }
+  let paid = 0n;
+  let payer = "";
+  for (const r of tx.receipts) {
+    if (r.executorId !== accept.asset) continue;
+    for (const line of r.logs) {
+      const data = parseFtTransferEvent(line);
+      if (!data) continue;
+      for (const d of data) {
+        if (d.new_owner_id === accept.payTo && (d.memo ?? "") === nonce) {
+          try {
+            paid += BigInt(d.amount ?? "0");
+          } catch {
+          }
+          if (!payer) payer = d.old_owner_id ?? "";
+        }
+      }
+    }
+  }
+  if (paid < required) {
+    return {
+      ok: false,
+      error: "transfer_not_found",
+      detail: `No NEP-141 ft_transfer of >= ${required} (token ${accept.asset}) to ${accept.payTo} carrying our nonce in ${hash}.`
+    };
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "onchain-proof",
+      success: true,
+      network: accept.network,
+      transaction: hash,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer,
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function txNotFound(hash) {
+  return {
+    ok: false,
+    error: "tx_not_found",
+    detail: `NEAR tx ${hash} not found or not yet executed \u2014 retry.`
+  };
+}
+
+// src/drivers/near/wallet.ts
+import { KeyPairSigner } from "near-api-js";
+function assertNearWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new WrongFamilyError(
+      `chain ${network} is NEAR; wallet must be { accountId, privateKey } (privateKey = ed25519:\u2026).`
+    );
+  }
+  if ("walletClient" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is NEAR; a viem { walletClient } can't be used \u2014 pass { accountId, privateKey }.`
+    );
+  }
+  if ("secretKey" in wallet || "signer" in wallet || "mnemonic" in wallet || "keyPair" in wallet || "secret" in wallet || "seed" in wallet || "keypair" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is NEAR; that looks like another family's wallet \u2014 pass { accountId, privateKey }.`
+    );
+  }
+  if (!("accountId" in wallet) || !("privateKey" in wallet)) {
+    throw new WrongFamilyError(
+      `chain ${network} is NEAR; wallet must be { accountId, privateKey } (privateKey = ed25519:\u2026).`
+    );
+  }
+  return wallet;
+}
+function resolveNearWallet(config) {
+  if (!config.accountId || !config.privateKey) {
+    throw new WrongFamilyError("NEAR wallet needs { accountId, privateKey } (privateKey = ed25519:\u2026).");
+  }
+  let signer;
+  try {
+    signer = KeyPairSigner.fromSecretKey(config.privateKey);
+  } catch (cause) {
+    throw new WrongFamilyError("NEAR wallet { privateKey } is not a valid ed25519:\u2026 secret key.", {
+      cause
+    });
+  }
+  return { accountId: config.accountId, signer };
+}
+
+// src/drivers/near/index.ts
+var nearDriver = {
+  family: "near",
+  resolve(opts) {
+    if (opts.chain !== "near") return null;
+    const rpcUrl = opts.rpcUrl ?? NEAR_MAINNET.defaultRpc;
+    return makeNearNetwork(NEAR_MAINNET, rpcUrl);
+  }
+};
+function isValidNearAccountId(id) {
+  if (id.startsWith("0x")) return false;
+  if (id.length < 2 || id.length > 64) return false;
+  return /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/.test(id);
+}
+function makeNearNetwork(preset, rpcUrl) {
+  const provider = new JsonRpcProvider({ url: rpcUrl });
+  const network = preset.caip2;
+  const reader = {
+    async txStatus(hash, senderId) {
+      const outcome = await provider.viewTransactionStatusWithReceipts({
+        txHash: hash,
+        accountId: senderId,
+        waitUntil: "EXECUTED_OPTIMISTIC"
+      });
+      if (!outcome) return null;
+      const status = outcome.status;
+      const success = typeof status === "object" && status !== null && "SuccessValue" in status;
+      const receipts = (outcome.receipts_outcome ?? []).map((r) => ({
+        executorId: r.outcome.executor_id,
+        logs: r.outcome.logs ?? []
+      }));
+      return { success, receipts };
+    }
+  };
+  return {
+    family: "near",
+    network,
+    supports: (n) => n === network,
+    resolveToken(token) {
+      if (token === "native") {
+        throw new UnknownTokenError(
+          `NEAR payments are NEP-141 token only \u2014 native NEAR isn't a built-in payment asset (a native transfer carries no memo to bind the payment). Use 'USDC' / 'USDT' or a custom { contractId, decimals }.`
+        );
+      }
+      if (typeof token === "string") {
+        const info = preset.tokens[token.toUpperCase()];
+        if (!info) {
+          const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
+          throw new UnknownTokenError(
+            `token "${token}" isn't built in for NEAR (known: ${known}). Pass { contractId, decimals } for a custom NEP-141.`
+          );
+        }
+        return { asset: info.contractId, decimals: info.decimals, symbol: info.symbol };
+      }
+      rejectForeignToken(token, "near", network);
+      const t = token;
+      if (!t.contractId || typeof t.decimals !== "number") {
+        throw new WrongFamilyError(
+          `chain ${network} is NEAR; a custom token must be { contractId, decimals }.`
+        );
+      }
+      return {
+        asset: t.contractId,
+        decimals: t.decimals,
+        ...t.symbol ? { symbol: t.symbol } : {}
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") return null;
+      for (const info of Object.values(preset.tokens)) {
+        if (info.contractId === asset) return { symbol: info.symbol, decimals: info.decimals };
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (payTo.startsWith("0x")) {
+        throw new WrongFamilyError(
+          `chain ${network} is NEAR, but payTo "${payTo}" looks like an EVM/Sui 0x address.`
+        );
+      }
+      if (!isValidNearAccountId(payTo)) {
+        throw new WrongFamilyError(
+          `chain ${network} is NEAR, but payTo "${payTo}" is not a valid NEAR account id.`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      return { _native: assertNearWallet(wallet, network) };
+    },
+    async send(wallet, accept) {
+      const { accountId, signer } = resolveNearWallet(wallet._native);
+      const account = new Account(accountId, provider, signer);
+      const client = {
+        async ftTransfer({ contractId, receiverId, amount, memo, gas, deposit }) {
+          const outcome = await account.signAndSendTransaction({
+            receiverId: contractId,
+            actions: [
+              actions.functionCall("ft_transfer", { receiver_id: receiverId, amount, memo }, gas, deposit)
+            ]
+          });
+          const hash2 = outcome.transaction?.hash;
+          if (!hash2) throw new Error("NEAR: signAndSendTransaction returned no tx hash.");
+          return { hash: hash2 };
+        }
+      };
+      const hash = await payNear({ client, accept });
+      return encodeRef(accountId, hash);
+    },
+    async confirm(ref) {
+      const { senderId, hash } = decodeRef(ref);
+      try {
+        const tx = await reader.txStatus(hash, senderId);
+        if (tx && tx.success) return { height: "0" };
+      } catch {
+      }
+      throw new ConfirmationTimeoutError(`NEAR tx ${hash} not confirmed in time.`);
+    },
+    async estimateCost() {
+      return nativeCost({
+        symbol: "NEAR",
+        decimals: NEAR_DECIMALS,
+        fee: 1500000000000000000000n,
+        basis: "heuristic",
+        detail: "~14 TGas for ft_transfer (\u22480.0015 NEAR) + 1 yoctoNEAR deposit"
+      });
+    },
+    async verify(ref, accept) {
+      const { senderId, hash } = decodeRef(ref);
+      return verifyNear({ reader, hash, senderId, accept });
+    }
+  };
+}
+function encodeRef(accountId, hash) {
+  return `${accountId}:${hash}`;
+}
+function decodeRef(ref) {
+  const i = ref.indexOf(":");
+  if (i < 0) return { senderId: "", hash: ref };
+  return { senderId: ref.slice(0, i), hash: ref.slice(i + 1) };
+}
+export {
+  nearDriver
+};