@4mica/sdk 1.0.1 → 1.1.0

package/dist/src/rpc.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcProxy = void 0;
-const signing_1 = require("./signing");
-const errors_1 = require("./errors");
-const ADMIN_API_KEY_HEADER = 'x-api-key';
-function serializeTabId(tabId) {
-    return `0x${BigInt(tabId).toString(16)}`;
-}
-class RpcProxy {
-    constructor(endpoint, adminApiKey, fetchFn = fetch) {
-        this.baseUrl = endpoint.endsWith('/') ? endpoint.slice(0, -1) : endpoint;
-        this.adminApiKey = adminApiKey;
-        this.fetchFn = fetchFn;
-    }
-    async aclose() {
-        // no-op for symmetry with Python SDK
-    }
-    headers() {
-        const headers = {};
-        if (this.adminApiKey) {
-            headers[ADMIN_API_KEY_HEADER] = this.adminApiKey;
-        }
-        return headers;
-    }
-    async decode(response) {
-        let payload;
-        try {
-            payload = await response.json();
-        }
-        catch (err) {
-            if (response.ok) {
-                throw new errors_1.RpcError(`invalid JSON response from ${response.url}: ${String(err)}`);
-            }
-            payload = await response.text();
-        }
-        if (response.ok) {
-            return payload;
-        }
-        let message = 'unknown error';
-        if (payload && typeof payload === 'object') {
-            message = payload.error ?? payload.message ?? JSON.stringify(payload, (_k, v) => v);
-        }
-        else if (typeof payload === 'string' && payload.trim()) {
-            message = payload.trim();
-        }
-        throw new errors_1.RpcError(`${response.status}: ${message}`);
-    }
-    async get(path) {
-        const resp = await this.fetchFn(`${this.baseUrl}${path}`, {
-            headers: this.headers(),
-            method: 'GET',
-        });
-        return this.decode(resp);
-    }
-    async post(path, body) {
-        const resp = await this.fetchFn(`${this.baseUrl}${path}`, {
-            headers: { 'content-type': 'application/json', ...this.headers() },
-            method: 'POST',
-            body: JSON.stringify(body),
-        });
-        return this.decode(resp);
-    }
-    async getPublicParams() {
-        const data = await this.get('/core/public-params');
-        return signing_1.CorePublicParameters.fromRpc(data);
-    }
-    async issueGuarantee(body) {
-        return this.post('/core/guarantees', body);
-    }
-    async createPaymentTab(body) {
-        return this.post('/core/payment-tabs', body);
-    }
-    async listSettledTabs(recipientAddress) {
-        return this.get(`/core/recipients/${recipientAddress}/settled-tabs`);
-    }
-    async listPendingRemunerations(recipientAddress) {
-        return this.get(`/core/recipients/${recipientAddress}/pending-remunerations`);
-    }
-    async getTab(tabId) {
-        return this.get(`/core/tabs/${serializeTabId(tabId)}`);
-    }
-    async listRecipientTabs(recipientAddress, settlementStatuses) {
-        let query = '';
-        if (settlementStatuses?.length) {
-            query =
-                '?' + settlementStatuses.map((s) => `settlementStatus=${encodeURIComponent(s)}`).join('&');
-        }
-        return this.get(`/core/recipients/${recipientAddress}/tabs${query}`);
-    }
-    async getTabGuarantees(tabId) {
-        return this.get(`/core/tabs/${serializeTabId(tabId)}/guarantees`);
-    }
-    async getLatestGuarantee(tabId) {
-        return this.get(`/core/tabs/${serializeTabId(tabId)}/guarantees/latest`);
-    }
-    async getGuarantee(tabId, reqId) {
-        return this.get(`/core/tabs/${serializeTabId(tabId)}/guarantees/${reqId}`);
-    }
-    async listRecipientPayments(recipientAddress) {
-        return this.get(`/core/recipients/${recipientAddress}/payments`);
-    }
-    async getCollateralEventsForTab(tabId) {
-        return this.get(`/core/tabs/${serializeTabId(tabId)}/collateral-events`);
-    }
-    async getUserAssetBalance(userAddress, assetAddress) {
-        return this.get(`/core/users/${userAddress}/assets/${assetAddress}`);
-    }
-    async updateUserSuspension(userAddress, suspended) {
-        return this.post(`/core/users/${userAddress}/suspension`, { suspended });
-    }
-    async createAdminApiKey(body) {
-        return this.post('/core/admin/api-keys', body);
-    }
-    async listAdminApiKeys() {
-        return this.get('/core/admin/api-keys');
-    }
-    async revokeAdminApiKey(keyId) {
-        return this.post(`/core/admin/api-keys/${keyId}/revoke`, {});
-    }
-}
-exports.RpcProxy = RpcProxy;

