@4mica/sdk 0.5.0

package/dist/tests/rpc.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const rpc_1 = require("../src/rpc");
+const errors_1 = require("../src/errors");
+(0, vitest_1.describe)('RpcProxy', () => {
+    (0, vitest_1.it)('round trips public params', async () => {
+        const params = {
+            publicKey: [1, 2, 3],
+            contractAddress: '0x1234567890abcdef1234567890abcdef12345678',
+            ethereumHttpRpcUrl: 'http://localhost:8545',
+            eip712Name: '4mica',
+            eip712Version: '1',
+            chainId: 1337,
+        };
+        const fetchMock = vitest_1.vi.fn(async (input) => {
+            const url = input.toString();
+            (0, vitest_1.expect)(url.endsWith('/core/public-params')).toBe(true);
+            return new Response(JSON.stringify(params), { status: 200 });
+        });
+        const proxy = new rpc_1.RpcProxy('http://example.com', undefined, fetchMock);
+        const got = await proxy.getPublicParams();
+        (0, vitest_1.expect)(got.chainId).toBe(1337);
+        (0, vitest_1.expect)(got.contractAddress).toBe(params.contractAddress);
+        (0, vitest_1.expect)(got.ethereumHttpRpcUrl).toBe(params.ethereumHttpRpcUrl);
+    });
+    (0, vitest_1.it)('surfaces api errors', async () => {
+        const fetchMock = vitest_1.vi.fn(async (input) => {
+            (0, vitest_1.expect)(input.toString()).toContain('settlementStatus=unknown');
+            return new Response(JSON.stringify({ error: 'invalid settlement status: unknown' }), {
+                status: 400,
+            });
+        });
+        const proxy = new rpc_1.RpcProxy('http://example.com', undefined, fetchMock);
+        await (0, vitest_1.expect)(proxy.listRecipientTabs('0xdeadbeef', ['unknown'])).rejects.toThrow(errors_1.RpcError);
+    });
+    (0, vitest_1.it)('returns decode error on invalid json', async () => {
+        const fetchMock = vitest_1.vi.fn(async () => {
+            return new Response('not-json', { status: 200 });
+        });
+        const proxy = new rpc_1.RpcProxy('http://example.com', undefined, fetchMock);
+        await (0, vitest_1.expect)(proxy.getPublicParams()).rejects.toThrow(errors_1.RpcError);
+    });
+});

package/dist/tests/signing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/signing.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const models_1 = require("../src/models");
+const signing_1 = require("../src/signing");
+const errors_1 = require("../src/errors");
+function buildParams() {
+    return new signing_1.CorePublicParameters(new Uint8Array(), '0x0000000000000000000000000000000000000000', 'https://example.com', '4Mica', '1', 1);
+}
+(0, vitest_1.describe)('PaymentSigner', () => {
+    (0, vitest_1.it)('rejects address mismatch', async () => {
+        const signer = new signing_1.PaymentSigner('11'.repeat(32));
+        const claims = models_1.PaymentGuaranteeRequestClaims.new('0x0000000000000000000000000000000000000011', '0x0000000000000000000000000000000000000002', 1, 5, 1234, null);
+        await (0, vitest_1.expect)(signer.signRequest(buildParams(), claims, models_1.SigningScheme.EIP712)).rejects.toThrow(errors_1.SigningError);
+    });
+    (0, vitest_1.it)('produces eip712 signature', async () => {
+        const privateKey = '0x59c6995e998f97a5a0044976f7be35d5ad91c0cfa55b5cfb20b07a1c60f4c5bc';
+        const signer = new signing_1.PaymentSigner(privateKey);
+        const accountAddress = (await signer['wallet'].getAddress()).toLowerCase();
+        const claims = models_1.PaymentGuaranteeRequestClaims.new(accountAddress, '0x0000000000000000000000000000000000000002', 42, 123, 999, null);
+        const sig = await signer.signRequest(buildParams(), claims, models_1.SigningScheme.EIP712);
+        (0, vitest_1.expect)(sig.scheme).toBe(models_1.SigningScheme.EIP712);
+        (0, vitest_1.expect)(sig.signature.length).toBe(132);
+    });
+});

