@faremeter/payment-evm 0.10.1 → 0.10.2

package/dist/src/exact/client.d.ts

@@ -0,0 +1,24 @@
+import type { PaymentHandler } from "@faremeter/types/client";
+import { type AssetNameOrContractInfo } from "@faremeter/info/evm";
+import type { Hex } from "viem";
+interface WalletForPayment {
+    chain: {
+        id: number;
+        name: string;
+    };
+    address: Hex;
+    account: {
+        signTypedData: (params: {
+            domain: Record<string, unknown>;
+            types: Record<string, unknown>;
+            primaryType: string;
+            message: Record<string, unknown>;
+        }) => Promise<Hex>;
+    };
+}
+export type CreatePaymentHandlerOpts = {
+    asset?: AssetNameOrContractInfo;
+};
+export declare function createPaymentHandler(wallet: WalletForPayment, opts?: CreatePaymentHandlerOpts): PaymentHandler;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/src/exact/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/exact/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAWhC,UAAU,gBAAgB;IACxB,KAAK,EAAE;QACL,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,OAAO,EAAE,GAAG,CAAC;IACb,OAAO,EAAE;QACP,aAAa,EAAE,CAAC,MAAM,EAAE;YACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC/B,WAAW,EAAE,MAAM,CAAC;YACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;SAClC,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;KACpB,CAAC;CACH;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,gBAAgB,EACxB,IAAI,GAAE,wBAA6B,GAClC,cAAc,CAkGhB"}

package/dist/src/exact/client.js

@@ -0,0 +1,81 @@
+import { randomBytes } from "crypto";
+import { lookupX402Network, findAssetInfo, } from "@faremeter/info/evm";
+import { isAddress } from "viem";
+import { type } from "arktype";
+import { X402_EXACT_SCHEME, EIP712_TYPES, eip712Domain, } from "./constants.js";
+export function createPaymentHandler(wallet, opts = {}) {
+    const x402Network = lookupX402Network(wallet.chain.id);
+    const assetInfo = findAssetInfo(x402Network, opts.asset ?? "USDC");
+    if (!assetInfo) {
+        throw new Error(`Couldn't look up USDC information on network '${x402Network}'`);
+    }
+    return async function handlePayment(context, accepts) {
+        const compatibleRequirements = accepts.filter((req) => req.scheme === X402_EXACT_SCHEME && req.network === x402Network);
+        return compatibleRequirements.map((requirements) => ({
+            requirements,
+            exec: async () => {
+                if (!isAddress(requirements.payTo)) {
+                    throw new Error(`Invalid payTo address: ${requirements.payTo}`);
+                }
+                const payToAddress = requirements.payTo;
+                // Generate nonce for EIP-3009 authorization (32 bytes hex with 0x prefix)
+                const nonce = `0x${randomBytes(32).toString("hex")}`;
+                const now = Math.floor(Date.now() / 1000);
+                const validAfter = now - 60; // Valid from 60 seconds ago
+                const validBefore = now + requirements.maxTimeoutSeconds;
+                // Create the authorization parameters for EIP-3009
+                const authorization = {
+                    from: wallet.address,
+                    to: payToAddress,
+                    value: requirements.maxAmountRequired, // String value of amount
+                    validAfter: validAfter.toString(),
+                    validBefore: validBefore.toString(),
+                    nonce: nonce,
+                };
+                // Validate and extract EIP-712 domain parameters from requirements.extra
+                const extraResult = eip712Domain(requirements.extra ?? {});
+                if (extraResult instanceof type.errors) {
+                    throw new Error(`Invalid EIP-712 domain parameters: ${extraResult.summary}`);
+                }
+                const verifyingContract = extraResult.verifyingContract ??
+                    requirements.asset ??
+                    assetInfo.address;
+                if (!isAddress(verifyingContract)) {
+                    throw new Error(`Invalid verifying contract: ${verifyingContract}`);
+                }
+                const domain = {
+                    name: extraResult.name ?? assetInfo.contractName,
+                    version: extraResult.version ?? "2",
+                    chainId: extraResult.chainId ?? wallet.chain.id,
+                    verifyingContract,
+                };
+                const types = EIP712_TYPES;
+                // Message for EIP-712 signing (using BigInt for signing)
+                const message = {
+                    from: wallet.address,
+                    to: payToAddress,
+                    value: BigInt(requirements.maxAmountRequired),
+                    validAfter: BigInt(validAfter),
+                    validBefore: BigInt(validBefore),
+                    nonce: nonce,
+                };
+                // Sign the EIP-712 typed data
+                const signature = await wallet.account.signTypedData({
+                    domain,
+                    types,
+                    primaryType: "TransferWithAuthorization",
+                    message,
+                });
+                // Create the x402 exact scheme payload
+                const payload = {
+                    signature: signature,
+                    authorization: authorization,
+                };
+                // Return the EIP-3009 authorization payload
+                return {
+                    payload,
+                };
+            },
+        }));
+    };
+}

