@bosonprotocol/x402-core 0.1.0-alpha-0

package/dist/cjs/eip712/token-auth/index.d.ts

@@ -0,0 +1,259 @@
+import { Address, Hex, PublicClient, TypedDataDomain } from 'viem';
+export { createPermit2ApprovalTx, getPermit2AllowanceReadParams } from '@x402/evm/exact/client';
+
+interface TokenEip712Domain {
+    /** Token's `EIP712Domain.name`, e.g. `"USD Coin"`. */
+    name: string;
+    /** Token's `EIP712Domain.version`, e.g. `"2"`. */
+    version: string;
+    chainId: number;
+    /** Token contract address. */
+    verifyingContract: Address;
+    /** Optional extra domain field some tokens publish. */
+    salt?: Hex;
+}
+
+/** EIP-712 type definition, keyed under the Boson-side primary type. */
+declare const ERC3009_TYPES: {
+    readonly ReceiveWithAuthorization: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validAfter";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validBefore";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "bytes32";
+    }];
+};
+declare const ERC3009_PRIMARY_TYPE: "ReceiveWithAuthorization";
+interface Erc3009Message {
+    from: Address;
+    to: Address;
+    value: bigint;
+    validAfter: bigint;
+    validBefore: bigint;
+    /** 32-byte hex; should be cryptographically random per the ERC-3009 spec. */
+    nonce: Hex;
+}
+interface Erc3009TypedDataArgs {
+    /**
+     * The token contract's own EIP-712 domain. ERC-3009 requires
+     * `{ name, version, chainId, verifyingContract }` to match what the
+     * token recovers on-chain — see {@link TokenEip712Domain}.
+     */
+    domain: TokenEip712Domain;
+    message: Erc3009Message;
+}
+interface Erc3009TypedData {
+    domain: TokenEip712Domain;
+    types: typeof ERC3009_TYPES;
+    primaryType: typeof ERC3009_PRIMARY_TYPE;
+    message: Erc3009Message;
+}
+declare function erc3009TypedData({ domain, message }: Erc3009TypedDataArgs): Erc3009TypedData;
+declare function hashErc3009Authorization(args: Erc3009TypedDataArgs): Hex;
+declare function recoverErc3009Signer(args: Erc3009TypedDataArgs & {
+    signature: Hex;
+}): Promise<Address>;
+
+declare const EIP5267_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "eip712Domain";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "fields";
+        readonly type: "bytes1";
+    }, {
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "version";
+        readonly type: "string";
+    }, {
+        readonly name: "chainId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "verifyingContract";
+        readonly type: "address";
+    }, {
+        readonly name: "salt";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "extensions";
+        readonly type: "uint256[]";
+    }];
+}];
+declare const NAME_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "name";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}];
+declare const VERSION_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "version";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}];
+/**
+ * Look up the token's EIP-712 domain. Tries EIP-5267 first (one call,
+ * canonical); falls back to `name()` + `version()` (with version
+ * defaulting to `"1"` per EIP-2612 if `version()` reverts).
+ *
+ * Error handling: only contract-level errors (any `ContractFunction*`
+ * class viem throws via `getContractError`) are treated as "method not
+ * implemented" and trigger the fallback. RPC / transport failures
+ * (HTTP timeouts, JSON-RPC errors) propagate as-is so the caller can
+ * distinguish them and surface a clear internal error rather than a
+ * silent fallback that fails again on the next call. `name()` is
+ * required by ERC-20 so any failure there is a real error and
+ * propagates.
+ *
+ * Both the facilitator (recovering a signature) and the browser paywall
+ * (about to sign one) call this against the same chain — keeping the
+ * lookup in one place keeps signer and verifier in lockstep.
+ */
+declare function fetchTokenDomain(publicClient: PublicClient, token: Address, chainId: number): Promise<TokenEip712Domain>;
+
+declare const PERMIT_TYPES: {
+    readonly Permit: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+declare const PERMIT_PRIMARY_TYPE: "Permit";
+interface PermitMessage {
+    owner: Address;
+    spender: Address;
+    value: bigint;
+    /** Token-internal sequential nonce — query via `IERC20Permit.nonces(owner)`. */
+    nonce: bigint;
+    deadline: bigint;
+}
+interface PermitTypedDataArgs {
+    /**
+     * The token contract's own EIP-712 domain. EIP-2612 requires
+     * `{ name, version, chainId, verifyingContract }` to produce the
+     * digest the token recovers on-chain — see {@link TokenEip712Domain}.
+     */
+    domain: TokenEip712Domain;
+    message: PermitMessage;
+}
+interface PermitTypedData {
+    domain: TokenEip712Domain;
+    types: typeof PERMIT_TYPES;
+    primaryType: typeof PERMIT_PRIMARY_TYPE;
+    message: PermitMessage;
+}
+declare function permitTypedData({ domain, message }: PermitTypedDataArgs): PermitTypedData;
+declare function hashPermit(args: PermitTypedDataArgs): Hex;
+declare function recoverPermitSigner(args: PermitTypedDataArgs & {
+    signature: Hex;
+}): Promise<Address>;
+
+/**
+ * Canonical Permit2 contract address. Same on every EVM chain via CREATE2
+ * deployment.
+ *
+ * @see https://github.com/Uniswap/permit2
+ */
+declare const PERMIT2_ADDRESS: Address;
+/** Permit2's EIP-712 `name` field. No `version`, no `salt`. */
+declare const PERMIT2_DOMAIN_NAME: "Permit2";
+declare const PERMIT2_TYPES: {
+    readonly PermitTransferFrom: readonly [{
+        readonly name: "permitted";
+        readonly type: "TokenPermissions";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly TokenPermissions: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+};
+declare const PERMIT2_PRIMARY_TYPE: "PermitTransferFrom";
+interface Permit2Message {
+    permitted: {
+        token: Address;
+        amount: bigint;
+    };
+    spender: Address;
+    /** Permit2 word-bitmap nonce. */
+    nonce: bigint;
+    deadline: bigint;
+}
+interface Permit2TypedDataArgs {
+    chainId: number;
+    message: Permit2Message;
+}
+interface Permit2TypedData {
+    domain: TypedDataDomain;
+    types: typeof PERMIT2_TYPES;
+    primaryType: typeof PERMIT2_PRIMARY_TYPE;
+    message: Permit2Message;
+}
+/** Permit2's EIP-712 domain on a given chain. The `verifyingContract` is the canonical Permit2 address. */
+declare function permit2Domain(chainId: number): TypedDataDomain;
+declare function permit2TypedData({ chainId, message }: Permit2TypedDataArgs): Permit2TypedData;
+declare function hashPermit2(args: Permit2TypedDataArgs): Hex;
+declare function recoverPermit2Signer(args: Permit2TypedDataArgs & {
+    signature: Hex;
+}): Promise<Address>;
+
+interface Erc20ApprovalArgs {
+    token: Address;
+    spender: Address;
+    amount: bigint;
+}
+/**
+ * Build calldata for an ERC-20 `approve(spender, amount)` call. Use with
+ * `walletClient.sendTransaction({ to: token, data })` or any equivalent
+ * signer to grant `spender` (the Boson escrow contract) the right to
+ * pull `amount` of `token`.
+ */
+declare function createErc20ApprovalTx({ token, spender, amount }: Erc20ApprovalArgs): {
+    to: Address;
+    data: Hex;
+};
+
+export { EIP5267_ABI, ERC3009_PRIMARY_TYPE, ERC3009_TYPES, type Erc20ApprovalArgs, type Erc3009Message, type Erc3009TypedData, type Erc3009TypedDataArgs, NAME_ABI, PERMIT2_ADDRESS, PERMIT2_DOMAIN_NAME, PERMIT2_PRIMARY_TYPE, PERMIT2_TYPES, PERMIT_PRIMARY_TYPE, PERMIT_TYPES, type Permit2Message, type Permit2TypedData, type Permit2TypedDataArgs, type PermitMessage, type PermitTypedData, type PermitTypedDataArgs, type TokenEip712Domain, VERSION_ABI, createErc20ApprovalTx, erc3009TypedData, fetchTokenDomain, hashErc3009Authorization, hashPermit, hashPermit2, permit2Domain, permit2TypedData, permitTypedData, recoverErc3009Signer, recoverPermit2Signer, recoverPermitSigner };

package/dist/cjs/eip712/token-auth/index.js

@@ -0,0 +1,221 @@
+'use strict';
+
+var viem = require('viem');
+var client = require('@x402/evm/exact/client');
+
+// src/eip712/token-auth/erc3009.ts
+var ERC3009_TYPES = {
+  ReceiveWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var ERC3009_PRIMARY_TYPE = "ReceiveWithAuthorization";
+function erc3009TypedData({ domain, message }) {
+  return { domain, types: ERC3009_TYPES, primaryType: ERC3009_PRIMARY_TYPE, message };
+}
+function hashErc3009Authorization(args) {
+  return viem.hashTypedData(erc3009TypedData(args));
+}
+async function recoverErc3009Signer(args) {
+  const { signature, ...rest } = args;
+  return viem.recoverTypedDataAddress({ ...erc3009TypedData(rest), signature });
+}
+
+// src/eip712/token-auth/fetch-token-domain.ts
+var EIP5267_ABI = [
+  {
+    type: "function",
+    name: "eip712Domain",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "fields", type: "bytes1" },
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" },
+      { name: "salt", type: "bytes32" },
+      { name: "extensions", type: "uint256[]" }
+    ]
+  }
+];
+var NAME_ABI = [
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  }
+];
+var VERSION_ABI = [
+  {
+    type: "function",
+    name: "version",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  }
+];
+var EIP5267_SALT_BIT = 16;
+function isContractFunctionError(e) {
+  if (!(e instanceof Error)) return false;
+  return e.name.startsWith("ContractFunction");
+}
+async function fetchTokenDomain(publicClient, token, chainId) {
+  try {
+    const result = await publicClient.readContract({
+      address: token,
+      abi: EIP5267_ABI,
+      functionName: "eip712Domain"
+    });
+    const hasSalt = (Number(result[0]) & EIP5267_SALT_BIT) !== 0;
+    return {
+      name: result[1],
+      version: result[2],
+      chainId: Number(result[3]),
+      verifyingContract: result[4],
+      // Only attach `salt` when the bitmask says it's part of the domain
+      // — omit the key entirely rather than emitting `salt: undefined`,
+      // so the object shape matches the optional `salt?` type and
+      // downstream `in` / key checks don't see a phantom field.
+      ...hasSalt ? { salt: result[5] } : {}
+    };
+  } catch (e) {
+    if (!isContractFunctionError(e)) {
+      throw e;
+    }
+  }
+  const name = await publicClient.readContract({
+    address: token,
+    abi: NAME_ABI,
+    functionName: "name"
+  });
+  let version = "1";
+  try {
+    version = await publicClient.readContract({
+      address: token,
+      abi: VERSION_ABI,
+      functionName: "version"
+    });
+  } catch (e) {
+    if (!isContractFunctionError(e)) {
+      throw e;
+    }
+  }
+  return { name, version, chainId, verifyingContract: token };
+}
+var PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var PERMIT_PRIMARY_TYPE = "Permit";
+function permitTypedData({ domain, message }) {
+  return { domain, types: PERMIT_TYPES, primaryType: PERMIT_PRIMARY_TYPE, message };
+}
+function hashPermit(args) {
+  return viem.hashTypedData(permitTypedData(args));
+}
+async function recoverPermitSigner(args) {
+  const { signature, ...rest } = args;
+  return viem.recoverTypedDataAddress({ ...permitTypedData(rest), signature });
+}
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var PERMIT2_DOMAIN_NAME = "Permit2";
+var PERMIT2_TYPES = {
+  PermitTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ]
+};
+var PERMIT2_PRIMARY_TYPE = "PermitTransferFrom";
+function permit2Domain(chainId) {
+  return { name: PERMIT2_DOMAIN_NAME, chainId, verifyingContract: PERMIT2_ADDRESS };
+}
+function permit2TypedData({ chainId, message }) {
+  return {
+    domain: permit2Domain(chainId),
+    types: PERMIT2_TYPES,
+    primaryType: PERMIT2_PRIMARY_TYPE,
+    message
+  };
+}
+function hashPermit2(args) {
+  return viem.hashTypedData(permit2TypedData(args));
+}
+async function recoverPermit2Signer(args) {
+  const { signature, ...rest } = args;
+  return viem.recoverTypedDataAddress({ ...permit2TypedData(rest), signature });
+}
+var ERC20_APPROVE_ABI = [
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  }
+];
+function createErc20ApprovalTx({ token, spender, amount }) {
+  return {
+    to: token,
+    data: viem.encodeFunctionData({
+      abi: ERC20_APPROVE_ABI,
+      functionName: "approve",
+      args: [spender, amount]
+    })
+  };
+}
+
+Object.defineProperty(exports, "createPermit2ApprovalTx", {
+  enumerable: true,
+  get: function () { return client.createPermit2ApprovalTx; }
+});
+Object.defineProperty(exports, "getPermit2AllowanceReadParams", {
+  enumerable: true,
+  get: function () { return client.getPermit2AllowanceReadParams; }
+});
+exports.EIP5267_ABI = EIP5267_ABI;
+exports.ERC3009_PRIMARY_TYPE = ERC3009_PRIMARY_TYPE;
+exports.ERC3009_TYPES = ERC3009_TYPES;
+exports.NAME_ABI = NAME_ABI;
+exports.PERMIT2_ADDRESS = PERMIT2_ADDRESS;
+exports.PERMIT2_DOMAIN_NAME = PERMIT2_DOMAIN_NAME;
+exports.PERMIT2_PRIMARY_TYPE = PERMIT2_PRIMARY_TYPE;
+exports.PERMIT2_TYPES = PERMIT2_TYPES;
+exports.PERMIT_PRIMARY_TYPE = PERMIT_PRIMARY_TYPE;
+exports.PERMIT_TYPES = PERMIT_TYPES;
+exports.VERSION_ABI = VERSION_ABI;
+exports.createErc20ApprovalTx = createErc20ApprovalTx;
+exports.erc3009TypedData = erc3009TypedData;
+exports.fetchTokenDomain = fetchTokenDomain;
+exports.hashErc3009Authorization = hashErc3009Authorization;
+exports.hashPermit = hashPermit;
+exports.hashPermit2 = hashPermit2;
+exports.permit2Domain = permit2Domain;
+exports.permit2TypedData = permit2TypedData;
+exports.permitTypedData = permitTypedData;
+exports.recoverErc3009Signer = recoverErc3009Signer;
+exports.recoverPermit2Signer = recoverPermit2Signer;
+exports.recoverPermitSigner = recoverPermitSigner;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/cjs/eip712/token-auth/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/eip712/token-auth/erc3009.ts","../../../../src/eip712/token-auth/fetch-token-domain.ts","../../../../src/eip712/token-auth/permit.ts","../../../../src/eip712/token-auth/permit2.ts","../../../../src/eip712/token-auth/approve.ts"],"names":["hashTypedData","recoverTypedDataAddress","encodeFunctionData"],"mappings":"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","file":"index.js","sourcesContent":["// EIP-712 typed-data builder for ERC-3009 `ReceiveWithAuthorization`.\n//\n// Boson uses the receive variant per docs/boson-impl-01-escrow-scheme.md §4.3\n// because only the recipient (Boson escrow contract) can call\n// `receiveWithAuthorization`, eliminating relayer front-running. The struct\n// fields are identical to ERC-3009's `TransferWithAuthorization` — only the\n// on-chain function name and primary type differ. The shape is fixed by\n// EIP-3009 and hasn't changed since the standard was published.\n//\n// `@bosonprotocol/core-sdk` exposes the same type-list internally inside\n// `signReceiveWithErc3009Authorization` but auto-generates the `nonce`\n// before returning typed-data. The verification path needs a caller-supplied\n// nonce (so it can rebuild the digest the buyer signed), so this module\n// keeps a standalone typed-data builder. A KAT cross-validation test\n// (`sdk-parity.test.ts`) asserts the type-list matches the SDK's internal\n// one, catching drift if either side ever changes.\n\nimport { hashTypedData, recoverTypedDataAddress, type Address, type Hex } from \"viem\";\n\nimport type { TokenEip712Domain } from \"./domain.js\";\n\n/** EIP-712 type definition, keyed under the Boson-side primary type. */\nexport const ERC3009_TYPES = {\n  ReceiveWithAuthorization: [\n    { name: \"from\", type: \"address\" },\n    { name: \"to\", type: \"address\" },\n    { name: \"value\", type: \"uint256\" },\n    { name: \"validAfter\", type: \"uint256\" },\n    { name: \"validBefore\", type: \"uint256\" },\n    { name: \"nonce\", type: \"bytes32\" },\n  ],\n} as const;\n\nexport const ERC3009_PRIMARY_TYPE = \"ReceiveWithAuthorization\" as const;\n\nexport interface Erc3009Message {\n  from: Address;\n  to: Address;\n  value: bigint;\n  validAfter: bigint;\n  validBefore: bigint;\n  /** 32-byte hex; should be cryptographically random per the ERC-3009 spec. */\n  nonce: Hex;\n}\n\nexport interface Erc3009TypedDataArgs {\n  /**\n   * The token contract's own EIP-712 domain. ERC-3009 requires\n   * `{ name, version, chainId, verifyingContract }` to match what the\n   * token recovers on-chain — see {@link TokenEip712Domain}.\n   */\n  domain: TokenEip712Domain;\n  message: Erc3009Message;\n}\n\nexport interface Erc3009TypedData {\n  domain: TokenEip712Domain;\n  types: typeof ERC3009_TYPES;\n  primaryType: typeof ERC3009_PRIMARY_TYPE;\n  message: Erc3009Message;\n}\n\nexport function erc3009TypedData({ domain, message }: Erc3009TypedDataArgs): Erc3009TypedData {\n  return { domain, types: ERC3009_TYPES, primaryType: ERC3009_PRIMARY_TYPE, message };\n}\n\nexport function hashErc3009Authorization(args: Erc3009TypedDataArgs): Hex {\n  return hashTypedData(erc3009TypedData(args));\n}\n\nexport async function recoverErc3009Signer(\n  args: Erc3009TypedDataArgs & { signature: Hex },\n): Promise<Address> {\n  const { signature, ...rest } = args;\n  return recoverTypedDataAddress({ ...erc3009TypedData(rest), signature });\n}\n","// Shared resolver for a token contract's EIP-712 domain (`name`,\n// `version`). ERC-3009 (`ReceiveWithAuthorization`) and EIP-2612\n// (`Permit`) signers and the facilitator's verify path both need this\n// lookup — keeping it in a single place ensures signing and verification\n// stay in lock-step on one ABI surface and one fallback flow.\n//\n// Tries EIP-5267's canonical `eip712Domain()` view first; on a contract\n// that doesn't implement it, falls back to ERC-20 `name()` + EIP-2612\n// `version()` with `\"1\"` as the default if `version()` reverts (the\n// EIP-2612-specified default).\n//\n// Error handling: only `ContractFunctionExecutionError` is treated as\n// \"method not implemented\" and triggers a fallback. RPC / transport\n// failures propagate as-is so callers can distinguish them and surface a\n// clear failure rather than a silent fallback that fails again on the\n// next call. `name()` is required by ERC-20 so any failure there is a\n// real error and propagates.\n\nimport { type Address, type Hex, type PublicClient } from \"viem\";\n\nimport type { TokenEip712Domain } from \"./domain.js\";\n\nexport const EIP5267_ABI = [\n  {\n    type: \"function\",\n    name: \"eip712Domain\",\n    stateMutability: \"view\",\n    inputs: [],\n    outputs: [\n      { name: \"fields\", type: \"bytes1\" },\n      { name: \"name\", type: \"string\" },\n      { name: \"version\", type: \"string\" },\n      { name: \"chainId\", type: \"uint256\" },\n      { name: \"verifyingContract\", type: \"address\" },\n      { name: \"salt\", type: \"bytes32\" },\n      { name: \"extensions\", type: \"uint256[]\" },\n    ],\n  },\n] as const;\n\nexport const NAME_ABI = [\n  {\n    type: \"function\",\n    name: \"name\",\n    stateMutability: \"view\",\n    inputs: [],\n    outputs: [{ type: \"string\" }],\n  },\n] as const;\n\nexport const VERSION_ABI = [\n  {\n    type: \"function\",\n    name: \"version\",\n    stateMutability: \"view\",\n    inputs: [],\n    outputs: [{ type: \"string\" }],\n  },\n] as const;\n\n// EIP-5267 `fields` bitmask: bit i (LSB-first) is set when domain field\n// i — in EIP-712's canonical field order (name, version, chainId,\n// verifyingContract, salt) — is present. We only need the `salt` bit:\n// tokens whose domain includes `salt` computed their domain separator\n// with it, so the signature won't recover unless we carry it through;\n// tokens that omit `salt` return a zero `bytes32` we must drop, or the\n// extra field corrupts the domain we hash against.\nconst EIP5267_SALT_BIT = 0x10;\n\n// Duck-type check for viem's `ContractFunctionExecutionError` (and the\n// other `ContractFunction*Error` subclasses it nests as a `cause`).\n// We compare by `.name` rather than `instanceof` because the paywall's\n// browser IIFE bundle ends up with multiple viem class instances\n// (esbuild inlines viem along several import chains —\n// `@bosonprotocol/x402-core`, `@bosonprotocol/x402-client-browser`,\n// wagmi, and direct paywall imports — and class identity is not\n// preserved across them). An `instanceof` check there would falsely\n// re-throw what's really a \"method not implemented\" revert. Name\n// strings are stable across bundles (viem sets them via\n// `Object.defineProperty(this, \"name\", ...)`) and plain `Error` from\n// transport failures still falls through to the rethrow path because\n// its `.name` is `\"Error\"`.\nfunction isContractFunctionError(e: unknown): boolean {\n  if (!(e instanceof Error)) return false;\n  return e.name.startsWith(\"ContractFunction\");\n}\n\n/**\n * Look up the token's EIP-712 domain. Tries EIP-5267 first (one call,\n * canonical); falls back to `name()` + `version()` (with version\n * defaulting to `\"1\"` per EIP-2612 if `version()` reverts).\n *\n * Error handling: only contract-level errors (any `ContractFunction*`\n * class viem throws via `getContractError`) are treated as \"method not\n * implemented\" and trigger the fallback. RPC / transport failures\n * (HTTP timeouts, JSON-RPC errors) propagate as-is so the caller can\n * distinguish them and surface a clear internal error rather than a\n * silent fallback that fails again on the next call. `name()` is\n * required by ERC-20 so any failure there is a real error and\n * propagates.\n *\n * Both the facilitator (recovering a signature) and the browser paywall\n * (about to sign one) call this against the same chain — keeping the\n * lookup in one place keeps signer and verifier in lockstep.\n */\nexport async function fetchTokenDomain(\n  publicClient: PublicClient,\n  token: Address,\n  chainId: number,\n): Promise<TokenEip712Domain> {\n  try {\n    const result = (await publicClient.readContract({\n      address: token,\n      abi: EIP5267_ABI,\n      functionName: \"eip712Domain\",\n    })) as readonly [Hex, string, string, bigint, Address, Hex, readonly bigint[]];\n    const hasSalt = (Number(result[0]) & EIP5267_SALT_BIT) !== 0;\n    return {\n      name: result[1],\n      version: result[2],\n      chainId: Number(result[3]),\n      verifyingContract: result[4],\n      // Only attach `salt` when the bitmask says it's part of the domain\n      // — omit the key entirely rather than emitting `salt: undefined`,\n      // so the object shape matches the optional `salt?` type and\n      // downstream `in` / key checks don't see a phantom field.\n      ...(hasSalt ? { salt: result[5] } : {}),\n    };\n  } catch (e) {\n    if (!isContractFunctionError(e)) {\n      throw e;\n    }\n    // EIP-5267 not implemented — fall back to name() + version().\n  }\n  const name = (await publicClient.readContract({\n    address: token,\n    abi: NAME_ABI,\n    functionName: \"name\",\n  })) as string;\n  let version = \"1\";\n  try {\n    version = (await publicClient.readContract({\n      address: token,\n      abi: VERSION_ABI,\n      functionName: \"version\",\n    })) as string;\n  } catch (e) {\n    if (!isContractFunctionError(e)) {\n      throw e;\n    }\n    // version() is optional per EIP-2612 — keep the default.\n  }\n  return { name, version, chainId, verifyingContract: token };\n}\n","// EIP-712 typed-data builder for EIP-2612 `Permit`.\n//\n// Hand-mirrors the standard 5-field shape\n//   Permit(address owner, address spender, uint256 value, uint256 nonce, uint256 deadline)\n// which is identical across every well-implemented EIP-2612 token.\n//\n// `@bosonprotocol/core-sdk` exposes the same type-list internally inside\n// `signReceiveWithErc2612Permit` but auto-fetches the `nonce` from the token\n// via an on-chain `nonces(owner)` call before signing. The verification path\n// needs a caller-supplied nonce (so it can rebuild the digest the buyer\n// signed without going on-chain), so this module keeps a standalone\n// typed-data builder. A KAT cross-validation test (`sdk-parity.test.ts`)\n// asserts the type-list matches the SDK's internal one, catching drift if\n// either side ever changes.\n\nimport { hashTypedData, recoverTypedDataAddress, type Address, type Hex } from \"viem\";\n\nimport type { TokenEip712Domain } from \"./domain.js\";\n\nexport const PERMIT_TYPES = {\n  Permit: [\n    { name: \"owner\", type: \"address\" },\n    { name: \"spender\", type: \"address\" },\n    { name: \"value\", type: \"uint256\" },\n    { name: \"nonce\", type: \"uint256\" },\n    { name: \"deadline\", type: \"uint256\" },\n  ],\n} as const;\n\nexport const PERMIT_PRIMARY_TYPE = \"Permit\" as const;\n\nexport interface PermitMessage {\n  owner: Address;\n  spender: Address;\n  value: bigint;\n  /** Token-internal sequential nonce — query via `IERC20Permit.nonces(owner)`. */\n  nonce: bigint;\n  deadline: bigint;\n}\n\nexport interface PermitTypedDataArgs {\n  /**\n   * The token contract's own EIP-712 domain. EIP-2612 requires\n   * `{ name, version, chainId, verifyingContract }` to produce the\n   * digest the token recovers on-chain — see {@link TokenEip712Domain}.\n   */\n  domain: TokenEip712Domain;\n  message: PermitMessage;\n}\n\nexport interface PermitTypedData {\n  domain: TokenEip712Domain;\n  types: typeof PERMIT_TYPES;\n  primaryType: typeof PERMIT_PRIMARY_TYPE;\n  message: PermitMessage;\n}\n\nexport function permitTypedData({ domain, message }: PermitTypedDataArgs): PermitTypedData {\n  return { domain, types: PERMIT_TYPES, primaryType: PERMIT_PRIMARY_TYPE, message };\n}\n\nexport function hashPermit(args: PermitTypedDataArgs): Hex {\n  return hashTypedData(permitTypedData(args));\n}\n\nexport async function recoverPermitSigner(\n  args: PermitTypedDataArgs & { signature: Hex },\n): Promise<Address> {\n  const { signature, ...rest } = args;\n  return recoverTypedDataAddress({ ...permitTypedData(rest), signature });\n}\n","// EIP-712 typed-data builder for Uniswap Permit2 `PermitTransferFrom`.\n//\n// Boson uses the no-witness `PermitTransferFrom` flavor per\n// docs/boson-impl-01-escrow-scheme.md §4.3 (the witness-bearing\n// `PermitWitnessTransferFrom` variant is for x402's exact scheme, which\n// pins the recipient inside the witness — Boson doesn't need that since\n// the escrow contract is the only valid recipient anyway).\n//\n// `@bosonprotocol/core-sdk` exposes the same type-list internally inside\n// `signReceiveWithPermit2`, but routes the Permit2 contract address through\n// `_contracts.permit2` (or `overrides.permit2Address`) on the configured\n// SDK instance. The verification path needs a stable canonical address\n// without an SDK round-trip, and the type-list is fixed by Permit2's\n// deployed contract — so this module keeps the canonical address +\n// type-list hand-defined as Uniswap protocol constants. A KAT\n// cross-validation test (`sdk-parity.test.ts`) asserts the type-list\n// matches the SDK's internal one, catching drift.\n//\n// `@x402/evm`'s public `./exact/client` exposes `createPermit2ApprovalTx`\n// and `getPermit2AllowanceReadParams` (re-exported below).\n\nimport { createPermit2ApprovalTx, getPermit2AllowanceReadParams } from \"@x402/evm/exact/client\";\nimport {\n  hashTypedData,\n  recoverTypedDataAddress,\n  type Address,\n  type Hex,\n  type TypedDataDomain,\n} from \"viem\";\n\nexport { createPermit2ApprovalTx, getPermit2AllowanceReadParams };\n\n/**\n * Canonical Permit2 contract address. Same on every EVM chain via CREATE2\n * deployment.\n *\n * @see https://github.com/Uniswap/permit2\n */\nexport const PERMIT2_ADDRESS: Address = \"0x000000000022D473030F116dDEE9F6B43aC78BA3\";\n\n/** Permit2's EIP-712 `name` field. No `version`, no `salt`. */\nexport const PERMIT2_DOMAIN_NAME = \"Permit2\" as const;\n\nexport const PERMIT2_TYPES = {\n  PermitTransferFrom: [\n    { name: \"permitted\", type: \"TokenPermissions\" },\n    { name: \"spender\", type: \"address\" },\n    { name: \"nonce\", type: \"uint256\" },\n    { name: \"deadline\", type: \"uint256\" },\n  ],\n  TokenPermissions: [\n    { name: \"token\", type: \"address\" },\n    { name: \"amount\", type: \"uint256\" },\n  ],\n} as const;\n\nexport const PERMIT2_PRIMARY_TYPE = \"PermitTransferFrom\" as const;\n\nexport interface Permit2Message {\n  permitted: { token: Address; amount: bigint };\n  spender: Address;\n  /** Permit2 word-bitmap nonce. */\n  nonce: bigint;\n  deadline: bigint;\n}\n\nexport interface Permit2TypedDataArgs {\n  chainId: number;\n  message: Permit2Message;\n}\n\nexport interface Permit2TypedData {\n  domain: TypedDataDomain;\n  types: typeof PERMIT2_TYPES;\n  primaryType: typeof PERMIT2_PRIMARY_TYPE;\n  message: Permit2Message;\n}\n\n/** Permit2's EIP-712 domain on a given chain. The `verifyingContract` is the canonical Permit2 address. */\nexport function permit2Domain(chainId: number): TypedDataDomain {\n  return { name: PERMIT2_DOMAIN_NAME, chainId, verifyingContract: PERMIT2_ADDRESS };\n}\n\nexport function permit2TypedData({ chainId, message }: Permit2TypedDataArgs): Permit2TypedData {\n  return {\n    domain: permit2Domain(chainId),\n    types: PERMIT2_TYPES,\n    primaryType: PERMIT2_PRIMARY_TYPE,\n    message,\n  };\n}\n\nexport function hashPermit2(args: Permit2TypedDataArgs): Hex {\n  return hashTypedData(permit2TypedData(args));\n}\n\nexport async function recoverPermit2Signer(\n  args: Permit2TypedDataArgs & { signature: Hex },\n): Promise<Address> {\n  const { signature, ...rest } = args;\n  return recoverTypedDataAddress({ ...permit2TypedData(rest), signature });\n}\n","// Helper for the `tokenAuthStrategy: \"none\"` flow (per\n// docs/boson-impl-01-escrow-scheme.md §4.3): the buyer must pre-approve\n// the Boson escrow contract to spend `amount` of `token` via the standard\n// ERC-20 `approve(spender, amount)` call.\n//\n// No EIP-712 typed-data is signed for this strategy; the buyer instead\n// sends a regular ERC-20 transaction. This module just builds the calldata\n// so callers can hand it to a wallet client.\n\nimport { encodeFunctionData, type Address, type Hex } from \"viem\";\n\nconst ERC20_APPROVE_ABI = [\n  {\n    type: \"function\",\n    name: \"approve\",\n    stateMutability: \"nonpayable\",\n    inputs: [\n      { name: \"spender\", type: \"address\" },\n      { name: \"amount\", type: \"uint256\" },\n    ],\n    outputs: [{ type: \"bool\" }],\n  },\n] as const;\n\nexport interface Erc20ApprovalArgs {\n  token: Address;\n  spender: Address;\n  amount: bigint;\n}\n\n/**\n * Build calldata for an ERC-20 `approve(spender, amount)` call. Use with\n * `walletClient.sendTransaction({ to: token, data })` or any equivalent\n * signer to grant `spender` (the Boson escrow contract) the right to\n * pull `amount` of `token`.\n */\nexport function createErc20ApprovalTx({ token, spender, amount }: Erc20ApprovalArgs): {\n  to: Address;\n  data: Hex;\n} {\n  return {\n    to: token,\n    data: encodeFunctionData({\n      abi: ERC20_APPROVE_ABI,\n      functionName: \"approve\",\n      args: [spender, amount],\n    }),\n  };\n}\n"]}

