@402lane/core 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# @402lane/core
+
+Protocol types, header codecs, network config, and EIP-3009 typed data for
+[402LANE](https://402lane.vercel.app) — the x402 agent-payments toolkit for the
+Robinhood Chain (USDG, chain 4663).
+
+Ships the x402 v2 wire types (`exact` scheme), base64-JSON `PAYMENT-*` header
+encode/decode, the Robinhood Chain mainnet (`eip155:4663`) and testnet (`eip155:46630`)
+network config with USDG addresses, and the `TransferWithAuthorization`
+EIP-712 typed-data helpers.
+
+```ts
+import { getNetwork, encodeHeader, toBaseUnits } from "@402lane/core";
+const net = getNetwork("eip155:4663");   // USDG, 6 decimals, EIP-712 domain
+toBaseUnits("0.001");                    // "1000"
+```
+
+Used by `@402lane/facilitator`, `@402lane/middleware`, and `@402lane/client`.
+See the [docs](https://402lane.vercel.app/docs). MIT.

package/dist/amount.d.ts

@@ -0,0 +1,4 @@
+/** Convert a decimal USDG string (e.g. "0.001") to base units (6 decimals). */
+export declare function toBaseUnits(amount: string, decimals?: number): string;
+/** Format base units back to a decimal string for display. */
+export declare function fromBaseUnits(base: string | bigint, decimals?: number): string;

package/dist/amount.js

@@ -0,0 +1,20 @@
+/** Convert a decimal USDG string (e.g. "0.001") to base units (6 decimals). */
+export function toBaseUnits(amount, decimals = 6) {
+    const m = amount.trim().match(/^(\d+)(?:\.(\d+))?$/);
+    if (!m)
+        throw new Error(`402LANE: invalid amount "${amount}"`);
+    const [, whole, fracRaw = ""] = m;
+    if (fracRaw.length > decimals) {
+        throw new Error(`402LANE: amount "${amount}" exceeds ${decimals} decimal places`);
+    }
+    const frac = fracRaw.padEnd(decimals, "0");
+    return (BigInt(whole) * 10n ** BigInt(decimals) + BigInt(frac)).toString();
+}
+/** Format base units back to a decimal string for display. */
+export function fromBaseUnits(base, decimals = 6) {
+    const b = BigInt(base);
+    const div = 10n ** BigInt(decimals);
+    const whole = b / div;
+    const frac = (b % div).toString().padStart(decimals, "0").replace(/0+$/, "");
+    return frac ? `${whole}.${frac}` : whole.toString();
+}

package/dist/eip3009.d.ts

@@ -0,0 +1,93 @@
+import type { TypedDataDomain } from "viem";
+import type { Eip3009Authorization } from "./protocol.js";
+export declare const TRANSFER_WITH_AUTHORIZATION_TYPES: {
+    readonly TransferWithAuthorization: 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";
+    }];
+};
+export declare function eip3009Domain(networkCaip2: string): TypedDataDomain;
+/** Typed-data message from a wire authorization (string ints → bigint). */
+export declare function toTypedMessage(auth: Eip3009Authorization): {
+    from: `0x${string}`;
+    to: `0x${string}`;
+    value: bigint;
+    validAfter: bigint;
+    validBefore: bigint;
+    nonce: `0x${string}`;
+};
+/** Minimal ABI surface of USDG needed by the facilitator. */
+export declare const EIP3009_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "authorizationState";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "authorizer";
+        readonly type: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "transferWithAuthorization";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: 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";
+    }, {
+        readonly name: "v";
+        readonly type: "uint8";
+    }, {
+        readonly name: "r";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "s";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [];
+}];

package/dist/eip3009.js