package/dist/src/exact/common.d.ts

@@ -0,0 +1,18 @@
+import type { PublicClient, Hex } from "viem";
+export declare function generateDomain(publicClient: PublicClient, chainId: number, asset: Hex): Promise<{
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: `0x${string}`;
+}>;
+export declare function generateForwarderDomain(chainId: number, domainInfo: {
+    version: string;
+    name: string;
+    verifyingContract: `0x${string}`;
+}): {
+    chainId: number;
+    version: string;
+    name: string;
+    verifyingContract: `0x${string}`;
+};
+//# sourceMappingURL=common.d.ts.map

package/dist/src/exact/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/exact/common.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAI9C,wBAAsB,cAAc,CAClC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,GAAG;;;;;GA8BX;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,KAAK,MAAM,EAAE,CAAC;CAClC;;aAHU,MAAM;UACT,MAAM;uBACO,KAAK,MAAM,EAAE;EAOnC"}

package/dist/src/exact/common.js

@@ -0,0 +1,36 @@
+import { TRANSFER_WITH_AUTHORIZATION_ABI } from "./constants.js";
+export async function generateDomain(publicClient, chainId, asset) {
+    // Read domain parameters from chain
+    let tokenName;
+    let tokenVersion;
+    try {
+        [tokenName, tokenVersion] = await Promise.all([
+            publicClient.readContract({
+                address: asset,
+                abi: TRANSFER_WITH_AUTHORIZATION_ABI,
+                functionName: "name",
+            }),
+            publicClient.readContract({
+                address: asset,
+                abi: TRANSFER_WITH_AUTHORIZATION_ABI,
+                functionName: "version",
+            }),
+        ]);
+    }
+    catch (cause) {
+        throw new Error("Failed to read contract parameters", { cause });
+    }
+    const domain = {
+        name: tokenName,
+        version: tokenVersion,
+        chainId,
+        verifyingContract: asset,
+    };
+    return domain;
+}
+export function generateForwarderDomain(chainId, domainInfo) {
+    return {
+        ...domainInfo,
+        chainId,
+    };
+}

package/dist/src/exact/constants.d.ts

@@ -0,0 +1,119 @@
+export declare const X402_EXACT_SCHEME = "exact";
+export declare const TRANSFER_WITH_AUTHORIZATION_ABI: readonly [{
+    readonly name: "transferWithAuthorization";
+    readonly type: "function";
+    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 [];
+}, {
+    readonly name: "authorizationState";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "authorizer";
+        readonly type: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "name";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly name: "version";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly name: "DOMAIN_SEPARATOR";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+}];
+export declare const EIP712_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 const x402ExactPayload: import("arktype/internal/methods/object.ts").ObjectType<{
+    signature: (In: string) => import("arktype").Out<`0x${string}`>;
+    authorization: {
+        from: (In: string) => import("arktype").Out<`0x${string}`>;
+        to: (In: string) => import("arktype").Out<`0x${string}`>;
+        value: string;
+        validAfter: string;
+        validBefore: string;
+        nonce: (In: string) => import("arktype").Out<`0x${string}`>;
+    };
+}, {}>;
+export type x402ExactPayload = typeof x402ExactPayload.infer;
+export type eip3009Authorization = x402ExactPayload["authorization"];
+export declare const eip712Domain: import("arktype/internal/methods/object.ts").ObjectType<{
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: string;
+}, {}>;
+export type eip712Domain = typeof eip712Domain.infer;
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/exact/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/exact/constants.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,iBAAiB,UAAU,CAAC;AAEzC,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDlC,CAAC;AAEX,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;CASf,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;;;;;;MAU3B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,KAAK,CAAC;AAC7D,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,CAAC,eAAe,CAAC,CAAC;AAErE,eAAO,MAAM,YAAY;;;;;MAKvB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,KAAK,CAAC"}

package/dist/src/exact/constants.js