package/dist/src/signing.d.ts

@@ -1,16 +0,0 @@
-import { PaymentGuaranteeRequestClaims, PaymentSignature, SigningScheme } from './models';
-export declare class CorePublicParameters {
-    publicKey: Uint8Array;
-    contractAddress: string;
-    ethereumHttpRpcUrl: string;
-    eip712Name: string;
-    eip712Version: string;
-    chainId: number;
-    constructor(publicKey: Uint8Array, contractAddress: string, ethereumHttpRpcUrl: string, eip712Name: string, eip712Version: string, chainId: number);
-    static fromRpc(payload: Record<string, any>): CorePublicParameters;
-}
-export declare class PaymentSigner {
-    private wallet;
-    constructor(privateKey: string);
-    signRequest(params: CorePublicParameters, claims: PaymentGuaranteeRequestClaims, scheme?: SigningScheme): Promise<PaymentSignature>;
-}

package/dist/src/signing.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaymentSigner = exports.CorePublicParameters = void 0;
-const ethers_1 = require("ethers");
-const errors_1 = require("./errors");
-const models_1 = require("./models");
-const utils_1 = require("./utils");
-class CorePublicParameters {
-    constructor(publicKey, contractAddress, ethereumHttpRpcUrl, eip712Name, eip712Version, chainId) {
-        this.publicKey = publicKey;
-        this.contractAddress = contractAddress;
-        this.ethereumHttpRpcUrl = ethereumHttpRpcUrl;
-        this.eip712Name = eip712Name;
-        this.eip712Version = eip712Version;
-        this.chainId = chainId;
-    }
-    static fromRpc(payload) {
-        const pkRaw = payload.public_key ?? payload.publicKey;
-        const pk = typeof pkRaw === 'string'
-            ? (0, ethers_1.getBytes)(pkRaw)
-            : pkRaw
-                ? Uint8Array.from(pkRaw)
-                : new Uint8Array();
-        return new CorePublicParameters(pk, payload.contract_address ?? payload.contractAddress, payload.ethereum_http_rpc_url ?? payload.ethereumHttpRpcUrl, payload.eip712_name ?? payload.eip712Name ?? '4Mica', payload.eip712_version ?? payload.eip712Version ?? '1', Number(payload.chain_id ?? payload.chainId));
-    }
-}
-exports.CorePublicParameters = CorePublicParameters;
-function buildTypedMessage(params, claims) {
-    return {
-        types: {
-            EIP712Domain: [
-                { name: 'name', type: 'string' },
-                { name: 'version', type: 'string' },
-                { name: 'chainId', type: 'uint256' },
-            ],
-            SolGuaranteeRequestClaimsV1: [
-                { name: 'user', type: 'address' },
-                { name: 'recipient', type: 'address' },
-                { name: 'tabId', type: 'uint256' },
-                { name: 'amount', type: 'uint256' },
-                { name: 'asset', type: 'address' },
-                { name: 'timestamp', type: 'uint64' },
-            ],
-        },
-        primaryType: 'SolGuaranteeRequestClaimsV1',
-        domain: {
-            name: params.eip712Name,
-            version: params.eip712Version,
-            chainId: params.chainId,
-        },
-        message: {
-            user: claims.userAddress,
-            recipient: claims.recipientAddress,
-            tabId: Number(claims.tabId),
-            amount: Number(claims.amount),
-            asset: claims.assetAddress,
-            timestamp: Number(claims.timestamp),
-        },
-    };
-}
-function encodeEip191(claims) {
-    const payload = ethers_1.AbiCoder.defaultAbiCoder().encode(['address', 'address', 'uint256', 'uint256', 'address', 'uint64'], [
-        claims.userAddress,
-        claims.recipientAddress,
-        claims.tabId,
-        claims.amount,
-        claims.assetAddress,
-        claims.timestamp,
-    ]);
-    return (0, ethers_1.getBytes)(payload);
-}
-class PaymentSigner {
-    constructor(privateKey) {
-        this.wallet = new ethers_1.Wallet(privateKey);
-    }
-    async signRequest(params, claims, scheme = models_1.SigningScheme.EIP712) {
-        if ((0, utils_1.normalizeAddress)(this.wallet.address) !== (0, utils_1.normalizeAddress)(claims.userAddress)) {
-            throw new errors_1.SigningError(`address mismatch: signer ${this.wallet.address} != claims.user_address ${claims.userAddress}`);
-        }
-        try {
-            if (scheme === models_1.SigningScheme.EIP712) {
-                const typed = buildTypedMessage(params, claims);
-                const claimsTypes = [...typed.types.SolGuaranteeRequestClaimsV1];
-                const signature = await this.wallet.signTypedData(typed.domain, { SolGuaranteeRequestClaimsV1: claimsTypes }, typed.message);
-                return { signature, scheme };
-            }
-            if (scheme === models_1.SigningScheme.EIP191) {
-                const message = encodeEip191(claims);
-                const signature = await this.wallet.signMessage(message);
-                return { signature, scheme };
-            }
-            throw new errors_1.SigningError(`unsupported signing scheme: ${scheme}`);
-        }
-        catch (err) {
-            if (err instanceof utils_1.ValidationError) {
-                throw new errors_1.SigningError(err.message);
-            }
-            throw new errors_1.SigningError(err?.message ?? String(err));
-        }
-    }
-}
-exports.PaymentSigner = PaymentSigner;