@@ -0,0 +1,68 @@
+import { getNetwork } from "./networks.js";
+export const TRANSFER_WITH_AUTHORIZATION_TYPES = {
+    TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" },
+    ],
+};
+export function eip3009Domain(networkCaip2) {
+    const net = getNetwork(networkCaip2);
+    return {
+        name: net.eip712.name,
+        version: net.eip712.version,
+        chainId: net.chain.id,
+        verifyingContract: net.asset,
+    };
+}
+/** Typed-data message from a wire authorization (string ints → bigint). */
+export function toTypedMessage(auth) {
+    return {
+        from: auth.from,
+        to: auth.to,
+        value: BigInt(auth.value),
+        validAfter: BigInt(auth.validAfter),
+        validBefore: BigInt(auth.validBefore),
+        nonce: auth.nonce,
+    };
+}
+/** Minimal ABI surface of USDG needed by the facilitator. */
+export const EIP3009_ABI = [
+    {
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [{ name: "account", type: "address" }],
+        outputs: [{ type: "uint256" }],
+    },
+    {
+        type: "function",
+        name: "authorizationState",
+        stateMutability: "view",
+        inputs: [
+            { name: "authorizer", type: "address" },
+            { name: "nonce", type: "bytes32" },
+        ],
+        outputs: [{ type: "bool" }],
+    },
+    {
+        type: "function",
+        name: "transferWithAuthorization",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "from", type: "address" },
+            { name: "to", type: "address" },
+            { name: "value", type: "uint256" },
+            { name: "validAfter", type: "uint256" },
+            { name: "validBefore", type: "uint256" },
+            { name: "nonce", type: "bytes32" },
+            { name: "v", type: "uint8" },
+            { name: "r", type: "bytes32" },
+            { name: "s", type: "bytes32" },
+        ],
+        outputs: [],
+    },
+];

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./networks.js";
+export * from "./protocol.js";
+export * from "./eip3009.js";
+export * from "./amount.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./networks.js";
+export * from "./protocol.js";
+export * from "./eip3009.js";
+export * from "./amount.js";

package/dist/networks.d.ts

@@ -0,0 +1,120 @@
+import { type Chain } from "viem";
+/** CAIP-2 network identifiers serviced by 402LANE (Robinhood Chain). */
+export declare const RH_MAINNET_CAIP2: "eip155:4663";
+export declare const RH_TESTNET_CAIP2: "eip155:46630";
+export type SupportedNetwork = typeof RH_MAINNET_CAIP2 | typeof RH_TESTNET_CAIP2;
+export interface NetworkConfig {
+    caip2: SupportedNetwork;
+    chain: Chain;
+    /** USDG (Global Dollar) — the EIP-3009 settlement token. Gas is ETH. */
+    asset: `0x${string}`;
+    /** EIP-712 domain for EIP-3009 signatures over USDG. */
+    eip712: {
+        name: string;
+        version: string;
+    };
+    decimals: number;
+    explorerTx: (hash: string) => string;
+}
+export declare const robinhoodMainnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Blockscout";
+            readonly url: "https://robinhoodchain.blockscout.com";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 4663;
+    name: "Robinhood Chain";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+export declare const robinhoodTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Blockscout";
+            readonly url: "https://explorer.testnet.chain.robinhood.com";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 46630;
+    name: "Robinhood Chain Testnet";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.testnet.chain.robinhood.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+export declare const NETWORKS: Record<SupportedNetwork, NetworkConfig>;
+export declare function getNetwork(caip2: string): NetworkConfig;

package/dist/networks.js