package/dist/tests/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const utils_1 = require("../src/utils");
+(0, vitest_1.describe)('utils', () => {
+    (0, vitest_1.it)('validateUrl rejects bad input', () => {
+        (0, vitest_1.expect)(() => (0, utils_1.validateUrl)('not-a-url')).toThrow(utils_1.ValidationError);
+    });
+    (0, vitest_1.it)('normalizePrivateKey strips prefix and lowercases', () => {
+        const key = (0, utils_1.normalizePrivateKey)('0xABCDEF' + '0'.repeat(58));
+        (0, vitest_1.expect)(key).toBe('0xabcdef' + '0'.repeat(58));
+    });
+    (0, vitest_1.it)('parseU256 accepts hex strings and serializes back', () => {
+        const value = (0, utils_1.parseU256)('0x10');
+        (0, vitest_1.expect)(value).toBe(16n);
+        (0, vitest_1.expect)((0, utils_1.serializeU256)(value)).toBe('0x10');
+    });
+    (0, vitest_1.it)('normalizeAddress round trips checksum', () => {
+        const addr = '0x0000000000000000000000000000000000000001';
+        (0, vitest_1.expect)((0, utils_1.normalizeAddress)(addr)).toBe('0x0000000000000000000000000000000000000001');
+    });
+    (0, vitest_1.it)('parseU256 rejects negatives', () => {
+        (0, vitest_1.expect)(() => (0, utils_1.parseU256)(-1)).toThrow(utils_1.ValidationError);
+    });
+});

package/dist/tests/x402.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/x402.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const models_1 = require("../src/models");
+const x402_1 = require("../src/x402");
+const errors_1 = require("../src/errors");
+class StubSigner {
+    async signPayment() {
+        return { signature: 'deadbeef', scheme: models_1.SigningScheme.EIP712 };
+    }
+}
+class StubX402Flow extends x402_1.X402Flow {
+    async requestTab() {
+        return new x402_1.TabResponse('2', '0x0000000000000000000000000000000000000001');
+    }
+}
+(0, vitest_1.describe)('X402Flow', () => {
+    (0, vitest_1.it)('rejects invalid scheme', async () => {
+        const flow = new StubX402Flow(new StubSigner());
+        const requirements = new x402_1.PaymentRequirements('http+pay', 'testnet', '1', '0x0000000000000000000000000000000000000003', '0x0000000000000000000000000000000000000000', { tabEndpoint: 'https://example.com' });
+        await (0, vitest_1.expect)(flow.signPayment(requirements, '0x0000000000000000000000000000000000000001')).rejects.toThrow(errors_1.X402Error);
+    });
+    (0, vitest_1.it)('builds header and payload', async () => {
+        const flow = new StubX402Flow(new StubSigner());
+        const requirements = new x402_1.PaymentRequirements('4mica+pay', 'testnet', '5', '0x0000000000000000000000000000000000000003', '0x0000000000000000000000000000000000000000', { tabEndpoint: 'https://example.com' });
+        const userAddress = '0x0000000000000000000000000000000000000001';
+        const signed = await flow.signPayment(requirements, userAddress);
+        const decoded = Buffer.from(signed.header, 'base64').toString('utf8');
+        const envelope = JSON.parse(decoded);
+        (0, vitest_1.expect)(envelope.x402Version).toBe(1);
+        (0, vitest_1.expect)(envelope.scheme).toBe('4mica+pay');
+        (0, vitest_1.expect)(envelope.payload.claims.tab_id).toBe('0x2');
+        (0, vitest_1.expect)(signed.claims.tabId).toBe(2n);
+        (0, vitest_1.expect)(signed.claims.amount).toBe(5n);
+    });
+    (0, vitest_1.it)('settles payment through facilitator', async () => {
+        const userAddress = '0x0000000000000000000000000000000000000009';
+        const tabEndpoint = 'http://facilitator.test/tab';
+        const facilitatorUrl = 'http://facilitator.test';
+        const requirements = new x402_1.PaymentRequirements('4mica+pay', 'testnet', '5', '0x00000000000000000000000000000000000000ff', '0x0000000000000000000000000000000000000000', { tabEndpoint });
+        const fetch = async (url, init) => {
+            const u = new URL(url);
+            if (u.pathname === '/tab') {
+                const body = JSON.parse(init?.body);
+                (0, vitest_1.expect)(body.userAddress).toBe(userAddress);
+                return new Response(JSON.stringify({ tabId: '0x1234', userAddress }), { status: 200 });
+            }
+            if (u.pathname === '/settle') {
+                const payload = JSON.parse(init?.body);
+                (0, vitest_1.expect)(payload.paymentRequirements.payTo).toBe(requirements.payTo);
+                return new Response(JSON.stringify({ settled: true, networkId: requirements.network }), {
+                    status: 200,
+                });
+            }
+            return new Response('not found', { status: 404 });
+        };
+        const flow = new x402_1.X402Flow(new StubSigner(), fetch);
+        const payment = await flow.signPayment(requirements, userAddress);
+        (0, vitest_1.expect)(payment.claims.tabId).toBe(0x1234n);
+        const settled = await flow.settlePayment(payment, requirements, facilitatorUrl);
+        (0, vitest_1.expect)(settled.settlement.settled).toBe(true);
+        (0, vitest_1.expect)(settled.settlement.networkId).toBe(requirements.network);
+        (0, vitest_1.expect)(settled.payment.claims.recipientAddress).toBe(requirements.payTo);
+    });
+});

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
+export declare function validateUrl(raw: string): string;
+export declare function normalizePrivateKey(raw: string): string;
+export declare function normalizeAddress(raw: string): string;
+export declare function parseU256(value: number | bigint | string): bigint;
+export declare function serializeU256(value: number | bigint | string): string;