@@ -0,0 +1,86 @@
+import { type } from "arktype";
+import { toHex, isHex } from "viem";
+const prefixedHexString = type("string").pipe.try((x) => {
+    if (isHex(x)) {
+        return x;
+    }
+    return toHex(x);
+});
+export const X402_EXACT_SCHEME = "exact";
+export const TRANSFER_WITH_AUTHORIZATION_ABI = [
+    {
+        name: "transferWithAuthorization",
+        type: "function",
+        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: [],
+    },
+    {
+        name: "authorizationState",
+        type: "function",
+        stateMutability: "view",
+        inputs: [
+            { name: "authorizer", type: "address" },
+            { name: "nonce", type: "bytes32" },
+        ],
+        outputs: [{ name: "", type: "bool" }],
+    },
+    {
+        name: "name",
+        type: "function",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ name: "", type: "string" }],
+    },
+    {
+        name: "version",
+        type: "function",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ name: "", type: "string" }],
+    },
+    {
+        name: "DOMAIN_SEPARATOR",
+        type: "function",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ name: "", type: "bytes32" }],
+    },
+];
+export const EIP712_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 const x402ExactPayload = type({
+    signature: prefixedHexString,
+    authorization: {
+        from: prefixedHexString,
+        to: prefixedHexString,
+        value: "string",
+        validAfter: "string",
+        validBefore: "string",
+        nonce: prefixedHexString,
+    },
+});
+export const eip712Domain = type({
+    "name?": "string",
+    "version?": "string",
+    "chainId?": "number",
+    "verifyingContract?": "string",
+});

package/dist/src/exact/facilitator.d.ts

@@ -0,0 +1,10 @@
+import { type FacilitatorHandler } from "@faremeter/types/facilitator";
+import type { Chain, Transport } from "viem";
+import { type KnownX402Network, type AssetNameOrContractInfo } from "@faremeter/info/evm";
+type CreateFacilitatorHandlerOpts = {
+    network?: KnownX402Network;
+    transport?: Transport;
+};
+export declare function createFacilitatorHandler(chain: Chain, privateKey: string, assetNameOrInfo: AssetNameOrContractInfo, opts?: CreateFacilitatorHandlerOpts): Promise<FacilitatorHandler>;
+export {};
+//# sourceMappingURL=facilitator.d.ts.map

package/dist/src/exact/facilitator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facilitator.d.ts","sourceRoot":"","sources":["../../../src/exact/facilitator.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,OAAO,KAAK,EAAgB,KAAK,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAY3D,OAAO,EAEL,KAAK,gBAAgB,EAErB,KAAK,uBAAuB,EAC7B,MAAM,qBAAqB,CAAC;AA8B7B,KAAK,4BAA4B,GAAG;IAClC,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AACF,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,uBAAuB,EACxC,IAAI,GAAE,4BAAiC,GACtC,OAAO,CAAC,kBAAkB,CAAC,CA+S7B"}

package/dist/src/exact/facilitator.js