@@ -0,0 +1,56 @@
+import { defineChain } from "viem";
+/** CAIP-2 network identifiers serviced by 402LANE (Robinhood Chain). */
+export const RH_MAINNET_CAIP2 = "eip155:4663";
+export const RH_TESTNET_CAIP2 = "eip155:46630";
+// Robinhood Chain is an Arbitrum Orbit (Nitro) L2. Gas is paid in ETH;
+// USDG is a normal ERC-20 that implements EIP-3009 transferWithAuthorization.
+export const robinhoodMainnet = defineChain({
+    id: 4663,
+    name: "Robinhood Chain",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },
+    blockExplorers: {
+        default: { name: "Blockscout", url: "https://robinhoodchain.blockscout.com" },
+    },
+});
+export const robinhoodTestnet = defineChain({
+    id: 46630,
+    name: "Robinhood Chain Testnet",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: ["https://rpc.testnet.chain.robinhood.com"] } },
+    blockExplorers: {
+        default: {
+            name: "Blockscout",
+            url: "https://explorer.testnet.chain.robinhood.com",
+        },
+    },
+    testnet: true,
+});
+export const NETWORKS = {
+    [RH_MAINNET_CAIP2]: {
+        caip2: RH_MAINNET_CAIP2,
+        chain: robinhoodMainnet,
+        // USDG on Robinhood Chain (Paxos Global Dollar). EIP-712 domain verified
+        // against the live on-chain DOMAIN_SEPARATOR.
+        asset: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+        eip712: { name: "Global Dollar", version: "1" },
+        decimals: 6,
+        explorerTx: (h) => `https://robinhoodchain.blockscout.com/tx/${h}`,
+    },
+    [RH_TESTNET_CAIP2]: {
+        caip2: RH_TESTNET_CAIP2,
+        chain: robinhoodTestnet,
+        // TODO: USDG testnet contract address (not yet pinned). Mainnet is the
+        // supported target; testnet requires the deployed USDG testnet address.
+        asset: "0x0000000000000000000000000000000000000000",
+        eip712: { name: "Global Dollar", version: "1" },
+        decimals: 6,
+        explorerTx: (h) => `https://explorer.testnet.chain.robinhood.com/tx/${h}`,
+    },
+};
+export function getNetwork(caip2) {
+    const cfg = NETWORKS[caip2];
+    if (!cfg)
+        throw new Error(`402LANE: unsupported network "${caip2}"`);
+    return cfg;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,276 @@
+import { z } from "zod";
+/** x402 v2 wire types (exact scheme, EVM / EIP-3009). */
+export declare const X402_VERSION = 2;
+/** HTTP headers used by the protocol. Values are base64-encoded JSON. */
+export declare const HEADER_PAYMENT_REQUIRED = "payment-required";
+export declare const HEADER_PAYMENT_SIGNATURE = "payment-signature";
+export declare const HEADER_PAYMENT_RESPONSE = "payment-response";
+export declare const paymentRequirementsSchema: z.ZodObject<{
+    scheme: z.ZodLiteral<"exact">;
+    network: z.ZodString;
+    asset: z.ZodString;
+    payTo: z.ZodString;
+    /** Amount in base units of the asset (string integer). */
+    maxAmountRequired: z.ZodString;
+    resource: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    maxTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    extra: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        decimals: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+        decimals: number;
+    }, {
+        name: string;
+        version: string;
+        decimals: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    scheme: "exact";
+    network: string;
+    asset: string;
+    payTo: string;
+    maxAmountRequired: string;
+    resource: string;
+    maxTimeoutSeconds: number;
+    extra?: {
+        name: string;
+        version: string;
+        decimals: number;
+    } | undefined;
+}, {
+    scheme: "exact";
+    network: string;
+    asset: string;
+    payTo: string;
+    maxAmountRequired: string;
+    resource: string;
+    description?: string | undefined;
+    maxTimeoutSeconds?: number | undefined;
+    extra?: {
+        name: string;
+        version: string;
+        decimals: number;
+    } | undefined;
+}>;
+export type PaymentRequirements = z.infer<typeof paymentRequirementsSchema>;
+export declare const paymentRequiredBodySchema: z.ZodObject<{
+    x402Version: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+    accepts: z.ZodArray<z.ZodObject<{
+        scheme: z.ZodLiteral<"exact">;
+        network: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+        /** Amount in base units of the asset (string integer). */
+        maxAmountRequired: z.ZodString;
+        resource: z.ZodString;
+        description: z.ZodDefault<z.ZodString>;
+        maxTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        extra: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            version: string;
+            decimals: number;
+        }, {
+            name: string;
+            version: string;
+            decimals: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        scheme: "exact";
+        network: string;
+        asset: string;
+        payTo: string;
+        maxAmountRequired: string;
+        resource: string;
+        maxTimeoutSeconds: number;
+        extra?: {
+            name: string;
+            version: string;
+            decimals: number;
+        } | undefined;
+    }, {
+        scheme: "exact";
+        network: string;
+        asset: string;
+        payTo: string;
+        maxAmountRequired: string;
+        resource: string;
+        description?: string | undefined;
+        maxTimeoutSeconds?: number | undefined;
+        extra?: {
+            name: string;
+            version: string;
+            decimals: number;
+        } | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    x402Version: number;
+    accepts: {
+        description: string;
+        scheme: "exact";
+        network: string;
+        asset: string;
+        payTo: string;
+        maxAmountRequired: string;
+        resource: string;
+        maxTimeoutSeconds: number;
+        extra?: {
+            name: string;
+            version: string;
+            decimals: number;
+        } | undefined;
+    }[];
+    error?: string | undefined;
+}, {
+    x402Version: number;
+    accepts: {
+        scheme: "exact";
+        network: string;
+        asset: string;
+        payTo: string;
+        maxAmountRequired: string;
+        resource: string;
+        description?: string | undefined;
+        maxTimeoutSeconds?: number | undefined;
+        extra?: {
+            name: string;
+            version: string;
+            decimals: number;
+        } | undefined;
+    }[];
+    error?: string | undefined;
+}>;
+export type PaymentRequiredBody = z.infer<typeof paymentRequiredBodySchema>;
+export declare const authorizationSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    value: z.ZodString;
+    validAfter: z.ZodString;
+    validBefore: z.ZodString;
+    nonce: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    from: string;
+    nonce: string;
+    to: string;
+    value: string;
+    validAfter: string;
+    validBefore: string;
+}, {
+    from: string;
+    nonce: string;
+    to: string;
+    value: string;
+    validAfter: string;
+    validBefore: string;
+}>;
+export type Eip3009Authorization = z.infer<typeof authorizationSchema>;
+export declare const paymentPayloadSchema: z.ZodObject<{
+    x402Version: z.ZodNumber;
+    scheme: z.ZodLiteral<"exact">;
+    network: z.ZodString;
+    payload: z.ZodObject<{
+        authorization: z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            value: z.ZodString;
+            validAfter: z.ZodString;
+            validBefore: z.ZodString;
+            nonce: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            nonce: string;
+            to: string;
+            value: string;
+            validAfter: string;
+            validBefore: string;
+        }, {
+            from: string;
+            nonce: string;
+            to: string;
+            value: string;
+            validAfter: string;
+            validBefore: string;
+        }>;
+        signature: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        authorization: {
+            from: string;
+            nonce: string;
+            to: string;
+            value: string;
+            validAfter: string;
+            validBefore: string;
+        };
+        signature: string;
+    }, {
+        authorization: {
+            from: string;
+            nonce: string;
+            to: string;
+            value: string;
+            validAfter: string;
+            validBefore: string;
+        };
+        signature: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    scheme: "exact";
+    network: string;
+    x402Version: number;
+    payload: {
+        authorization: {
+            from: string;
+            nonce: string;
+            to: string;
+            value: string;
+            validAfter: string;
+            validBefore: string;
+        };
+        signature: string;
+    };
+}, {
+    scheme: "exact";
+    network: string;
+    x402Version: number;
+    payload: {
+        authorization: {
+            from: string;
+            nonce: string;
+            to: string;
+            value: string;
+            validAfter: string;
+            validBefore: string;
+        };
+        signature: string;
+    };
+}>;
+export type PaymentPayload = z.infer<typeof paymentPayloadSchema>;
+export interface VerifyRequest {
+    paymentPayload: PaymentPayload;
+    paymentRequirements: PaymentRequirements;
+}
+export interface VerifyResponse {
+    isValid: boolean;
+    invalidReason?: string;
+    payer?: `0x${string}`;
+}
+export interface SettleResponse {
+    success: boolean;
+    errorReason?: string;
+    transaction?: `0x${string}`;
+    network: string;
+    payer?: `0x${string}`;
+}
+/** base64(JSON) codecs used for all PAYMENT-* headers. */
+export declare function encodeHeader(value: unknown): string;
+export declare function decodeHeader<S extends z.ZodTypeAny>(raw: string, schema: S): z.output<S>;

package/dist/protocol.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+/** x402 v2 wire types (exact scheme, EVM / EIP-3009). */
+export const X402_VERSION = 2;
+/** HTTP headers used by the protocol. Values are base64-encoded JSON. */
+export const HEADER_PAYMENT_REQUIRED = "payment-required";
+export const HEADER_PAYMENT_SIGNATURE = "payment-signature";
+export const HEADER_PAYMENT_RESPONSE = "payment-response";
+const hex = /^0x[0-9a-fA-F]+$/;
+const address = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+export const paymentRequirementsSchema = z.object({
+    scheme: z.literal("exact"),
+    network: z.string(),
+    asset: address,
+    payTo: address,
+    /** Amount in base units of the asset (string integer). */
+    maxAmountRequired: z.string().regex(/^\d+$/),
+    resource: z.string(),
+    description: z.string().default(""),
+    maxTimeoutSeconds: z.number().int().positive().default(300),
+    extra: z
+        .object({
+        name: z.string(),
+        version: z.string(),
+        decimals: z.number().int(),
+    })
+        .optional(),
+});
+export const paymentRequiredBodySchema = z.object({
+    x402Version: z.number(),
+    error: z.string().optional(),
+    accepts: z.array(paymentRequirementsSchema).min(1),
+});
+export const authorizationSchema = z.object({
+    from: address,
+    to: address,
+    value: z.string().regex(/^\d+$/),
+    validAfter: z.string().regex(/^\d+$/),
+    validBefore: z.string().regex(/^\d+$/),
+    nonce: z.string().regex(/^0x[0-9a-fA-F]{64}$/),
+});
+export const paymentPayloadSchema = z.object({
+    x402Version: z.number(),
+    scheme: z.literal("exact"),
+    network: z.string(),
+    payload: z.object({
+        authorization: authorizationSchema,
+        signature: z.string().regex(hex),
+    }),
+});
+/** base64(JSON) codecs used for all PAYMENT-* headers. */
+export function encodeHeader(value) {
+    return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+}
+export function decodeHeader(raw, schema) {
+    const json = JSON.parse(Buffer.from(raw, "base64").toString("utf8"));
+    return schema.parse(json);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@402lane/core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test dist/test/"
+  },
+  "dependencies": {
+    "viem": "^2.21.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "@types/node": "^22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oggyfoxy/lane402"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}