package/dist/utils.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = void 0;
+exports.validateUrl = validateUrl;
+exports.normalizePrivateKey = normalizePrivateKey;
+exports.normalizeAddress = normalizeAddress;
+exports.parseU256 = parseU256;
+exports.serializeU256 = serializeU256;
+const ethers_1 = require("ethers");
+class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+function validateUrl(raw) {
+    try {
+        const url = new URL(raw);
+        if (!url.protocol || !url.host) {
+            throw new Error('missing parts');
+        }
+        return raw;
+    }
+    catch {
+        throw new ValidationError(`invalid URL: ${raw}`);
+    }
+}
+function normalizePrivateKey(raw) {
+    const key = raw.startsWith('0x') ? raw.slice(2) : raw;
+    if (!/^[0-9a-fA-F]{64}$/.test(key)) {
+        throw new ValidationError('invalid private key (expected 32 byte hex)');
+    }
+    return `0x${key.toLowerCase()}`;
+}
+function normalizeAddress(raw) {
+    const candidate = String(raw);
+    if ((0, ethers_1.isAddress)(candidate)) {
+        return (0, ethers_1.getAddress)(candidate);
+    }
+    const lower = candidate.toLowerCase();
+    if ((0, ethers_1.isAddress)(lower)) {
+        return (0, ethers_1.getAddress)(lower);
+    }
+    throw new ValidationError(`invalid address: ${raw}`);
+}
+function parseNumericString(raw) {
+    const text = raw.trim();
+    const n = BigInt(text);
+    if (n < 0n) {
+        throw new ValidationError('u256 cannot be negative');
+    }
+    return n;
+}
+function parseU256(value) {
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new ValidationError('invalid integer');
+        }
+        if (value < 0) {
+            throw new ValidationError('u256 cannot be negative');
+        }
+        return BigInt(value);
+    }
+    if (typeof value === 'bigint') {
+        if (value < 0) {
+            throw new ValidationError('u256 cannot be negative');
+        }
+        return value;
+    }
+    if (typeof value === 'string') {
+        return parseNumericString(value);
+    }
+    throw new ValidationError(`unsupported numeric type: ${typeof value}`);
+}
+function serializeU256(value) {
+    return `0x${parseU256(value).toString(16)}`;
+}

package/dist/x402/index.d.ts

