@piprail/sdk 2.4.0 → 2.6.0

package/dist/{near-DI2I3MAV.cjs → near-H5AQ253I.cjs}

@@ -8,6 +8,8 @@
 
 
 
+
+
 var _chunkJG6KRAW6cjs = require('./chunk-JG6KRAW6.cjs');
 
 // src/drivers/near/index.ts
@@ -15,6 +17,11 @@ var _nearapijs = require('near-api-js');
 
 // src/drivers/near/chains.ts
 var NEAR_DECIMALS = 24;
+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);
+}
 var NEAR_MAINNET = {
   caip2: "near:mainnet",
   defaultRpc: "https://free.rpc.fastnear.com",
@@ -92,6 +99,190 @@ function isNearAffordability(err) {
   return /not enough|doesn't have enough|does not have enough|lack ?balance|exceeds .*balance|insufficient/i.test(m);
 }
 
+// src/drivers/near/exact.ts
+
+var _borsh = require('borsh');
+var FT_TRANSFER_GAS2 = 30000000000000n;
+var ONE_YOCTO2 = 1n;
+var ESTIMATED_BLOCK_SECONDS = 1;
+var NONCE_BLOCK_MULTIPLIER = 1000000n;
+async function payExactNear(input) {
+  const { signer, senderId, blockHeight, accessKeyNonce, accept } = input;
+  if (accept.asset === "native") {
+    throw new (0, _chunkJG6KRAW6cjs.UnsupportedSchemeError)(
+      "NEAR exact is NEP-141-only (an ft_transfer); native NEAR is not exact-payable. Pay via onchain-proof."
+    );
+  }
+  if (!isValidNearAccountId(accept.asset)) {
+    throw new (0, _chunkJG6KRAW6cjs.UnsupportedSchemeError)(`NEAR exact: asset "${accept.asset}" must be a NEP-141 contract account id.`);
+  }
+  if (!isValidNearAccountId(accept.payTo)) {
+    throw new (0, _chunkJG6KRAW6cjs.UnsupportedSchemeError)(`NEAR exact: payTo "${accept.payTo}" is not a valid NEAR account id.`);
+  }
+  if (!isValidNearAccountId(senderId)) {
+    throw new (0, _chunkJG6KRAW6cjs.UnsupportedSchemeError)(`NEAR exact: sender "${senderId}" is not a valid NEAR account id.`);
+  }
+  const t = accept.maxTimeoutSeconds;
+  if (!Number.isInteger(t) || t <= 0) {
+    throw new (0, _chunkJG6KRAW6cjs.UnsupportedSchemeError)("NEAR exact: maxTimeoutSeconds must be a positive integer.");
+  }
+  const timeoutBlocks = BigInt(Math.max(1, Math.ceil(t / ESTIMATED_BLOCK_SECONDS)));
+  const maxBlockHeight = blockHeight + timeoutBlocks;
+  const nonce = accessKeyNonce + 1n;
+  if (nonce >= blockHeight * NONCE_BLOCK_MULTIPLIER) {
+    throw new (0, _chunkJG6KRAW6cjs.UnsupportedSchemeError)(
+      "NEAR exact: the access-key nonce is at the protocol ceiling for this block height; cannot build a delegate action."
+    );
+  }
+  const publicKey = await signer.getPublicKey();
+  const action = _nearapijs.actions.functionCall(
+    "ft_transfer",
+    { receiver_id: accept.payTo, amount: accept.amount },
+    FT_TRANSFER_GAS2,
+    ONE_YOCTO2
+  );
+  const delegateAction = _nearapijs.buildDelegateAction.call(void 0, {
+    senderId,
+    receiverId: accept.asset,
+    actions: [action],
+    nonce,
+    maxBlockHeight,
+    publicKey
+  });
+  const { signedDelegate } = await signer.signDelegateAction(delegateAction);
+  const encoded = _nearapijs.encodeSignedDelegate.call(void 0, signedDelegate);
+  return {
+    payload: { signedDelegateAction: Buffer.from(encoded).toString("base64") },
+    payerFrom: senderId,
+    // A stable id for THIS authorization (single-use on-chain via the access-key nonce): the
+    // client records it as the spend ref and re-presents the SAME signed action on a retry.
+    nonce: `${senderId}:${nonce.toString()}`
+  };
+}
+var MAX_RELAY_GAS = 300000000000000n;
+var b64decode = (s) => new Uint8Array(Buffer.from(s, "base64"));
+function shorten(msg) {
+  const oneLine = msg.replace(/\s+/g, " ").trim();
+  return oneLine.length > 200 ? `${oneLine.slice(0, 200)}\u2026` : oneLine;
+}
+function fail(error, detail) {
+  return { ok: false, error, detail };
+}
+function verifyExactNear(payload, accept, currentBlockHeight) {
+  if (accept.asset === "native" || !isValidNearAccountId(accept.asset)) {
+    return fail("transfer_not_found", `NEAR exact rail asset "${accept.asset}" is not a NEP-141 contract.`);
+  }
+  if (typeof _optionalChain([payload, 'optionalAccess', _ => _.signedDelegateAction]) !== "string") {
+    return fail("signature_invalid", "NEAR exact payload is missing signedDelegateAction.");
+  }
+  let decoded;
+  try {
+    decoded = _borsh.deserialize.call(void 0, _nearapijs.SCHEMA.SignedDelegate, b64decode(payload.signedDelegateAction));
+  } catch (err) {
+    return fail("signature_invalid", `Unparseable SignedDelegateAction: ${shorten(err instanceof Error ? err.message : String(err))}.`);
+  }
+  const da = _optionalChain([decoded, 'optionalAccess', _2 => _2.delegateAction]);
+  const sig = _optionalChain([decoded, 'optionalAccess', _3 => _3.signature]);
+  if (!da || sig == null) return fail("signature_invalid", "SignedDelegateAction is missing its delegate action or signature.");
+  if (!Array.isArray(da.actions) || da.actions.length !== 1) {
+    return fail("transfer_not_found", `the delegate must carry exactly one action, got ${_nullishCoalesce(_optionalChain([da, 'access', _4 => _4.actions, 'optionalAccess', _5 => _5.length]), () => ( 0))}.`);
+  }
+  const fc = _optionalChain([da, 'access', _6 => _6.actions, 'access', _7 => _7[0], 'optionalAccess', _8 => _8.functionCall]);
+  if (!fc || fc.methodName !== "ft_transfer") {
+    return fail("transfer_not_found", `the delegated action is not an ft_transfer (got "${_nullishCoalesce(_optionalChain([fc, 'optionalAccess', _9 => _9.methodName]), () => ( "none"))}").`);
+  }
+  if (da.receiverId !== accept.asset) {
+    return fail("transfer_not_found", `delegate receiver ${da.receiverId} \u2260 token contract ${accept.asset}.`);
+  }
+  let args;
+  try {
+    args = JSON.parse(Buffer.from(_nullishCoalesce(fc.args, () => ( new Uint8Array()))).toString());
+  } catch (e2) {
+    return fail("transfer_not_found", "the ft_transfer args are not valid JSON.");
+  }
+  if (args.receiver_id !== accept.payTo) {
+    return fail("wrong_recipient", `ft_transfer pays ${String(args.receiver_id)}, not payTo ${accept.payTo}.`);
+  }
+  if (typeof args.amount !== "string" || !/^\d+$/.test(args.amount) || BigInt(args.amount) < BigInt(accept.amount)) {
+    return fail("amount_too_low", `ft_transfer pays ${String(args.amount)} of the token, required ${accept.amount}.`);
+  }
+  let deposit;
+  let gas;
+  try {
+    deposit = BigInt(_nullishCoalesce(fc.deposit, () => ( 0)));
+    gas = BigInt(_nullishCoalesce(fc.gas, () => ( 0)));
+  } catch (e3) {
+    return fail("signature_invalid", "the ft_transfer has a malformed gas/deposit.");
+  }
+  if (deposit !== ONE_YOCTO2) {
+    return fail("signature_invalid", `attached deposit ${deposit} \u2260 the required 1 yoctoNEAR (relayer drain guard).`);
+  }
+  if (gas > MAX_RELAY_GAS) {
+    return fail("signature_invalid", `delegated gas ${gas} exceeds the ${MAX_RELAY_GAS} cap (relayer drain guard).`);
+  }
+  if (currentBlockHeight !== null) {
+    let maxBlock;
+    try {
+      maxBlock = BigInt(_nullishCoalesce(da.maxBlockHeight, () => ( 0)));
+    } catch (e4) {
+      return fail("signature_invalid", "the delegate has a malformed max_block_height.");
+    }
+    if (maxBlock <= currentBlockHeight) {
+      return fail("payment_expired", `the delegate expired (max_block_height ${maxBlock} \u2264 current ${currentBlockHeight}).`);
+    }
+  }
+  if (!da.senderId || !isValidNearAccountId(String(da.senderId))) {
+    return fail("signature_invalid", `the delegate sender "${String(da.senderId)}" is not a valid NEAR account id.`);
+  }
+  return { ok: true, senderId: String(da.senderId), delegateAction: new (0, _nearapijs.DelegateAction)(da), signature: sig };
+}
+async function verifyAndSettleExactNear(input) {
+  const { client, payload, accept } = input;
+  let height = null;
+  try {
+    height = await client.currentBlockHeight();
+  } catch (e5) {
+  }
+  const v = verifyExactNear(payload, accept, height);
+  if (!v.ok) return v;
+  let result;
+  try {
+    result = await client.relay({ senderId: v.senderId, delegateAction: v.delegateAction, signature: v.signature });
+  } catch (err) {
+    const m = err instanceof Error ? err.message : String(err);
+    if (/invalid.*nonce|nonce.*used|DelegateActionInvalidNonce/i.test(m)) {
+      return fail("tx_already_used", `this delegate was already used (single-use nonce): ${shorten(m)}.`);
+    }
+    if (/expired|DelegateActionExpired|max_block_height|deadline/i.test(m)) {
+      return fail("payment_expired", `the delegate expired before it landed: ${shorten(m)}.`);
+    }
+    if (/not enough|insufficient|exceeded the prepaid gas|NotEnoughBalance|doesn't have enough|is not registered/i.test(m)) {
+      return fail("tx_reverted", `the ft_transfer would fail on chain: ${shorten(m)}.`);
+    }
+    throw new (0, _chunkJG6KRAW6cjs.SettlementError)(
+      `NEAR exact settle: the relayer could not submit the delegate (${shorten(m)}). The buyer's signed delegate is still valid \u2014 fund/fix the relayer and the buyer can re-present it.`,
+      { cause: err }
+    );
+  }
+  if (!result.innerSuccess) {
+    return fail("tx_reverted", `the ft_transfer receipt did not succeed on chain (tx ${result.txHash}).`);
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "exact",
+      success: true,
+      network: accept.network,
+      transaction: result.txHash,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer: v.senderId,
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+
 // src/drivers/near/verify.ts
 function parseFtTransferEvent(line) {
   const marker = "EVENT_JSON:";
@@ -102,7 +293,7 @@ function parseFtTransferEvent(line) {
     if (ev.standard === "nep141" && ev.event === "ft_transfer" && Array.isArray(ev.data)) {
       return ev.data;
     }
-  } catch (e2) {
+  } catch (e6) {
   }
   return null;
 }
@@ -113,7 +304,7 @@ async function verifyNear(params) {
   let tx;
   try {
     tx = await reader.txStatus(hash, senderId);
-  } catch (e3) {
+  } catch (e7) {
     return txNotFound(hash);
   }
   if (!tx) return txNotFound(hash);
@@ -134,7 +325,7 @@ async function verifyNear(params) {
     let paid2;
     try {
       paid2 = BigInt(_nullishCoalesce(tx.nativeDeposit, () => ( "0")));
-    } catch (e4) {
+    } catch (e8) {
       paid2 = 0n;
     }
     if (paid2 < required) {
@@ -176,7 +367,7 @@ async function verifyNear(params) {
         if (d.new_owner_id === accept.payTo && (_nullishCoalesce(d.memo, () => ( ""))) === nonce) {
           try {
             paid += BigInt(_nullishCoalesce(d.amount, () => ( "0")));
-          } catch (e5) {
+          } catch (e9) {
           }
           if (!payer) payer = _nullishCoalesce(d.old_owner_id, () => ( ""));
         }
@@ -253,11 +444,6 @@ var nearDriver = {
     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;
@@ -276,18 +462,18 @@ function makeNearNetwork(preset, rpcUrl) {
         logs: _nullishCoalesce(r.outcome.logs, () => ( []))
       }));
       const txn = outcome.transaction;
-      const receiverId = _optionalChain([txn, 'optionalAccess', _ => _.receiver_id]);
-      const nativeDeposit = sumTransferDeposits(_optionalChain([txn, 'optionalAccess', _2 => _2.actions])).toString();
+      const receiverId = _optionalChain([txn, 'optionalAccess', _10 => _10.receiver_id]);
+      const nativeDeposit = sumTransferDeposits(_optionalChain([txn, 'optionalAccess', _11 => _11.actions])).toString();
       let timestampMs;
       try {
-        const blockHash = _optionalChain([outcome, 'access', _3 => _3.transaction_outcome, 'optionalAccess', _4 => _4.block_hash]);
+        const blockHash = _optionalChain([outcome, 'access', _12 => _12.transaction_outcome, 'optionalAccess', _13 => _13.block_hash]);
         if (blockHash) {
           const block = await provider.viewBlock({ blockId: blockHash });
           const header = block.header;
-          const ns = _nullishCoalesce(_optionalChain([header, 'optionalAccess', _5 => _5.timestamp_nanosec]), () => ( (_optionalChain([header, 'optionalAccess', _6 => _6.timestamp]) != null ? String(header.timestamp) : void 0)));
+          const ns = _nullishCoalesce(_optionalChain([header, 'optionalAccess', _14 => _14.timestamp_nanosec]), () => ( (_optionalChain([header, 'optionalAccess', _15 => _15.timestamp]) != null ? String(header.timestamp) : void 0)));
           if (ns != null) timestampMs = Number(BigInt(ns) / 1000000n);
         }
-      } catch (e6) {
+      } catch (e10) {
       }
       return { success, receipts, receiverId, nativeDeposit, timestampMs };
     }
@@ -349,7 +535,7 @@ function makeNearNetwork(preset, rpcUrl) {
       const { accountId, signer } = resolveNearWallet(wallet._native);
       const account = new (0, _nearapijs.Account)(accountId, provider, signer);
       const hashOf = (outcome) => {
-        const hash2 = _optionalChain([outcome, 'access', _7 => _7.transaction, 'optionalAccess', _8 => _8.hash]);
+        const hash2 = _optionalChain([outcome, 'access', _16 => _16.transaction, 'optionalAccess', _17 => _17.hash]);
         if (!hash2) throw new Error("NEAR: signAndSendTransaction returned no tx hash.");
         return hash2;
       };
@@ -379,7 +565,7 @@ function makeNearNetwork(preset, rpcUrl) {
       try {
         const tx = await reader.txStatus(hash, senderId);
         if (tx && tx.success) return { height: "0" };
-      } catch (e7) {
+      } catch (e11) {
       }
       throw new (0, _chunkJG6KRAW6cjs.ConfirmationTimeoutError)(`NEAR tx ${hash} not confirmed in time.`);
     },
@@ -396,7 +582,7 @@ function makeNearNetwork(preset, rpcUrl) {
       let accountId;
       try {
         accountId = resolveNearWallet(wallet._native).accountId;
-      } catch (e8) {
+      } catch (e12) {
         return { token: null, native: null };
       }
       let native = null;
@@ -408,7 +594,7 @@ function makeNearNetwork(preset, rpcUrl) {
         });
         native = r.amount != null ? BigInt(r.amount) : null;
       } catch (e) {
-        native = /does not exist|UNKNOWN_ACCOUNT/i.test(String(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _9 => _9.message]), () => ( e)))) ? 0n : null;
+        native = /does not exist|UNKNOWN_ACCOUNT/i.test(String(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _18 => _18.message]), () => ( e)))) ? 0n : null;
       }
       if (asset === "native") return { token: native, native };
       let token = null;