package/dist/src/utils.d.ts

@@ -1,8 +0,0 @@
-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/src/utils.js

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

@@ -1,77 +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, any>;
-    resource?: string;
-    description?: string;
-    mimeType?: string;
-    outputSchema?: any;
-    maxTimeoutSeconds?: number;
-}
-export declare class PaymentRequirements {
-    scheme: string;
-    network: string;
-    maxAmountRequired: string;
-    payTo: string;
-    asset: string;
-    extra: Record<string, any>;
-    resource?: string | undefined;
-    description?: string | undefined;
-    mimeType?: string | undefined;
-    outputSchema?: any | undefined;
-    maxTimeoutSeconds?: number | undefined;
-    constructor(scheme: string, network: string, maxAmountRequired: string, payTo: string, asset: string, extra: Record<string, any>, resource?: string | undefined, description?: string | undefined, mimeType?: string | undefined, outputSchema?: any | undefined, maxTimeoutSeconds?: number | undefined);
-    static fromRaw(raw: Record<string, any>): PaymentRequirements;
-    toPayload(): Record<string, any>;
-}
-export declare class PaymentRequirementsExtra {
-    tabEndpoint?: string | null | undefined;
-    constructor(tabEndpoint?: string | null | undefined);
-    static fromRaw(raw: Record<string, any> | undefined): PaymentRequirementsExtra;
-}
-export declare class TabResponse {
-    tabId: string;
-    userAddress: string;
-    constructor(tabId: string, userAddress: string);
-}
-export declare class X402PaymentEnvelope {
-    x402Version: number;
-    scheme: string;
-    network: string;
-    payload: Record<string, any>;
-    constructor(x402Version: number, scheme: string, network: string, payload: Record<string, any>);
-    toPayload(): Record<string, any>;
-}
-export declare class X402SignedPayment {
-    header: string;
-    claims: PaymentGuaranteeRequestClaims;
-    signature: PaymentSignature;
-    constructor(header: string, claims: PaymentGuaranteeRequestClaims, signature: PaymentSignature);
-}
-export declare class X402SettledPayment {
-    payment: X402SignedPayment;
-    settlement: any;
-    constructor(payment: X402SignedPayment, settlement: any);
-}
-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): 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/src/x402.js