@@ -0,0 +1,22 @@
+import { PaymentGuaranteeRequestClaims, PaymentSignature, SigningScheme } from '../models';
+import { PaymentRequirementsV1, TabResponse, X402SignedPayment, X402SettledPayment, PaymentRequirementsV2, X402PaymentRequired, X402ResourceInfo } from './models';
+import type { FetchFn } from '../rpc';
+export * from './models';
+export interface FlowSigner {
+    signPayment(claims: PaymentGuaranteeRequestClaims, scheme: SigningScheme): Promise<PaymentSignature>;
+}
+export declare class X402Flow {
+    private signer;
+    private fetchFn;
+    constructor(signer: FlowSigner, fetchFn?: FetchFn);
+    static fromClient(client: {
+        user: FlowSigner;
+    }): X402Flow;
+    signPayment(paymentRequirements: PaymentRequirementsV1, userAddress: string): Promise<X402SignedPayment>;
+    signPaymentV2(paymentRequired: X402PaymentRequired, accepted: PaymentRequirementsV2, userAddress: string): Promise<X402SignedPayment>;
+    settlePayment(payment: X402SignedPayment, paymentRequirements: PaymentRequirementsV1, facilitatorUrl: string): Promise<X402SettledPayment>;
+    protected requestTab(x402Version: number, paymentRequirements: PaymentRequirementsV1 | PaymentRequirementsV2, userAddress: string, resource?: X402ResourceInfo): Promise<TabResponse>;
+    protected buildClaims(requirements: PaymentRequirementsV1 | PaymentRequirementsV2, tab: TabResponse, userAddress: string): PaymentGuaranteeRequestClaims;
+    private static validateScheme;
+    private static buildPaymentPayload;
+}

package/dist/x402/index.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.X402Flow = void 0;
+const models_1 = require("../models");
+const utils_1 = require("../utils");
+const errors_1 = require("../errors");
+__exportStar(require("./models"), exports);
+class X402Flow {
+    constructor(signer, fetchFn = fetch) {
+        this.signer = signer;
+        this.fetchFn = fetchFn;
+    }
+    static fromClient(client) {
+        return new X402Flow(client.user);
+    }
+    async signPayment(paymentRequirements, userAddress) {
+        X402Flow.validateScheme(paymentRequirements.scheme);
+        const tab = await this.requestTab(1, paymentRequirements, userAddress);
+        const claims = this.buildClaims(paymentRequirements, tab, userAddress);
+        const signature = await this.signer.signPayment(claims, models_1.SigningScheme.EIP712);
+        const paymentPayload = X402Flow.buildPaymentPayload(claims, signature);
+        const envelope = {
+            x402Version: 1,
+            scheme: paymentRequirements.scheme,
+            network: paymentRequirements.network,
+            payload: paymentPayload,
+        };
+        const header = Buffer.from(JSON.stringify(envelope)).toString('base64');
+        return { header, payload: paymentPayload, signature };
+    }
+    async signPaymentV2(paymentRequired, accepted, userAddress) {
+        X402Flow.validateScheme(accepted.scheme);
+        const tab = await this.requestTab(2, accepted, userAddress, paymentRequired.resource);
+        const claims = this.buildClaims(accepted, tab, userAddress);
+        const signature = await this.signer.signPayment(claims, models_1.SigningScheme.EIP712);
+        const paymentPayload = X402Flow.buildPaymentPayload(claims, signature);
+        const envelope = {
+            x402Version: 2,
+            accepted: accepted,
+            payload: paymentPayload,
+            resource: paymentRequired.resource,
+        };
+        const header = Buffer.from(JSON.stringify(envelope)).toString('base64');
+        return { header, payload: paymentPayload, signature };
+    }
+    async settlePayment(payment, paymentRequirements, facilitatorUrl) {
+        const url = `${facilitatorUrl.replace(/\/$/, '')}/settle`;
+        const response = await this.fetchFn(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                x402Version: 1,
+                paymentHeader: payment.header,
+                paymentRequirements,
+            }),
+        });
+        const data = await response.text();
+        if (!response.ok) {
+            throw new errors_1.X402Error(`settlement failed with status ${response.status}: ${data}`);
+        }
+        const settlement = data ? JSON.parse(data) : {};
+        return { payment, settlement };
+    }
+    async requestTab(x402Version, paymentRequirements, userAddress, resource) {
+        const tabEndpoint = paymentRequirements.extra?.tabEndpoint;
+        if (!tabEndpoint || typeof tabEndpoint !== 'string') {
+            throw new errors_1.X402Error('missing tabEndpoint in paymentRequirements.extra');
+        }
+        const resp = await this.fetchFn(tabEndpoint, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                x402Version,
+                userAddress,
+                paymentRequirements,
+                resource,
+            }),
+        });
+        if (!resp.ok) {
+            const text = await resp.text();
+            throw new errors_1.X402Error(`tab resolution failed: ${resp.status} ${text}`);
+        }
+        const body = await resp.json();
+        return {
+            tabId: body.tabId ?? body.tab_id,
+            userAddress: body.userAddress ?? body.user_address,
+            nextReqId: body.nextReqId ?? body.next_req_id ?? body.reqId ?? body.req_id,
+        };
+    }
+    buildClaims(requirements, tab, userAddress) {
+        const tabId = (0, utils_1.parseU256)(tab.tabId);
+        const reqId = tab.nextReqId !== undefined && tab.nextReqId !== null ? (0, utils_1.parseU256)(tab.nextReqId) : 0n;
+        const amount = (0, utils_1.parseU256)('maxAmountRequired' in requirements ? requirements.maxAmountRequired : requirements.amount);
+        if (tab.userAddress.toLowerCase() !== userAddress.toLowerCase()) {
+            throw new errors_1.X402Error(`user mismatch in paymentRequirements: found ${tab.userAddress}, expected ${userAddress}`);
+        }
+        const timestamp = Math.floor(Date.now() / 1000);
+        return models_1.PaymentGuaranteeRequestClaims.new(userAddress, (0, utils_1.normalizeAddress)(requirements.payTo), tabId, amount, timestamp, requirements.asset, reqId);
+    }
+    static validateScheme(scheme) {
+        if (!scheme.toLowerCase().includes('4mica')) {
+            throw new errors_1.X402Error(`invalid scheme: ${scheme}`);
+        }
+    }
+    static buildPaymentPayload(claims, signature) {
+        return {
+            claims: {
+                version: 'v1',
+                user_address: claims.userAddress,
+                recipient_address: claims.recipientAddress,
+                tab_id: `0x${claims.tabId.toString(16)}`,
+                req_id: `0x${claims.reqId.toString(16)}`,
+                amount: `0x${claims.amount.toString(16)}`,
+                asset_address: claims.assetAddress,
+                timestamp: claims.timestamp,
+            },
+            signature: signature.signature,
+            scheme: signature.scheme,
+        };
+    }
+}
+exports.X402Flow = X402Flow;

