@4mica/sdk 1.0.1 → 1.0.2

package/dist/tests/rpc.test.js

@@ -1,44 +0,0 @@
-"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

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

package/dist/tests/signing.test.js

@@ -1,25 +0,0 @@
-"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

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

package/dist/tests/utils.test.js

@@ -1,25 +0,0 @@
-"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

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

package/dist/tests/x402.test.js

@@ -1,65 +0,0 @@
-"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/x402.d.ts

@@ -1,78 +0,0 @@
-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;
-}

package/dist/x402.js

@@ -1,231 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.X402Flow = exports.X402SettledPayment = exports.X402SignedPayment = exports.X402PaymentEnvelope = exports.TabResponse = exports.PaymentRequirementsExtra = exports.PaymentRequirements = void 0;
-const models_1 = require("./models");
-const utils_1 = require("./utils");
-const errors_1 = require("./errors");
-const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-class PaymentRequirements {
-    constructor(scheme, network, maxAmountRequired, payTo, asset, extra, resource, description, mimeType, outputSchema, maxTimeoutSeconds) {
-        this.scheme = scheme;
-        this.network = network;
-        this.maxAmountRequired = maxAmountRequired;
-        this.payTo = payTo;
-        this.asset = asset;
-        this.extra = extra;
-        this.resource = resource;
-        this.description = description;
-        this.mimeType = mimeType;
-        this.outputSchema = outputSchema;
-        this.maxTimeoutSeconds = maxTimeoutSeconds;
-    }
-    static fromRaw(raw) {
-        const pick = (keys, defaultValue) => {
-            for (const key of keys) {
-                const value = raw[key];
-                if (value !== undefined && value !== null)
-                    return value;
-            }
-            return defaultValue;
-        };
-        const amount = pick(['maxAmountRequired', 'max_amount_required']);
-        const payTo = pick(['payTo', 'pay_to']);
-        const asset = pick(['asset', 'assetAddress', 'asset_address']);
-        const scheme = pick(['scheme']);
-        const network = pick(['network']);
-        if (!amount || !payTo || !asset || !scheme || !network) {
-            const missing = [
-                ['scheme', scheme],
-                ['network', network],
-                ['maxAmountRequired', amount],
-                ['payTo', payTo],
-                ['asset', asset],
-            ]
-                .filter(([, value]) => !value)
-                .map(([key]) => key)
-                .join(', ');
-            throw new errors_1.X402Error(`payment requirements missing fields: ${missing}`);
-        }
-        return new PaymentRequirements(String(scheme), String(network), String(amount), String(payTo), String(asset), pick(['extra'], {}) ?? {}, pick(['resource']), pick(['description']), pick(['mimeType', 'mime_type']), pick(['outputSchema', 'output_schema']), pick(['maxTimeoutSeconds', 'max_timeout_seconds']));
-    }
-    toPayload() {
-        const extraPayload = { ...(this.extra ?? {}) };
-        if ('tab_endpoint' in extraPayload && !('tabEndpoint' in extraPayload)) {
-            extraPayload['tabEndpoint'] = extraPayload['tab_endpoint'];
-            delete extraPayload['tab_endpoint'];
-        }
-        const payload = {
-            scheme: this.scheme,
-            network: this.network,
-            maxAmountRequired: this.maxAmountRequired,
-            payTo: this.payTo,
-            asset: this.asset,
-            extra: extraPayload,
-        };
-        if (this.resource !== undefined)
-            payload.resource = this.resource;
-        if (this.description !== undefined)
-            payload.description = this.description;
-        if (this.mimeType !== undefined)
-            payload.mimeType = this.mimeType;
-        if (this.outputSchema !== undefined)
-            payload.outputSchema = this.outputSchema;
-        if (this.maxTimeoutSeconds !== undefined)
-            payload.maxTimeoutSeconds = this.maxTimeoutSeconds;
-        return payload;
-    }
-}
-exports.PaymentRequirements = PaymentRequirements;
-class PaymentRequirementsExtra {
-    constructor(tabEndpoint) {
-        this.tabEndpoint = tabEndpoint;
-    }
-    static fromRaw(raw) {
-        const tabEndpointRaw = (isRecord(raw) ? raw.tabEndpoint : undefined) ??
-            (isRecord(raw) ? raw.tab_endpoint : undefined);
-        const tabEndpoint = typeof tabEndpointRaw === 'string'
-            ? tabEndpointRaw
-            : tabEndpointRaw === null
-                ? null
-                : undefined;
-        return new PaymentRequirementsExtra(tabEndpoint);
-    }
-}
-exports.PaymentRequirementsExtra = PaymentRequirementsExtra;
-class TabResponse {
-    constructor(tabId, userAddress, nextReqId) {
-        this.tabId = tabId;
-        this.userAddress = userAddress;
-        this.nextReqId = nextReqId;
-    }
-}
-exports.TabResponse = TabResponse;
-class X402PaymentEnvelope {
-    constructor(x402Version, scheme, network, payload) {
-        this.x402Version = x402Version;
-        this.scheme = scheme;
-        this.network = network;
-        this.payload = payload;
-    }
-    toPayload() {
-        return {
-            x402Version: this.x402Version,
-            scheme: this.scheme,
-            network: this.network,
-            payload: this.payload,
-        };
-    }
-}
-exports.X402PaymentEnvelope = X402PaymentEnvelope;
-class X402SignedPayment {
-    constructor(header, claims, signature) {
-        this.header = header;
-        this.claims = claims;
-        this.signature = signature;
-    }
-}
-exports.X402SignedPayment = X402SignedPayment;
-class X402SettledPayment {
-    constructor(payment, settlement) {
-        this.payment = payment;
-        this.settlement = settlement;
-    }
-}
-exports.X402SettledPayment = X402SettledPayment;
-class X402Flow {
-    constructor(signer, fetchFn = fetch) {
-        this.signer = signer;
-        this.fetchFn = fetchFn;
-    }
-    static fromClient(client) {
-        return new X402Flow(client.user);
-    }
-    async signPayment(paymentRequirements, userAddress, existingTabId, existingReqId) {
-        X402Flow.validateScheme(paymentRequirements.scheme);
-        let tab;
-        if (existingTabId !== undefined && existingTabId !== null) {
-            tab = new TabResponse(String(existingTabId), userAddress, existingReqId !== undefined && existingReqId !== null ? String(existingReqId) : undefined);
-        }
-        else {
-            tab = await this.requestTab(paymentRequirements, userAddress);
-        }
-        const claims = this.buildClaims(paymentRequirements, tab, userAddress);
-        const signature = await this.signer.signPayment(claims, models_1.SigningScheme.EIP712);
-        const envelope = X402Flow.buildEnvelope(paymentRequirements, claims, signature);
-        const payload = envelope.toPayload();
-        payload.x402Version ?? (payload.x402Version = envelope.x402Version);
-        const header = Buffer.from(JSON.stringify(payload)).toString('base64');
-        return new X402SignedPayment(header, claims, 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: paymentRequirements.toPayload(),
-            }),
-        });
-        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 new X402SettledPayment(payment, settlement);
-    }
-    async requestTab(paymentRequirements, userAddress) {
-        const extra = PaymentRequirementsExtra.fromRaw(paymentRequirements.extra);
-        if (!extra.tabEndpoint) {
-            throw new errors_1.X402Error('missing tabEndpoint in paymentRequirements.extra');
-        }
-        const resp = await this.fetchFn(extra.tabEndpoint, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({
-                userAddress,
-                paymentRequirements: paymentRequirements.toPayload(),
-            }),
-        });
-        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 new TabResponse(body.tabId ?? body.tab_id, body.userAddress ?? body.user_address, 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)(requirements.maxAmountRequired);
-        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 buildEnvelope(paymentRequirements, claims, signature) {
-        const payload = {
-            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,
-        };
-        return new X402PaymentEnvelope(1, paymentRequirements.scheme, paymentRequirements.network, payload);
-    }
-}
-exports.X402Flow = X402Flow;