@@ -1,214 +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");
-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) {
-                if (raw[key] !== undefined && raw[key] !== null)
-                    return raw[key];
-            }
-            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(scheme, network, String(amount), payTo, 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 tabEndpoint = raw?.tabEndpoint ?? raw?.tab_endpoint;
-        return new PaymentRequirementsExtra(tabEndpoint);
-    }
-}
-exports.PaymentRequirementsExtra = PaymentRequirementsExtra;
-class TabResponse {
-    constructor(tabId, userAddress) {
-        this.tabId = tabId;
-        this.userAddress = userAddress;
-    }
-}
-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) {
-        X402Flow.validateScheme(paymentRequirements.scheme);
-        const 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);
-    }
-    buildClaims(requirements, tab, userAddress) {
-        const tabId = (0, utils_1.parseU256)(tab.tabId);
-        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);
-    }
-    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)}`,
-                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;

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

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

package/dist/tests/config.test.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const config_1 = require("../src/config");
-const errors_1 = require("../src/errors");
-(0, vitest_1.describe)('ConfigBuilder', () => {
-    (0, vitest_1.beforeEach)(() => {
-        vitest_1.vi.resetModules();
-    });
-    (0, vitest_1.it)('reads from env', () => {
-        process.env['4MICA_RPC_URL'] = 'https://example.com';
-        process.env['4MICA_WALLET_PRIVATE_KEY'] = '11'.repeat(32);
-        const cfg = new config_1.ConfigBuilder().fromEnv().build();
-        (0, vitest_1.expect)(cfg.rpcUrl).toBe('https://example.com');
-        (0, vitest_1.expect)(cfg.walletPrivateKey.startsWith('0x11')).toBe(true);
-    });
-    (0, vitest_1.it)('requires private key', () => {
-        delete process.env['4MICA_WALLET_PRIVATE_KEY'];
-        const builder = new config_1.ConfigBuilder().fromEnv();
-        (0, vitest_1.expect)(() => builder.build()).toThrow(errors_1.ConfigError);
-    });
-    (0, vitest_1.it)('rejects invalid private key', () => {
-        const builder = new config_1.ConfigBuilder().walletPrivateKey('0x1234');
-        (0, vitest_1.expect)(() => builder.build()).toThrow(errors_1.ConfigError);
-    });
-});

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

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

package/dist/tests/guarantee.test.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const guarantee_1 = require("../src/guarantee");
-(0, vitest_1.describe)('guarantee codec', () => {
-    (0, vitest_1.it)('round trips guarantee claims', () => {
-        const claims = {
-            domain: new Uint8Array(32),
-            userAddress: '0x0000000000000000000000000000000000000001',
-            recipientAddress: '0x0000000000000000000000000000000000000002',
-            tabId: 1n,
-            reqId: 2n,
-            amount: 3n,
-            totalAmount: 4n,
-            assetAddress: '0x0000000000000000000000000000000000000000',
-            timestamp: 123456,
-            version: 1,
-        };
-        const encoded = (0, guarantee_1.encodeGuaranteeClaims)(claims);
-        const decoded = (0, guarantee_1.decodeGuaranteeClaims)(encoded);
-        (0, vitest_1.expect)(decoded.userAddress).toBe(claims.userAddress);
-        (0, vitest_1.expect)(decoded.recipientAddress).toBe(claims.recipientAddress);
-        (0, vitest_1.expect)(decoded.tabId).toBe(claims.tabId);
-        (0, vitest_1.expect)(decoded.amount).toBe(claims.amount);
-    });
-});

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

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