package/dist/cjs/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Custom header `@bosonprotocol/x402-client-fetch` stamps on both the
+ * initial request and the X-PAYMENT retry. Resource servers that scope
+ * their `FullOffer` cache per buyer flow key the cache off this id so
+ * the 402 challenge and the X-PAYMENT retry share one signed offer.
+ *
+ * The canonical value uses mixed case for header readability; HTTP
+ * header lookups are case-insensitive on both Node (`req.headers[…]`
+ * are already lowercased) and Express (`req.header(…)`), so importers
+ * can pass the constant verbatim regardless of which lookup style they
+ * use.
+ */
+declare const SESSION_ID_HEADER = "X-X402-Boson-Session-Id";
+
+export { SESSION_ID_HEADER };

package/dist/cjs/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// src/headers.ts
+var SESSION_ID_HEADER = "X-X402-Boson-Session-Id";
+
+exports.SESSION_ID_HEADER = SESSION_ID_HEADER;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/headers.ts"],"names":[],"mappings":";;;AAiBO,IAAM,iBAAA,GAAoB","file":"index.js","sourcesContent":["// Shared HTTP header names that span the buyer-side fetch wrapper and\n// any resource server / facilitator implementing the x402B escrow\n// scheme. Centralising them here keeps the wire contract single-sourced\n// across packages.\n\n/**\n * Custom header `@bosonprotocol/x402-client-fetch` stamps on both the\n * initial request and the X-PAYMENT retry. Resource servers that scope\n * their `FullOffer` cache per buyer flow key the cache off this id so\n * the 402 challenge and the X-PAYMENT retry share one signed offer.\n *\n * The canonical value uses mixed case for header readability; HTTP\n * header lookups are case-insensitive on both Node (`req.headers[…]`\n * are already lowercased) and Express (`req.header(…)`), so importers\n * can pass the constant verbatim regardless of which lookup style they\n * use.\n */\nexport const SESSION_ID_HEADER = \"X-X402-Boson-Session-Id\";\n"]}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}