@@ -0,0 +1,267 @@
+import { isValidationError, caseInsensitiveLiteral } from "@faremeter/types";
+import { isPrivateKey } from "@faremeter/types/evm";
+import {} from "@faremeter/types/facilitator";
+import { type } from "arktype";
+import { createPublicClient, createWalletClient, http, verifyTypedData, encodeFunctionData, isAddress, } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { lookupX402Network, findAssetInfo, } from "@faremeter/info/evm";
+import { X402_EXACT_SCHEME, TRANSFER_WITH_AUTHORIZATION_ABI, EIP712_TYPES, x402ExactPayload, } from "./constants.js";
+import { generateDomain, generateForwarderDomain } from "./common.js";
+function errorResponse(msg) {
+    return {
+        success: false,
+        error: msg,
+        txHash: null,
+        networkId: null,
+    };
+}
+const usedNonces = new Set();
+function parseSignature(signature) {
+    const sig = signature.slice(2); // Remove 0x
+    const r = `0x${sig.slice(0, 64)}`;
+    const s = `0x${sig.slice(64, 128)}`;
+    const v = parseInt(sig.slice(128, 130), 16);
+    return { v, r, s };
+}
+export async function createFacilitatorHandler(chain, privateKey, assetNameOrInfo, opts = {}) {
+    if (!isPrivateKey(privateKey)) {
+        throw new Error(`Invalid private key: ${privateKey}`);
+    }
+    const network = opts.network ?? lookupX402Network(chain.id);
+    const chainId = chain.id;
+    const assetInfo = findAssetInfo(network, assetNameOrInfo);
+    const asset = assetInfo.address;
+    const useForwarder = assetInfo.forwarder !== undefined && assetInfo.forwarderName !== undefined;
+    if (!isAddress(asset)) {
+        throw new Error(`Invalid asset address: ${asset}`);
+    }
+    const transport = opts.transport ?? http(chain.rpcUrls.default.http[0]);
+    const account = privateKeyToAccount(privateKey);
+    const publicClient = createPublicClient({
+        chain,
+        transport,
+    });
+    const walletClient = createWalletClient({
+        account,
+        chain,
+        transport,
+    });
+    let domain;
+    if (useForwarder) {
+        if (!assetInfo.forwarder) {
+            throw new Error("Missing Forwarding Contract");
+        }
+        if (!assetInfo.forwarderVersion) {
+            throw new Error("Missing Forwarding Version");
+        }
+        if (!assetInfo.forwarderName) {
+            throw new Error("Missing Forwarding Name");
+        }
+        domain = generateForwarderDomain(chainId, {
+            version: assetInfo.forwarderVersion,
+            name: assetInfo.forwarderName,
+            verifyingContract: assetInfo.forwarder,
+        });
+    }
+    else {
+        domain = await generateDomain(publicClient, chainId, asset);
+        if (domain.name != assetInfo.contractName) {
+            throw new Error(`On chain contract name (${domain.name}) doesn't match configured asset name (${assetInfo.contractName})`);
+        }
+    }
+    const checkTuple = type({
+        scheme: caseInsensitiveLiteral(X402_EXACT_SCHEME),
+        network: caseInsensitiveLiteral(network),
+    });
+    const checkTupleAndAsset = checkTuple.and({
+        asset: caseInsensitiveLiteral(asset),
+    });
+    const getSupported = () => {
+        return [
+            Promise.resolve({
+                x402Version: 1,
+                network,
+                scheme: X402_EXACT_SCHEME,
+            }),
+        ];
+    };
+    const getRequirements = async (req) => {
+        return req
+            .filter((x) => !isValidationError(checkTupleAndAsset(x)))
+            .map((x) => ({
+            ...x,
+            asset,
+            maxTimeoutSeconds: 300,
+            // Provide EIP-712 domain parameters for client signing
+            extra: {
+                name: useForwarder ? assetInfo.forwarderName : assetInfo.contractName,
+                version: useForwarder ? assetInfo.forwarderVersion : "2",
+                chainId,
+                verifyingContract: useForwarder ? assetInfo.forwarder : asset,
+            },
+        }));
+    };
+    const handleSettle = async (requirements, payment) => {
+        const tupleMatches = checkTuple(payment);
+        if (isValidationError(tupleMatches)) {
+            return null; // Not for us, let another handler try
+        }
+        // For the exact scheme with EIP-3009, validate the authorization payload
+        const payloadResult = x402ExactPayload(payment.payload);
+        if (payloadResult instanceof type.errors) {
+            return errorResponse(`Invalid payload: ${payloadResult.summary}`);
+        }
+        const { authorization, signature } = payloadResult;
+        // Check if the payment is to the correct address
+        if (authorization.to.toLowerCase() !== requirements.payTo.toLowerCase()) {
+            return errorResponse("Payment authorized to wrong address");
+        }
+        // Check if the amount matches
+        if (authorization.value !== requirements.maxAmountRequired) {
+            return errorResponse("Incorrect payment amount");
+        }
+        // Check if the authorization is still valid (time-wise)
+        const now = Math.floor(Date.now() / 1000);
+        const validAfter = parseInt(authorization.validAfter);
+        const validBefore = parseInt(authorization.validBefore);
+        if (now < validAfter) {
+            return errorResponse("Authorization not yet valid");
+        }
+        if (now > validBefore) {
+            return errorResponse("Authorization expired");
+        }
+        // Verify the from address is valid
+        if (!isAddress(authorization.from)) {
+            return errorResponse("Invalid from address");
+        }
+        // Check nonce hasn't been used (local check)
+        const nonceKey = `${authorization.from}-${authorization.nonce}`;
+        if (usedNonces.has(nonceKey)) {
+            return errorResponse("Nonce already used");
+        }
+        // Check on-chain nonce status
+        let onChainUsed;
+        try {
+            onChainUsed = await publicClient.readContract({
+                address: assetInfo.forwarder ?? asset,
+                abi: TRANSFER_WITH_AUTHORIZATION_ABI,
+                functionName: "authorizationState",
+                args: [authorization.from, authorization.nonce],
+            });
+        }
+        catch (error) {
+            throw new Error("Failed to check authorization status", { cause: error });
+        }
+        if (onChainUsed) {
+            return errorResponse("Authorization already used on-chain");
+        }
+        let domain;
+        if (useForwarder) {
+            if (!assetInfo.forwarderVersion ||
+                !assetInfo.forwarderName ||
+                !assetInfo.forwarder) {
+                throw new Error("Secondary Forwardign Information Missing");
+            }
+            domain = generateForwarderDomain(chainId, {
+                version: assetInfo.forwarderVersion,
+                name: assetInfo.forwarderName,
+                verifyingContract: assetInfo.forwarder,
+            });
+        }
+        else {
+            domain = await generateDomain(publicClient, chainId, asset);
+        }
+        const types = EIP712_TYPES;
+        const message = {
+            from: authorization.from,
+            to: authorization.to,
+            value: BigInt(authorization.value),
+            validAfter: BigInt(validAfter),
+            validBefore: BigInt(validBefore),
+            nonce: authorization.nonce,
+        };
+        // Verify the signature
+        let isValidSignature;
+        try {
+            isValidSignature = await verifyTypedData({
+                address: authorization.from,
+                domain,
+                types,
+                primaryType: "TransferWithAuthorization",
+                message,
+                signature: signature,
+            });
+        }
+        catch (cause) {
+            throw new Error("Signature verification failed", { cause });
+        }
+        if (!isValidSignature) {
+            return errorResponse("Invalid signature");
+        }
+        // Verify contract supports EIP-712
+        try {
+            await publicClient.readContract({
+                address: useForwarder ? domain.verifyingContract : asset,
+                abi: TRANSFER_WITH_AUTHORIZATION_ABI,
+                functionName: "DOMAIN_SEPARATOR",
+            });
+        }
+        catch (cause) {
+            throw new Error("Contract does not support EIP-712", { cause });
+        }
+        const acct = walletClient.account;
+        if (!acct || acct.type !== "local") {
+            return errorResponse("Wallet client is not configured with a local account");
+        }
+        const { v, r, s } = parseSignature(signature);
+        const data = encodeFunctionData({
+            abi: TRANSFER_WITH_AUTHORIZATION_ABI,
+            functionName: "transferWithAuthorization",
+            args: [
+                authorization.from,
+                authorization.to,
+                BigInt(authorization.value),
+                BigInt(validAfter),
+                BigInt(validBefore),
+                authorization.nonce,
+                v,
+                r,
+                s,
+            ],
+        });
+        // Build and send the transaction
+        try {
+            const request = await walletClient.prepareTransactionRequest({
+                to: useForwarder ? domain.verifyingContract : asset,
+                data,
+                account: acct,
+                chain: undefined,
+            });
+            const serializedTransaction = await walletClient.signTransaction(request);
+            const txHash = await publicClient.sendRawTransaction({
+                serializedTransaction,
+            });
+            const receipt = await publicClient.waitForTransactionReceipt({
+                hash: txHash,
+            });
+            if (receipt.status !== "success") {
+                return errorResponse("Transaction failed");
+            }
+            usedNonces.add(nonceKey);
+            return {
+                success: true,
+                error: null,
+                txHash,
+                networkId: chainId.toString(),
+            };
+        }
+        catch (cause) {
+            throw new Error("Transaction execution failed", { cause });
+        }
+    };
+    return {
+        getSupported,
+        getRequirements,
+        handleSettle,
+    };
+}

package/dist/src/exact/index.d.ts

@@ -0,0 +1,4 @@
+export { createPaymentHandler } from "./client.js";
+export { createFacilitatorHandler } from "./facilitator.js";
+export { X402_EXACT_SCHEME, TRANSFER_WITH_AUTHORIZATION_ABI, EIP712_TYPES, x402ExactPayload, eip712Domain, } from "./constants.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/exact/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exact/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EACL,iBAAiB,EACjB,+BAA+B,EAC/B,YAAY,EACZ,gBAAgB,EAChB,YAAY,GACb,MAAM,gBAAgB,CAAC"}

package/dist/src/exact/index.js

@@ -0,0 +1,3 @@
+export { createPaymentHandler } from "./client.js";
+export { createFacilitatorHandler } from "./facilitator.js";
+export { X402_EXACT_SCHEME, TRANSFER_WITH_AUTHORIZATION_ABI, EIP712_TYPES, x402ExactPayload, eip712Domain, } from "./constants.js";

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * as exact from "./exact/index.js";
+//# sourceMappingURL=index.d.ts.map