@@ -422,7 +608,7 @@ function makeNearNetwork(preset, rpcUrl) {
         });
         token = r.result ? BigInt(JSON.parse(Buffer.from(r.result).toString())) : null;
       } catch (e) {
-        token = /does not exist|not registered|UNKNOWN_ACCOUNT/i.test(String(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _10 => _10.message]), () => ( e)))) ? 0n : null;
+        token = /does not exist|not registered|UNKNOWN_ACCOUNT/i.test(String(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _19 => _19.message]), () => ( e)))) ? 0n : null;
       }
       return { token, native };
     },
@@ -438,13 +624,103 @@ function makeNearNetwork(preset, rpcUrl) {
         });
         const parsed = r.result ? JSON.parse(Buffer.from(r.result).toString()) : null;
         return parsed == null ? { ready: false, reason: "NOT_REGISTERED" } : { ready: true };
-      } catch (e9) {
+      } catch (e13) {
         return { ready: "unknown" };
       }
     },
     async verify(ref, accept) {
       const { senderId, hash } = decodeRef(ref);
       return verifyNear({ reader, hash, senderId, accept });
+    },
+    // Standard x402 `exact` rail, BUYER side — build a NEP-366 SignedDelegateAction authorizing one
+    // NEP-141 ft_transfer (per scheme_exact_near.md). The buyer signs with its FULL-ACCESS key and
+    // spends ZERO NEAR; a keyless facilitator's relayer prepays the gas + 1 yoctoNEAR and submits.
+    // NEAR exact is NEP-141-only + facilitator-settled (see ./exact.ts for why) — native NEAR isn't
+    // exact-payable. Pre-reads the access-key nonce + final block height, then defers to payExactNear.
+    async payExact(wallet, accept) {
+      const { accountId, signer } = resolveNearWallet(wallet._native);
+      const publicKey = await signer.getPublicKey();
+      const [accessKey, block] = await Promise.all([
+        provider.query({
+          request_type: "view_access_key",
+          finality: "final",
+          account_id: accountId,
+          public_key: publicKey.toString()
+        }),
+        provider.viewBlock({ finality: "final" })
+      ]);
+      const accessKeyNonce = BigInt(_nullishCoalesce(accessKey.nonce, () => ( 0)));
+      const blockHeight = BigInt(_nullishCoalesce(_optionalChain([block, 'access', _20 => _20.header, 'optionalAccess', _21 => _21.height]), () => ( 0)));
+      const { payload, payerFrom, nonce } = await payExactNear({
+        signer,
+        senderId: accountId,
+        blockHeight,
+        accessKeyNonce,
+        accept
+      });
+      return { payload, accepted: accept, payerFrom, nonce };
+    },
+    // The gate's rail-advertisement SPI. NEAR exact is NEP-141-only. The fee payer (the relayer that
+    // prepays gas + the 1 yocto, so the BUYER pays nothing) comes from EITHER the merchant's own bound
+    // `relayer` (SELF mode — what works today) OR a facilitator-provided `feePayer` (facilitator mode —
+    // for when a NEAR x402 facilitator ships; none does yet). `null` for native / non-NEP-141 / when no
+    // fee payer is available. The buyer's SignedDelegateAction is self-contained, so `feePayer` rides in
+    // `extra` only for observability + (future) facilitator forwarding.
+    async resolveExactRail({ asset, relayer, feePayer }) {
+      if (asset === "native" || !isValidNearAccountId(asset)) return null;
+      let fp = feePayer;
+      if (!fp && relayer) {
+        try {
+          fp = resolveNearWallet(relayer._native).accountId;
+        } catch (e14) {
+          return null;
+        }
+      }
+      if (!fp) return null;
+      return { method: "near", extra: { feePayer: fp } };
+    },
+    // Standard x402 `exact` rail, SELLER side (SELF-SETTLE) — decode + verify the inbound delegate
+    // against the trusted accept, then RELAY it from the merchant's own NEAR relayer (which prepays the
+    // sub-cent gas + the 1 yocto). The buyer stays gasless. THIS is how a NEAR gate gets paid today
+    // (no third-party facilitator settles NEAR yet). The drain guard (gas/deposit caps) lives in
+    // verifyAndSettleExactNear, invisible to the gate.
+    async settleExactSelf({ relayer, payload, accept }) {
+      if (!("signedDelegateAction" in payload)) {
+        return { ok: false, error: "signature_invalid", detail: "NEAR exact expects a { signedDelegateAction } payload." };
+      }
+      let relayerWallet;
+      try {
+        relayerWallet = resolveNearWallet(relayer._native);
+      } catch (err) {
+        throw new (0, _chunkJG6KRAW6cjs.SettlementError)(
+          `NEAR exact settle: the relayer wallet is invalid (${err instanceof Error ? err.message : String(err)}).`,
+          { cause: err }
+        );
+      }
+      const relayerAccount = new (0, _nearapijs.Account)(relayerWallet.accountId, provider, relayerWallet.signer);
+      const isSuccess = (s) => typeof s === "object" && s !== null && "SuccessValue" in s;
+      const client = {
+        async currentBlockHeight() {
+          try {
+            const b = await provider.viewBlock({ finality: "final" });
+            return _optionalChain([b, 'access', _22 => _22.header, 'optionalAccess', _23 => _23.height]) != null ? BigInt(b.header.height) : null;
+          } catch (e15) {
+            return null;
+          }
+        },
+        async relay({ senderId, delegateAction, signature }) {
+          const outcome = await relayerAccount.signAndSendTransaction({
+            receiverId: senderId,
+            actions: [_nearapijs.actions.signedDelegate({ delegateAction, signature })],
+            waitUntil: "FINAL"
+          });
+          const txHash = _nullishCoalesce(_optionalChain([outcome, 'access', _24 => _24.transaction, 'optionalAccess', _25 => _25.hash]), () => ( ""));
+          const tokenReceipt = (_nullishCoalesce(outcome.receipts_outcome, () => ( []))).find((r) => _optionalChain([r, 'access', _26 => _26.outcome, 'optionalAccess', _27 => _27.executor_id]) === accept.asset);
+          const innerSuccess = tokenReceipt ? isSuccess(_optionalChain([tokenReceipt, 'access', _28 => _28.outcome, 'optionalAccess', _29 => _29.status])) : isSuccess(outcome.status);
+          return { txHash, innerSuccess };
+        }
+      };
+      return verifyAndSettleExactNear({ client, payload, accept });
     }
   };
 }
@@ -456,15 +732,15 @@ function decodeRef(ref) {
   if (i < 0) return { senderId: "", hash: ref };
   return { senderId: ref.slice(0, i), hash: ref.slice(i + 1) };
 }
-function sumTransferDeposits(actions2) {
-  if (!Array.isArray(actions2)) return 0n;
+function sumTransferDeposits(actions3) {
+  if (!Array.isArray(actions3)) return 0n;
   let sum = 0n;
-  for (const a of actions2) {
+  for (const a of actions3) {
     const t = _nullishCoalesce(a.Transfer, () => ( a.transfer));
     if (t && t.deposit != null) {
       try {
         sum += BigInt(t.deposit);
-      } catch (e10) {
+      } catch (e16) {
       }
     }
   }