package/dist/x402/models.d.ts

@@ -0,0 +1,80 @@
+import { PaymentSignature, SigningScheme } from '../models';
+export interface PaymentRequirementsV1 {
+    scheme: string;
+    network: string;
+    maxAmountRequired: string;
+    payTo: string;
+    asset: string;
+    resource?: string;
+    description?: string;
+    mimeType?: string;
+    outputSchema?: unknown;
+    maxTimeoutSeconds?: number;
+    extra?: PaymentRequirementsExtra;
+}
+export interface PaymentRequirementsV2 {
+    scheme: string;
+    network: string;
+    asset: string;
+    amount: string;
+    payTo: string;
+    maxTimeoutSeconds?: number;
+    extra?: PaymentRequirementsExtra;
+}
+export type PaymentRequirements = PaymentRequirementsV2;
+export interface PaymentRequirementsExtra {
+    tabEndpoint?: string;
+}
+export interface TabResponse {
+    tabId: string;
+    userAddress: string;
+    nextReqId?: string;
+}
+export interface X402PaymentPayloadClaims {
+    version: string;
+    user_address: string;
+    recipient_address: string;
+    tab_id: string;
+    req_id: string;
+    amount: string;
+    timestamp: number;
+    asset_address: string;
+}
+export interface X402PaymentPayload {
+    claims: X402PaymentPayloadClaims;
+    signature: string;
+    scheme: SigningScheme;
+}
+export interface X402PaymentEnvelopeV1 {
+    x402Version: number;
+    scheme: string;
+    network: string;
+    payload: X402PaymentPayload;
+}
+export interface X402ResourceInfo {
+    url: string;
+    description: string;
+    mimeType: string;
+}
+export interface X402PaymentEnvelopeV2 {
+    x402Version: number;
+    accepted: PaymentRequirementsV2;
+    payload: X402PaymentPayload;
+    resource: X402ResourceInfo;
+}
+export interface X402SignedPayment {
+    header: string;
+    payload: X402PaymentPayload;
+    signature: PaymentSignature;
+}
+export interface X402SettledPayment {
+    payment: X402SignedPayment;
+    settlement: unknown;
+}
+export interface X402PaymentRequired {
+    x402Version: number;
+    error?: string;
+    resource: X402ResourceInfo;
+    accepts: PaymentRequirementsV2[];
+    extensions?: Record<string, unknown>;
+}

