@bitpal/checkout 0.10.0 → 0.12.0

package/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to `@bitpal/checkout`. Versions follow [semver](https://semver.org/) (pre-1.0: a minor bump may contain breaking changes, called out below).
+
+Source of truth: the BitPal monorepo (`packages/checkout-sdk`). The public repo `superlabs-x/bitpal-checkout-sdk` mirrors it.
+
+## 0.12.0 — 2026-11-06
+
+Merges the x402 line (0.8.0–0.11.0, previously released from the standalone repo) with the checkout API alignment fixes made in the monorepo.
+
+### Breaking (types)
+- `CreatePriceParams.currency` removed. The API always rejected it — a Price's currency is derived from `token_symbol` (`'USDC' | 'USDT' | 'JPYC'`, default `'USDC'`). Code that passed `currency` got a `400`; pass `token_symbol` instead.
+
+### Added
+- `PublicSession.pay_amount` — the exact amount the buyer must send, in the pay token's atomic units (`token_decimals`).
+- `BitPalError` now carries structured fields parsed from the API error body: `code`, `apiMessage`, `retryable`, `traceId`. `error.message` is unchanged from 0.11 (it is still the body's `error` value), so existing `catch` code keeps working. Also exported: `parseApiErrorBody`, `BitPalErrorDetails`.
+- `CreateSessionParams.expires_in_minutes` (1–60, default 15) — the session payment window.
+- Non-JSON error responses (e.g. an HTML `502` from a gateway) now throw `BitPalError` with `HTTP <status>` instead of a `SyntaxError`.
+
+### Fixed
+- **Session expiry was silently ignored.** `expires_in_seconds` was never an API field, so every session used the 15-minute default. The SDK now sends `expires_in_minutes`; `expires_in_seconds` is deprecated and converted (rounded up to whole minutes, 60–3600 s). Out-of-range values throw before the request.
+- `payer_wallet` and `pay_asset` on `createSession` are deprecated and no longer sent — the API never accepted them (it dropped them silently).
+- A contract test checks every SDK request (method, path, query and body keys) against the API's generated OpenAPI spec, so SDK ↔ API drift like the two above fails CI.
+
+### Fixed (docs / type comments)
+- `amount_total` is **always canonical 6-decimal**, regardless of the pay token. Only `amount_received`, `pay_amount` and the issued `expectedAmount` use `token_decimals`. (0.11 said `amount_total` used token decimals — wrong for 18-decimal tokens.)
+- Line item / Price `amount` is quoted in the line item's `currency` (`USDC`/`USDT` = USD, `JPYC` = JPY, no FX), not always USD.
+- Browser use: only `getPublicSession` may be called from a merchant's browser (CORS). Call `issueDepositAddress` / `getStatus` through your backend.
+- README: `previewFee` example now passes a human amount (`'29.00'`) — 0.11's README passed an atomic value, which the API reads as a human amount (1,000,000× too large).
+- README: full payments after the deadline (up to 7 days) are accepted as late payments (`late: true` on `checkout.session.paid`), not refunded.
+
+## 0.11.0 — 2026-09-17
+- **Breaking (x402 payer):** standard x402 payload — one EIP-3009 authorization and one signature (`{ signature, authorization }`). Fee split is committed by the `payTo` forwarder address. Old two-signature headers get a fresh `402`.
+- `paymentRequirements` carries the merchant wallet.
+
+## 0.10.0 — 2026-09-17
+- Webhook event `x402.payment.resolved` (an x402 payment left unresolved by `/settle` was later settled on-chain).
+
+## 0.9.0 — 2026-09-17
+- **Breaking:** `x402({ amount })` and `previewFee(amount)` take a human amount (`'1.00'`); use `amountAtomic` / `{ amountAtomic }` for raw values.
+
+## 0.8.0 — 2026-09-16
+- `x402()` per-call payment middleware, `createX402Payment()` payer helper, `X402ReplayStore` (memory default; pass a shared store when running several instances).
+
+## 0.7.0 — 2026-07-30
+- `allowed_assets: { chain, token }[]` as the standard way to set payment options.
+
+## 0.6.0 — 2026-07-30
+- Human `amount` input for line items and Prices; `paymentLinks` resource.
+
+## 0.5.0 — 2026-07-23
+- Initial public release: sessions, per-order deposit addresses, status polling, timestamped webhook signatures.

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 BitPal
-
-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.
+MIT License
+
+Copyright (c) 2026 BitPal
+
+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

@@ -13,23 +13,28 @@ pnpm add @bitpal/checkout
 
 ## Amounts — just pass a human number
 
-Use **`amount`** in line items — a plain USD string like `"20"`, `"0.5"`, `"29.00"`. No decimals to compute.
+Use **`amount`** in line items — a plain decimal string like `"20"`, `"0.5"`, `"29.00"`. No decimals to compute.
 
 ```ts
 line_items: [{ name: 'Pro', amount: '29', currency: 'USDC' }]
 ```
 
-**The amount is a USD price — it does NOT depend on the chain or token decimals.** Whether the buyer pays with USDC (6dp) on Base or USDT (18dp) on BNB, you pass the same `amount`. BitPal rescales to the buyer's chosen token at deposit time. So you never compute per-token decimals. (Prices via `prices.create` take the same `amount`.)
+**The amount is quoted in the line item's `currency` — it does NOT depend on the chain or token decimals.** `currency: 'USDC'` / `'USDT'` means a USD price; `currency: 'JPYC'` means a JPY price (`amount: '1500'` → 1,500 JPYC — there is no FX conversion). Whether the buyer pays USDC (6dp) on Base or USDT (18dp) on BNB, you pass the same `amount`; BitPal rescales to the buyer's chosen token at deposit time. (Prices via `prices.create` take the same `amount`; their currency comes from `token_symbol`.)
 
 <details><summary>Advanced: raw atomic amounts</summary>
 
-If you already hold **atomic μUSD integer strings** ($1 = `"1000000"`), pass `amount_atomic` instead (mutually exclusive with `amount`):
+If you already hold **canonical 6-decimal integer strings** (`"1"` = `"1000000"`), pass `amount_atomic` instead (mutually exclusive with `amount`):
 
 ```
-$1.00 → "1000000"   $29.00 → "29000000"   $0.50 → "500000"
+1.00 → "1000000"   29.00 → "29000000"   0.50 → "500000"
 ```
 
-Helpers for atomic conversion (e.g. reading `amount_total` back): `toAtomic(v, decimals)` / `fromAtomic(v, decimals)` — read `decimals` from `payment_options[]`/`token_decimals` (6 for USDC/USDT, 18 for BNB USDT). `toAtomicUSDC`/`fromAtomicUSDC` are 6dp shortcuts.
+Reading amounts back:
+
+- `amount_total` is **always canonical 6dp**, whatever token the buyer pays with — `fromAtomic(amount_total, 6)`.
+- `amount_received`, `pay_amount` (the exact amount the buyer must send) and the issued `expectedAmount` are in the **pay token's units** — use `token_decimals` (6 for USDC/USDT, 18 for BNB USDT / JPYC). Never assume 6dp for these.
+
+Helpers: `toAtomic(v, decimals)` / `fromAtomic(v, decimals)`; `toAtomicUSDC`/`fromAtomicUSDC` are 6dp shortcuts.
 </details>
 
 ## Environments
@@ -73,7 +78,7 @@ const { data: session } = await bitpal.checkout.createSession({
     { chain: 'tron',   token: 'USDT' },
     { chain: 'solana', token: 'USDC' },
   ],
-  expires_in_seconds: 1800,
+  expires_in_minutes: 30,
   success_url: 'https://yourstore.com/thanks',
 });
 
@@ -96,6 +101,10 @@ The buyer then sends the exact amount from **any wallet or exchange** — no wal
 signature; they pay their own network gas. A watcher detects the deposit and a keeper sweeps it to
 you.
 
+> **Call this from your backend.** Browsers on your own domain can only call `getPublicSession`
+> directly (CORS). Proxy `issueDepositAddress` / `getStatus` through your server — and never ship a
+> secret key to the browser.
+
 ```ts
 const { data } = await bitpal.checkout.issueDepositAddress(session.id, {
   session_token: session.session_token!, // from createSession
@@ -106,11 +115,13 @@ const { data } = await bitpal.checkout.issueDepositAddress(session.id, {
 });
 
 console.log(data.depositAddress);  // buyer sends the exact amount here
-console.log(data.expectedAmount);  // atomic μUSDC — display this exact amount
+console.log(data.expectedAmount);  // atomic, in the pay token's decimals — display this exact amount
 ```
 
-> `refundAddress` is committed into the deposit address and **cannot change** after issuance
-> (over / under / late payments auto-refund there on-chain).
+> `refundAddress` is committed into the deposit address and **cannot change** after issuance.
+> Overpaid excess, wrong tokens, and underpayments left at expiry are refunded there on-chain. A full
+> payment that arrives after the deadline (up to 7 days) is accepted as a **late payment** — the
+> `checkout.session.paid` webhook carries `late: true` so you can decide how to fulfil it.
 
 ### Poll status (buyer UX)
 
@@ -124,8 +135,9 @@ Polling is for buyer-facing UX. For **server-side** confirmation, trust the webh
 ### Preview the fee
 
 ```ts
-const { data: fee } = await bitpal.checkout.previewFee(toAtomicUSDC('29.00'));
-console.log(fromAtomicUSDC(fee.fee_amount)); // e.g. "0.43"
+const { data: fee } = await bitpal.checkout.previewFee('29.00');            // human amount
+// or: await bitpal.checkout.previewFee({ amountAtomic: '29000000' });       // raw 6dp
+console.log(fromAtomicUSDC(fee.fee_amount)); // response is atomic — e.g. "0.43"
 ```
 
 ## Webhooks
@@ -249,9 +261,13 @@ the response, or `release()` if you could not.
 
 ### Payer side
 
-The fee split needs two authorizations, which a stock x402 client does not know about.
-`createX402Payment` reads the `402` and builds both. You supply the signer; the SDK has no crypto
-dependency.
+The payer signs **one** standard EIP-3009 authorization, so the `X-PAYMENT` payload is plain x402:
+`{ signature, authorization }`. The fee split happens on-chain — `payTo` in the `402` is not the
+merchant's wallet but a CREATE2 address that commits to the whole split, so nothing extra has to be
+signed for it.
+
+`createX402Payment` reads the `402` and builds the header. You supply the signer; the SDK has no
+crypto dependency.
 
 ```ts
 import { createX402Payment } from '@bitpal/checkout';
@@ -277,6 +293,10 @@ if (res.status === 402) {
 Amounts are human-readable (`'1.00'`), the same model as `line_items[].amount` — the server converts.
 Pass `amountAtomic` instead if you already have raw units.
 
+The `402` also carries a `feeBreakdown` (net / fee / bps / recipient). It is informational — a payer
+can ignore it entirely and still pay correctly, because the split is already committed by the `payTo`
+address. It is there so you can see where the money goes without reading the chain.
+
 EOA signers only — smart-contract wallets cannot sign EIP-3009 authorizations. Amounts are exact:
 over- and underpayment are both rejected, and this lane has no refund path. Authorizations are valid
 for 90–3600 seconds (the server's floor is 60s; the extra 30s absorbs clock skew and round trips).
@@ -308,6 +328,26 @@ store wiring session creation + webhook verification + idempotency.
 pnpm build   # tsup → dist/ (ESM + .d.ts)
 ```
 
+## Migrating to 0.11.0 (breaking — x402 payer only)
+
+The `X-PAYMENT` payload changed from BitPal's two-authorization shape to the **x402 standard**:
+
+```
+0.10.0   payload: { merchant: {...}, fee: {...} }     two signatures
+0.11.0   payload: { signature, authorization }        one signature — plain x402
+```
+
+- If you call `createX402Payment`, nothing changes in your code. It signs once now instead of twice,
+  and the wallet prompts once.
+- If you built the payload by hand, rebuild it in the standard shape.
+- `splitSignature` is gone. `normalizeSignature` replaces it — same input handling (65-byte or
+  EIP-2098 compact, `v` of 0/1/27/28) but it returns a 65-byte packed hex string, which is what the
+  payload carries.
+- The `402` is unchanged apart from `payTo`, which now points at the settlement address rather than
+  the merchant wallet. Both `X402Gate` and `x402()` handle this for you.
+
+Old headers are rejected — a payer on 0.10.0 gets a fresh `402` and re-signs, so no payment is lost.
+
 ## Migrating from 0.3.x → 0.5.0 (breaking)
 
 - **Webhook verification now requires the timestamp** and enforces replay defense. Pass the

package/dist/index.cjs

@@ -48,8 +48,9 @@ __export(index_exports, {
   encodePaymentHeader: () => encodePaymentHeader,
   fromAtomic: () => fromAtomic,
   fromAtomicUSDC: () => fromAtomicUSDC,
+  normalizeSignature: () => normalizeSignature,
+  parseApiErrorBody: () => parseApiErrorBody,
   parseWebhookEvent: () => parseWebhookEvent,
-  splitSignature: () => splitSignature,
   toAtomic: () => toAtomic,
   toAtomicUSDC: () => toAtomicUSDC,
   verifyWebhookSignature: () => verifyWebhookSignature,
@@ -138,12 +139,25 @@ var PaymentLinksResource = class {
 };
 
 // src/client.ts
+var EXPIRY_MIN_MINUTES = 1;
+var EXPIRY_MAX_MINUTES = 60;
+function resolveExpiryMinutes(minutes, seconds) {
+  if (minutes !== void 0 && seconds !== void 0) {
+    throw new Error("[BitPal] pass only one of `expires_in_minutes` or `expires_in_seconds`.");
+  }
+  const resolved = seconds !== void 0 ? Math.ceil(seconds / 60) : minutes;
+  if (resolved === void 0) return void 0;
+  if (!Number.isInteger(resolved) || resolved < EXPIRY_MIN_MINUTES || resolved > EXPIRY_MAX_MINUTES) {
+    throw new Error(`[BitPal] session expiry must be ${EXPIRY_MIN_MINUTES}\u2013${EXPIRY_MAX_MINUTES} minutes (expires_in_minutes) \u2014 got ${seconds !== void 0 ? seconds + "s" : minutes}.`);
+  }
+  return resolved;
+}
 function validateLineItem(li) {
   if ("price_id" in li) return li;
   const hasHuman = li.amount != null;
   const hasAtomic = li.amount_atomic != null;
   if (hasHuman === hasAtomic) {
-    throw new Error('[BitPal] line item requires exactly one of `amount` (USD number, e.g. "29") or `amount_atomic` (raw \u03BCUSD integer, e.g. "29000000").');
+    throw new Error('[BitPal] line item requires exactly one of `amount` (canonical decimal number, e.g. "29") or `amount_atomic` (raw canonical 6dp integer, e.g. "29000000").');
   }
   return li;
 }
@@ -186,10 +200,18 @@ var BitPalCheckoutClient = class {
         body: body ? JSON.stringify(body) : void 0,
         signal: controller.signal
       });
-      const json = await res.json();
+      const text = await res.text();
+      let json = null;
+      try {
+        json = text ? JSON.parse(text) : null;
+      } catch {
+        if (!res.ok) throw new BitPalError(`HTTP ${res.status}`, res.status);
+        throw new BitPalError(`Invalid JSON response (HTTP ${res.status})`, res.status);
+      }
       if (!res.ok) {
-        const msg = json.error ?? `HTTP ${res.status}`;
-        throw new BitPalError(String(msg), res.status);
+        const err = json && typeof json === "object" ? json.error : void 0;
+        const msg = typeof err === "string" && err.length > 0 ? err : `HTTP ${res.status}`;
+        throw new BitPalError(msg, res.status, parseApiErrorBody(json));
       }
       return json;
     } finally {
@@ -200,14 +222,16 @@ var BitPalCheckoutClient = class {
   /**
    * 체크아웃 세션 생성.
    *
-   * `line_items[].amount` 는 사람 표기 USD 문자열("29", "0.5") — decimal 계산 불필요.
-   * 이미 raw μUSD 정수라면 `amount_atomic`("29000000") 사용(고급). 둘은 상호 배타.
+   * `line_items[].amount` 는 사람 표기 canonical 6dp 문자열("29", "0.5") — decimal 계산 불필요.
+   * `currency`('USDC'/'USDT'/'JPYC')가 실제 결제 통화를 결정하고, amount 는 항상 그 통화 기준 값이다
+   * (USD 로 고정된 게 아님 — currency='JPYC' + amount='1500' → 1500엔/1500 JPYC, 환율 변환 없음).
+   * 이미 raw canonical 6dp 정수라면 `amount_atomic`("29000000") 사용(고급). 둘은 상호 배타.
    *
    * @example
    * import { BitPal } from '@bitpal/checkout';
    * const bp = new BitPal('bp_test_...');
    * const { data } = await bp.checkout.createSession({
-   *   // amount: 사람 표기 USD("29", "0.5"). 금액은 USD 가격이라 체인/토큰 decimal 무관.
+   *   // amount: 사람 표기 canonical 6dp("29", "0.5"). 체인/토큰 decimal 은 발급 시 서버가 재스케일.
    *   line_items: [{ name: 'Pro', amount: '29', currency: 'USDC' }],
    * });
    * console.log(data.url); // → buyer를 redirect할 결제 페이지
@@ -224,8 +248,11 @@ var BitPalCheckoutClient = class {
     if (params.pay_chain && params.allowed_pay_chains && params.allowed_pay_chains.length > 0) {
       throw new Error("[BitPal] pay_chain and allowed_pay_chains are mutually exclusive \u2014 use only one.");
     }
+    const { expires_in_seconds, payer_wallet: _payerWallet, pay_asset: _payAsset, ...rest } = params;
+    const expiresInMinutes = resolveExpiryMinutes(params.expires_in_minutes, expires_in_seconds);
     const body = {
-      ...params,
+      ...rest,
+      ...expiresInMinutes !== void 0 ? { expires_in_minutes: expiresInMinutes } : {},
       line_items: params.line_items.map(validateLineItem),
       ...params.allowed_assets ? { allowed_assets: params.allowed_assets.map((a) => ({ caip2: a.chain, token: a.token })) } : {}
     };
@@ -336,12 +363,37 @@ var BitPalCheckoutClient = class {
 };
 var BitPalError = class extends Error {
   statusCode;
-  constructor(message, statusCode) {
+  code;
+  apiMessage;
+  retryable;
+  traceId;
+  constructor(message, statusCode, details = {}) {
     super(message);
     this.name = "BitPalError";
     this.statusCode = statusCode;
+    this.code = details.code;
+    this.apiMessage = details.apiMessage;
+    this.retryable = details.retryable;
+    this.traceId = details.traceId;
   }
 };
+var ERROR_CODE_RE = /^[A-Z][A-Z0-9_]*$/;
+function parseApiErrorBody(body) {
+  if (!body || typeof body !== "object") return {};
+  const b = body;
+  const str = (v) => typeof v === "string" && v.length > 0 ? v : void 0;
+  const error = str(b.error);
+  const explicitCode = str(b.code);
+  const message = str(b.message);
+  const code = explicitCode ?? (error && ERROR_CODE_RE.test(error) ? error : void 0);
+  const apiMessage = message ?? (explicitCode && error && error !== explicitCode ? error : void 0);
+  return {
+    code,
+    apiMessage,
+    retryable: typeof b.retryable === "boolean" ? b.retryable : void 0,
+    traceId: str(b.trace_id)
+  };
+}
 
 // src/webhook.ts
 var CHECKOUT_WEBHOOK_EVENTS = [
@@ -544,11 +596,11 @@ var X402Gate = class {
     } catch {
       return this.paymentRequired(resource, "MALFORMED_PAYMENT_HEADER");
     }
-    const merchant = payload?.payload?.merchant;
-    if (!merchant?.from || !merchant?.nonce) {
+    const auth = payload?.payload?.authorization;
+    if (!auth?.from || !auth?.nonce) {
       return this.paymentRequired(resource, "MALFORMED_PAYMENT_HEADER");
     }
-    const key = `${payload.network}:${merchant.from.toLowerCase()}:${merchant.nonce.toLowerCase()}`;
+    const key = `${payload.network}:${auth.from.toLowerCase()}:${auth.nonce.toLowerCase()}`;
     const claim = await this.store.claim(key, this.maxTimeoutSeconds);
     if (claim === "used") {
       return {
@@ -586,7 +638,12 @@ var X402Gate = class {
       },
       paymentRequirements: {
         asset: accept.asset,
+        // payer 가 서명한 목적지 = 분배 조건을 커밋한 정산 주소.
         payTo: accept.payTo,
+        // 머천트 정산 지갑. facilitator 가 이 값으로 정산 주소를 재계산해 payTo 와 대조한다 —
+        //   CREATE2 는 단방향이라 payTo 에서 되돌릴 수 없으므로 따로 보내야 한다.
+        //   우리 설정값을 그대로 쓴다(402 응답에서 읽지 않는다 — 그러면 재계산의 의미가 없다).
+        merchant: this.opts.payTo,
         maxAmountRequired: accept.maxAmountRequired,
         resource: accept.resource
       }
@@ -638,7 +695,7 @@ var X402Gate = class {
       txHash: settled.tx_hash,
       feeTxHash: settled.fee_tx_hash ?? null,
       network: settled.network,
-      payer: merchant.from,
+      payer: auth.from,
       amount: accept.maxAmountRequired,
       idempotent: settled.idempotent ?? false
     };
@@ -650,7 +707,7 @@ var X402Gate = class {
         success: true,
         transaction: settled.tx_hash,
         network: settled.network,
-        payer: merchant.from,
+        payer: auth.from,
         paymentId: settled.payment_id
       }),
       // 소진 확정은 **응답을 실제로 내준 뒤**다. 핸들러가 throw 하거나 프로세스가 죽으면 결제만 하고
@@ -771,18 +828,22 @@ function assertPaymentPayload(value) {
     throw new Error("[BitPal] x402: invalid network.");
   }
   const inner = asObject(root.payload, "payload");
-  const merchant = assertAuthorization(inner.merchant, "merchant");
-  const fee = inner.fee === void 0 ? void 0 : assertAuthorization(inner.fee, "fee");
+  if (typeof inner.signature !== "string" || !PACKED_SIG_RE.test(inner.signature)) {
+    throw new Error("[BitPal] x402: invalid payload.signature (expected 65-byte packed hex).");
+  }
   return {
     x402Version: 1,
     scheme: "exact",
     network: root.network,
-    payload: fee ? { merchant, fee } : { merchant }
+    payload: {
+      signature: inner.signature,
+      authorization: assertAuthorization(inner.authorization, "authorization")
+    }
   };
 }
+var PACKED_SIG_RE = /^0x[0-9a-fA-F]{130}$/;
 function assertAuthorization(value, label) {
-  const a = asObject(value, `${label} authorization`);
-  const sig = asObject(a.signature, `${label} signature`);
+  const a = asObject(value, label);
   const check = (ok, field) => {
     if (!ok) throw new Error(`[BitPal] x402: invalid ${label}.${field}.`);
   };
@@ -792,17 +853,13 @@ function assertAuthorization(value, label) {
   check(typeof a.validAfter === "string" && DECIMAL_RE.test(a.validAfter), "validAfter");
   check(typeof a.validBefore === "string" && DECIMAL_RE.test(a.validBefore), "validBefore");
   check(typeof a.nonce === "string" && HEX32_RE.test(a.nonce), "nonce");
-  check(typeof sig.v === "number" && Number.isInteger(sig.v), "signature.v");
-  check(typeof sig.r === "string" && HEX32_RE.test(sig.r), "signature.r");
-  check(typeof sig.s === "string" && HEX32_RE.test(sig.s), "signature.s");
   return {
     from: a.from,
     to: a.to,
     value: a.value,
     validAfter: a.validAfter,
     validBefore: a.validBefore,
-    nonce: a.nonce,
-    signature: { v: sig.v, r: sig.r, s: sig.s }
+    nonce: a.nonce
   };
 }
 function asObject(value, label) {
@@ -876,49 +933,33 @@ async function createX402Payment(options) {
   }
   const validAfter = "0";
   const validBefore = String(now + validFor);
-  const nextNonce = options.randomNonce ?? randomNonce;
-  const fee = accept.feeBreakdown;
-  const feeAmount = fee ? BigInt(fee.feeAmount) : 0n;
-  const merchantValue = fee ? fee.netAmount : accept.maxAmountRequired;
-  const merchant = await signAuthorization({
-    domain,
-    signTypedData: options.signTypedData,
+  const nonce = (options.randomNonce ?? randomNonce)();
+  const authorization = {
     from: options.from,
     to: accept.payTo,
-    value: merchantValue,
+    value: accept.maxAmountRequired,
     validAfter,
     validBefore,
-    nonce: nextNonce()
-  });
-  let feeLeg;
-  if (feeAmount > 0n) {
-    if (!fee?.feeRecipient) {
-      throw new Error("[BitPal] x402: feeAmount > 0 but feeRecipient is missing in the 402 response.");
-    }
-    feeLeg = await signAuthorization({
+    nonce
+  };
+  const signature = normalizeSignature(
+    await options.signTypedData({
       domain,
-      signTypedData: options.signTypedData,
-      from: options.from,
-      to: fee.feeRecipient,
-      value: fee.feeAmount,
-      validAfter,
-      validBefore,
-      nonce: nextNonce()
-    });
-    if (feeLeg.nonce.toLowerCase() === merchant.nonce.toLowerCase()) {
-      throw new Error("[BitPal] x402: the two authorizations must use different nonces.");
-    }
-  }
+      types: TRANSFER_WITH_AUTHORIZATION_TYPES,
+      primaryType: "TransferWithAuthorization",
+      message: authorization
+    })
+  );
   const payload = {
     x402Version: 1,
     scheme: "exact",
     network: accept.network,
-    payload: feeLeg ? { merchant, fee: feeLeg } : { merchant }
+    payload: { signature, authorization }
   };
   return {
     header: encodePaymentHeader(payload),
     payload,
-    totalAmount: (BigInt(merchantValue) + feeAmount).toString()
+    totalAmount: accept.maxAmountRequired
   };
 }
 function resolveAccept(input) {
@@ -929,41 +970,24 @@ function resolveAccept(input) {
   }
   return input;
 }
-async function signAuthorization(args) {
-  const message = {
-    from: args.from,
-    to: args.to,
-    value: args.value,
-    validAfter: args.validAfter,
-    validBefore: args.validBefore,
-    nonce: args.nonce
-  };
-  const signature = await args.signTypedData({
-    domain: args.domain,
-    types: TRANSFER_WITH_AUTHORIZATION_TYPES,
-    primaryType: "TransferWithAuthorization",
-    message
-  });
-  return { ...message, signature: splitSignature(signature) };
-}
-function splitSignature(signature) {
+function normalizeSignature(signature) {
   const hex = signature.startsWith("0x") ? signature.slice(2) : signature;
   if (!/^[0-9a-fA-F]+$/.test(hex) || hex.length !== 130 && hex.length !== 128) {
     throw new Error(
       `[BitPal] x402: expected a 65-byte or 64-byte (EIP-2098) hex signature, got ${signature.length} chars.`
     );
   }
-  const r = `0x${hex.slice(0, 64)}`;
+  const r = hex.slice(0, 64);
   if (hex.length === 128) {
     const yParityAndS = BigInt(`0x${hex.slice(64, 128)}`);
     const yParity = Number(yParityAndS >> 255n & 1n);
-    const s2 = yParityAndS & (1n << 255n) - 1n;
-    return { v: 27 + yParity, r, s: `0x${s2.toString(16).padStart(64, "0")}` };
+    const s2 = (yParityAndS & (1n << 255n) - 1n).toString(16).padStart(64, "0");
+    return `0x${r}${s2}${(27 + yParity).toString(16).padStart(2, "0")}`;
   }
-  const s = `0x${hex.slice(64, 128)}`;
+  const s = hex.slice(64, 128);
   const raw = parseInt(hex.slice(128, 130), 16);
-  if (raw === 27 || raw === 28) return { v: raw, r, s };
-  if (raw === 0 || raw === 1) return { v: raw + 27, r, s };
+  if (raw === 27 || raw === 28) return `0x${r}${s}${raw.toString(16)}`;
+  if (raw === 0 || raw === 1) return `0x${r}${s}${(raw + 27).toString(16)}`;
   throw new Error(`[BitPal] x402: unexpected signature v=${raw} (expected 0, 1, 27 or 28).`);
 }
 function randomNonce() {
@@ -1005,8 +1029,9 @@ var BitPal = class {
   encodePaymentHeader,
   fromAtomic,
   fromAtomicUSDC,
+  normalizeSignature,
+  parseApiErrorBody,
   parseWebhookEvent,
-  splitSignature,
   toAtomic,
   toAtomicUSDC,
   verifyWebhookSignature,