package/dist/x402/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/x402.d.ts

@@ -0,0 +1,78 @@
+import { PaymentGuaranteeRequestClaims, PaymentSignature, SigningScheme } from './models';
+import type { FetchFn } from './rpc';
+export interface PaymentRequirementsInit {
+    scheme: string;
+    network: string;
+    maxAmountRequired: string;
+    payTo: string;
+    asset: string;
+    extra?: Record<string, unknown>;
+    resource?: string;
+    description?: string;
+    mimeType?: string;
+    outputSchema?: unknown;
+    maxTimeoutSeconds?: number;
+}
+export declare class PaymentRequirements {
+    scheme: string;
+    network: string;
+    maxAmountRequired: string;
+    payTo: string;
+    asset: string;
+    extra: Record<string, unknown>;
+    resource?: string | undefined;
+    description?: string | undefined;
+    mimeType?: string | undefined;
+    outputSchema?: unknown | undefined;
+    maxTimeoutSeconds?: number | undefined;
+    constructor(scheme: string, network: string, maxAmountRequired: string, payTo: string, asset: string, extra: Record<string, unknown>, resource?: string | undefined, description?: string | undefined, mimeType?: string | undefined, outputSchema?: unknown | undefined, maxTimeoutSeconds?: number | undefined);
+    static fromRaw(raw: Record<string, unknown>): PaymentRequirements;
+    toPayload(): Record<string, unknown>;
+}
+export declare class PaymentRequirementsExtra {
+    tabEndpoint?: string | null | undefined;
+    constructor(tabEndpoint?: string | null | undefined);
+    static fromRaw(raw: Record<string, unknown> | undefined): PaymentRequirementsExtra;
+}
+export declare class TabResponse {
+    tabId: string;
+    userAddress: string;
+    nextReqId?: string | null | undefined;
+    constructor(tabId: string, userAddress: string, nextReqId?: string | null | undefined);
+}
+export declare class X402PaymentEnvelope {
+    x402Version: number;
+    scheme: string;
+    network: string;
+    payload: Record<string, unknown>;
+    constructor(x402Version: number, scheme: string, network: string, payload: Record<string, unknown>);
+    toPayload(): Record<string, unknown>;
+}
+export declare class X402SignedPayment {
+    header: string;
+    claims: PaymentGuaranteeRequestClaims;
+    signature: PaymentSignature;
+    constructor(header: string, claims: PaymentGuaranteeRequestClaims, signature: PaymentSignature);
+}
+export declare class X402SettledPayment {
+    payment: X402SignedPayment;
+    settlement: unknown;
+    constructor(payment: X402SignedPayment, settlement: unknown);
+}
+export interface FlowSigner {
+    signPayment(claims: PaymentGuaranteeRequestClaims, scheme: SigningScheme): Promise<PaymentSignature>;
+}
+export declare class X402Flow {
+    private signer;
+    private fetchFn;
+    constructor(signer: FlowSigner, fetchFn?: FetchFn);
+    static fromClient(client: {
+        user: FlowSigner;
+    }): X402Flow;
+    signPayment(paymentRequirements: PaymentRequirements, userAddress: string, existingTabId?: bigint | number, existingReqId?: bigint | number): Promise<X402SignedPayment>;
+    settlePayment(payment: X402SignedPayment, paymentRequirements: PaymentRequirements, facilitatorUrl: string): Promise<X402SettledPayment>;
+    protected requestTab(paymentRequirements: PaymentRequirements, userAddress: string): Promise<TabResponse>;
+    protected buildClaims(requirements: PaymentRequirements, tab: TabResponse, userAddress: string): PaymentGuaranteeRequestClaims;
+    private static validateScheme;
+    private static buildEnvelope;
+}