@halot/sdk 1.0.0

package/dist/utils/artifacts.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveImageArtifacts = resolveImageArtifacts;
+exports.buildArtifactSummary = buildArtifactSummary;
+const hash_1 = require("./hash");
+const imagePathPattern = /(image|images|artifact|artifacts|thumbnail|preview|mask|reference)/i;
+const directImageFieldPattern = /(image|imageUrl|imageUri|dataUrl|dataURI|uri|url|src|href)$/i;
+const imageMimePattern = /^image\//i;
+const imageExtensionPattern = /\.(png|jpe?g|gif|webp|bmp|svg)(?:[?#].*)?$/i;
+const defaultMaxImageBytes = 5 * 1024 * 1024;
+const defaultMaxImagesPerOrigin = 4;
+async function resolveImageArtifacts(input, result, options = {}) {
+    const fetchImplementation = options.fetchImplementation ?? fetch;
+    const maxImageBytes = options.maxImageBytes ?? defaultMaxImageBytes;
+    const maxImagesPerOrigin = options.maxImagesPerOrigin ?? defaultMaxImagesPerOrigin;
+    const inputCandidates = collectImageArtifactCandidates(input, 'input');
+    const resultCandidates = collectImageArtifactCandidates(result, 'result');
+    if (resultCandidates.length === 0
+        && typeof result === 'string'
+        && isSupportedImageReference(result)
+        && (options.outputFormat ?? '').toLowerCase().includes('image')) {
+        resultCandidates.push({
+            origin: 'result',
+            path: 'result',
+            url: result,
+        });
+    }
+    const issues = [];
+    if ((options.outputFormat ?? '').toLowerCase().includes('image') && resultCandidates.length === 0) {
+        issues.push('Service output format indicates image output, but no image artifacts were found in the provider result.');
+    }
+    const inputResolution = await resolveCandidates(inputCandidates.slice(0, maxImagesPerOrigin), fetchImplementation, maxImageBytes);
+    const resultResolution = await resolveCandidates(resultCandidates.slice(0, maxImagesPerOrigin), fetchImplementation, maxImageBytes);
+    issues.push(...inputResolution.failures.flatMap(formatFailure));
+    issues.push(...resultResolution.failures.flatMap(formatFailure));
+    if (inputCandidates.length > maxImagesPerOrigin) {
+        issues.push(`Only the first ${maxImagesPerOrigin} input image artifacts were evaluated.`);
+    }
+    if (resultCandidates.length > maxImagesPerOrigin) {
+        issues.push(`Only the first ${maxImagesPerOrigin} result image artifacts were evaluated.`);
+    }
+    return {
+        inputImages: inputResolution.images,
+        resultImages: resultResolution.images,
+        issues,
+    };
+}
+function buildArtifactSummary(artifacts) {
+    if (artifacts.length === 0) {
+        return 'None';
+    }
+    return artifacts.map((artifact) => {
+        const dimensions = artifact.width && artifact.height ? `, ${artifact.width}x${artifact.height}` : '';
+        return `- ${artifact.path}: ${artifact.mimeType}${dimensions}, sha256=${artifact.sha256}, bytes=${artifact.byteLength}`;
+    }).join('\n');
+}
+function formatFailure(failure) {
+    return failure.errors.map((error) => `${failure.path}: ${error}`);
+}
+function collectImageArtifactCandidates(value, origin) {
+    const seen = new WeakSet();
+    const results = [];
+    const dedupe = new Set();
+    const visit = (current, path, parentKey) => {
+        if (typeof current === 'string') {
+            const candidate = buildStringCandidate(current, origin, path, parentKey);
+            if (candidate) {
+                const key = `${candidate.origin}:${candidate.url}`;
+                if (!dedupe.has(key)) {
+                    dedupe.add(key);
+                    results.push(candidate);
+                }
+            }
+            return;
+        }
+        if (!current || typeof current !== 'object') {
+            return;
+        }
+        if (seen.has(current)) {
+            return;
+        }
+        seen.add(current);
+        if (Array.isArray(current)) {
+            current.forEach((item, index) => visit(item, `${path}[${index}]`, parentKey));
+            return;
+        }
+        const candidate = buildObjectCandidate(current, origin, path, parentKey);
+        if (candidate) {
+            const key = `${candidate.origin}:${candidate.url}`;
+            if (!dedupe.has(key)) {
+                dedupe.add(key);
+                results.push(candidate);
+            }
+        }
+        for (const [key, item] of Object.entries(current)) {
+            visit(item, `${path}.${key}`, key);
+        }
+    };
+    visit(value, origin);
+    return results;
+}
+function buildStringCandidate(value, origin, path, parentKey) {
+    if (!isSupportedImageReference(value)) {
+        return null;
+    }
+    if (!imagePathPattern.test(path) && !directImageFieldPattern.test(parentKey ?? '')) {
+        return null;
+    }
+    return {
+        origin,
+        path,
+        url: value,
+    };
+}
+function buildObjectCandidate(value, origin, path, parentKey) {
+    const url = firstString(value, ['dataUrl', 'dataURI', 'imageUrl', 'imageURI', 'url', 'uri', 'src', 'href']);
+    if (!url || !isSupportedImageReference(url)) {
+        return null;
+    }
+    const mimeType = firstString(value, ['mimeType', 'contentType', 'mediaType', 'type']);
+    const isImageObject = Boolean((mimeType && imageMimePattern.test(mimeType))
+        || value.kind === 'image'
+        || value.artifactType === 'image'
+        || imagePathPattern.test(path)
+        || imagePathPattern.test(parentKey ?? '')
+        || imageExtensionPattern.test(url)
+        || isDataImageUri(url));
+    if (!isImageObject) {
+        return null;
+    }
+    const sha256 = firstString(value, ['sha256', 'sha256Hash', 'contentSha256', 'checksumSha256', 'digest']);
+    const width = firstNumber(value, ['width']);
+    const height = firstNumber(value, ['height']);
+    return {
+        origin,
+        path,
+        url,
+        mimeType,
+        sha256,
+        width,
+        height,
+    };
+}
+async function resolveCandidates(candidates, fetchImplementation, maxImageBytes) {
+    const images = [];
+    const failures = [];
+    for (const candidate of candidates) {
+        try {
+            const resolved = await resolveCandidate(candidate, fetchImplementation, maxImageBytes);
+            images.push(resolved.image);
+            if (resolved.errors.length > 0) {
+                failures.push({
+                    origin: candidate.origin,
+                    path: candidate.path,
+                    url: candidate.url,
+                    errors: resolved.errors,
+                });
+            }
+        }
+        catch (error) {
+            failures.push({
+                origin: candidate.origin,
+                path: candidate.path,
+                url: candidate.url,
+                errors: [error instanceof Error ? error.message : String(error)],
+            });
+        }
+    }
+    return { images, failures };
+}
+async function resolveCandidate(candidate, fetchImplementation, maxImageBytes) {
+    const { bytes, mimeType: detectedMimeType } = await loadImageBytes(candidate.url, fetchImplementation, maxImageBytes);
+    const metadata = inferImageMetadata(bytes, candidate.mimeType ?? detectedMimeType);
+    const mimeType = candidate.mimeType ?? metadata.mimeType ?? detectedMimeType;
+    if (!imageMimePattern.test(mimeType)) {
+        throw new Error(`Resolved artifact is not an image (${mimeType})`);
+    }
+    const sha256 = (0, hash_1.hashBytes)(bytes);
+    const errors = [];
+    if (candidate.mimeType && candidate.mimeType !== mimeType) {
+        errors.push(`declared mimeType ${candidate.mimeType} does not match fetched mimeType ${mimeType}`);
+    }
+    if (candidate.sha256 && candidate.sha256 !== sha256) {
+        errors.push(`declared sha256 ${candidate.sha256} does not match fetched content hash ${sha256}`);
+    }
+    if (candidate.width && metadata.width && candidate.width !== metadata.width) {
+        errors.push(`declared width ${candidate.width} does not match fetched width ${metadata.width}`);
+    }
+    if (candidate.height && metadata.height && candidate.height !== metadata.height) {
+        errors.push(`declared height ${candidate.height} does not match fetched height ${metadata.height}`);
+    }
+    return {
+        image: {
+            origin: candidate.origin,
+            path: candidate.path,
+            url: candidate.url,
+            mimeType,
+            sha256,
+            byteLength: bytes.byteLength,
+            width: metadata.width ?? candidate.width,
+            height: metadata.height ?? candidate.height,
+            dataUrl: `data:${mimeType};base64,${Buffer.from(bytes).toString('base64')}`,
+        },
+        errors,
+    };
+}
+async function loadImageBytes(url, fetchImplementation, maxImageBytes) {
+    if (isDataImageUri(url)) {
+        const match = url.match(/^data:([^;,]+);base64,(.+)$/);
+        if (!match) {
+            throw new Error('Unsupported data URI image format');
+        }
+        const bytes = Buffer.from(match[2], 'base64');
+        if (bytes.byteLength > maxImageBytes) {
+            throw new Error(`image exceeds maximum size of ${maxImageBytes} bytes`);
+        }
+        return {
+            bytes,
+            mimeType: match[1],
+        };
+    }
+    if (!isHttpUrl(url)) {
+        throw new Error('Only http(s) URLs and data:image URIs are supported for image verification');
+    }
+    const response = await fetchImplementation(url);
+    if (!response.ok) {
+        throw new Error(`failed to fetch image artifact (${response.status})`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const bytes = new Uint8Array(arrayBuffer);
+    if (bytes.byteLength > maxImageBytes) {
+        throw new Error(`image exceeds maximum size of ${maxImageBytes} bytes`);
+    }
+    return {
+        bytes,
+        mimeType: response.headers.get('content-type')?.split(';')[0]?.trim() || inferMimeTypeFromUrl(url) || 'application/octet-stream',
+    };
+}
+function inferImageMetadata(bytes, fallbackMimeType) {
+    if (bytes.byteLength >= 24 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) {
+        return {
+            mimeType: 'image/png',
+            width: readUInt32BE(bytes, 16),
+            height: readUInt32BE(bytes, 20),
+        };
+    }
+    if (bytes.byteLength >= 10 && bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46) {
+        return {
+            mimeType: 'image/gif',
+            width: readUInt16LE(bytes, 6),
+            height: readUInt16LE(bytes, 8),
+        };
+    }
+    if (bytes.byteLength >= 12 && String.fromCharCode(...bytes.slice(0, 4)) === 'RIFF' && String.fromCharCode(...bytes.slice(8, 12)) === 'WEBP') {
+        return {
+            mimeType: 'image/webp',
+            ...readWebpDimensions(bytes),
+        };
+    }
+    if (bytes.byteLength >= 4 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+        return {
+            mimeType: 'image/jpeg',
+            ...readJpegDimensions(bytes),
+        };
+    }
+    const asciiPrefix = Buffer.from(bytes.slice(0, 256)).toString('utf8').trimStart();
+    if (asciiPrefix.startsWith('<svg') || asciiPrefix.startsWith('<?xml')) {
+        return {
+            mimeType: 'image/svg+xml',
+        };
+    }
+    return {
+        mimeType: fallbackMimeType ?? 'application/octet-stream',
+    };
+}
+function readJpegDimensions(bytes) {
+    let offset = 2;
+    while (offset + 9 < bytes.byteLength) {
+        if (bytes[offset] !== 0xff) {
+            offset += 1;
+            continue;
+        }
+        const marker = bytes[offset + 1];
+        const length = readUInt16BE(bytes, offset + 2);
+        if ([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker)) {
+            return {
+                height: readUInt16BE(bytes, offset + 5),
+                width: readUInt16BE(bytes, offset + 7),
+            };
+        }
+        if (length < 2) {
+            break;
+        }
+        offset += 2 + length;
+    }
+    return {};
+}
+function readWebpDimensions(bytes) {
+    const chunkType = Buffer.from(bytes.slice(12, 16)).toString('ascii');
+    if (chunkType === 'VP8X' && bytes.byteLength >= 30) {
+        return {
+            width: 1 + readUInt24LE(bytes, 24),
+            height: 1 + readUInt24LE(bytes, 27),
+        };
+    }
+    if (chunkType === 'VP8 ' && bytes.byteLength >= 30) {
+        return {
+            width: readUInt16LE(bytes, 26) & 0x3fff,
+            height: readUInt16LE(bytes, 28) & 0x3fff,
+        };
+    }
+    if (chunkType === 'VP8L' && bytes.byteLength >= 25) {
+        const bits = readUInt32LE(bytes, 21);
+        return {
+            width: (bits & 0x3fff) + 1,
+            height: ((bits >> 14) & 0x3fff) + 1,
+        };
+    }
+    return {};
+}
+function readUInt16BE(bytes, offset) {
+    return (bytes[offset] << 8) | bytes[offset + 1];
+}
+function readUInt16LE(bytes, offset) {
+    return bytes[offset] | (bytes[offset + 1] << 8);
+}
+function readUInt24LE(bytes, offset) {
+    return bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16);
+}
+function readUInt32BE(bytes, offset) {
+    return (bytes[offset] * 2 ** 24) + (bytes[offset + 1] << 16) + (bytes[offset + 2] << 8) + bytes[offset + 3];
+}
+function readUInt32LE(bytes, offset) {
+    return bytes[offset] + (bytes[offset + 1] << 8) + (bytes[offset + 2] << 16) + (bytes[offset + 3] * 2 ** 24);
+}
+function firstString(value, keys) {
+    for (const key of keys) {
+        const item = value[key];
+        if (typeof item === 'string' && item.length > 0) {
+            return item;
+        }
+    }
+    return undefined;
+}
+function firstNumber(value, keys) {
+    for (const key of keys) {
+        const item = value[key];
+        if (typeof item === 'number' && Number.isFinite(item)) {
+            return item;
+        }
+    }
+    return undefined;
+}
+function isSupportedImageReference(value) {
+    return isDataImageUri(value) || (isHttpUrl(value) && imageExtensionPattern.test(value)) || isHttpUrl(value);
+}
+function isDataImageUri(value) {
+    return /^data:image\/[^;]+;base64,/i.test(value);
+}
+function isHttpUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+function inferMimeTypeFromUrl(url) {
+    const normalized = url.split('?')[0]?.toLowerCase() ?? url.toLowerCase();
+    if (normalized.endsWith('.png'))
+        return 'image/png';
+    if (normalized.endsWith('.jpg') || normalized.endsWith('.jpeg'))
+        return 'image/jpeg';
+    if (normalized.endsWith('.gif'))
+        return 'image/gif';
+    if (normalized.endsWith('.webp'))
+        return 'image/webp';
+    if (normalized.endsWith('.bmp'))
+        return 'image/bmp';
+    if (normalized.endsWith('.svg'))
+        return 'image/svg+xml';
+    return undefined;
+}

package/dist/utils/category.d.ts

@@ -0,0 +1,4 @@
+import { ServiceCategory } from '../types/common';
+export declare function serviceCategoryToMask(category: ServiceCategory): bigint;
+export declare function serviceCategoriesToMask(categories: ServiceCategory[]): bigint;
+export declare function isKnownServiceCategory(value: string): value is ServiceCategory;

package/dist/utils/category.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceCategoryToMask = serviceCategoryToMask;
+exports.serviceCategoriesToMask = serviceCategoriesToMask;
+exports.isKnownServiceCategory = isKnownServiceCategory;
+const common_1 = require("../types/common");
+const categoryBitIndex = {
+    text: 0,
+    code: 1,
+    image: 2,
+    audio: 3,
+    video: 4,
+    document: 5,
+    tool: 6,
+    workflow: 7,
+};
+function serviceCategoryToMask(category) {
+    return 1n << BigInt(categoryBitIndex[category]);
+}
+function serviceCategoriesToMask(categories) {
+    return categories.reduce((mask, category) => mask | serviceCategoryToMask(category), 0n);
+}
+function isKnownServiceCategory(value) {
+    return common_1.serviceCategoryValues.includes(value);
+}

package/dist/utils/date.d.ts

@@ -0,0 +1,2 @@
+export declare function nowIso(): string;
+export declare function addMinutes(date: Date, minutes: number): string;

package/dist/utils/date.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nowIso = nowIso;
+exports.addMinutes = addMinutes;
+function nowIso() {
+    return new Date().toISOString();
+}
+function addMinutes(date, minutes) {
+    return new Date(date.getTime() + minutes * 60_000).toISOString();
+}

package/dist/utils/hash.d.ts

@@ -0,0 +1,4 @@
+export declare function stableStringify(value: unknown): string;
+export declare function hashValue(value: unknown): string;
+export declare function hashText(value: string): string;
+export declare function hashBytes(value: Uint8Array | ArrayBuffer): string;

package/dist/utils/hash.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stableStringify = stableStringify;
+exports.hashValue = hashValue;
+exports.hashText = hashText;
+exports.hashBytes = hashBytes;
+const node_crypto_1 = require("node:crypto");
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    }
+    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(',')}}`;
+}
+function hashValue(value) {
+    return `0x${(0, node_crypto_1.createHash)('sha256').update(stableStringify(value)).digest('hex')}`;
+}
+function hashText(value) {
+    return `0x${(0, node_crypto_1.createHash)('sha256').update(value).digest('hex')}`;
+}
+function hashBytes(value) {
+    const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+    return `0x${(0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex')}`;
+}

package/dist/utils/id.d.ts

@@ -0,0 +1 @@
+export declare function createPrefixedId(prefix: string): string;

package/dist/utils/id.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrefixedId = createPrefixedId;
+const node_crypto_1 = require("node:crypto");
+function createPrefixedId(prefix) {
+    return `${prefix}_${(0, node_crypto_1.randomUUID)().replaceAll('-', '').slice(0, 16)}`;
+}

package/dist/utils/json-file.d.ts

@@ -0,0 +1,3 @@
+export declare function ensureDirectory(directoryPath: string): void;
+export declare function readJsonFile<T>(filePath: string): T;
+export declare function writeJsonFile(filePath: string, data: unknown): void;

package/dist/utils/json-file.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDirectory = ensureDirectory;
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function ensureDirectory(directoryPath) {
+    node_fs_1.default.mkdirSync(directoryPath, { recursive: true });
+}
+function readJsonFile(filePath) {
+    return JSON.parse(node_fs_1.default.readFileSync(filePath, 'utf8'));
+}
+function writeJsonFile(filePath, data) {
+    ensureDirectory(node_path_1.default.dirname(filePath));
+    node_fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}

package/dist/utils/schema.d.ts

@@ -0,0 +1,5 @@
+export type SchemaValidationResult = {
+    valid: boolean;
+    errors: string[];
+};
+export declare function validateSchema(data: unknown, schema: any): SchemaValidationResult;

package/dist/utils/schema.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSchema = validateSchema;
+function validateValue(value, schema, path, errors) {
+    if (!schema || typeof schema !== 'object') {
+        return;
+    }
+    if (schema.type === 'object') {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            errors.push(`${path} must be an object`);
+            return;
+        }
+        const record = value;
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        for (const key of required) {
+            if (!(key in record)) {
+                errors.push(`${path}.${key} is required`);
+            }
+        }
+        const properties = schema.properties ?? {};
+        for (const [key, nestedSchema] of Object.entries(properties)) {
+            if (key in record) {
+                validateValue(record[key], nestedSchema, `${path}.${key}`, errors);
+            }
+        }
+        return;
+    }
+    if (schema.type === 'array') {
+        if (!Array.isArray(value)) {
+            errors.push(`${path} must be an array`);
+            return;
+        }
+        if (typeof schema.minItems === 'number' && value.length < schema.minItems) {
+            errors.push(`${path} must contain at least ${schema.minItems} items`);
+        }
+        if (schema.items) {
+            value.forEach((item, index) => validateValue(item, schema.items, `${path}[${index}]`, errors));
+        }
+        return;
+    }
+    if (schema.type === 'string') {
+        if (typeof value !== 'string') {
+            errors.push(`${path} must be a string`);
+            return;
+        }
+        if (typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
+            errors.push(`${path} exceeds maxLength ${schema.maxLength}`);
+        }
+        if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
+            errors.push(`${path} must be one of: ${schema.enum.join(', ')}`);
+        }
+        return;
+    }
+    if (schema.type === 'number' && typeof value !== 'number') {
+        errors.push(`${path} must be a number`);
+        return;
+    }
+    if (schema.type === 'boolean' && typeof value !== 'boolean') {
+        errors.push(`${path} must be a boolean`);
+    }
+}
+function validateSchema(data, schema) {
+    const errors = [];
+    validateValue(data, schema, '$', errors);
+    return { valid: errors.length === 0, errors };
+}

package/dist/x402/payment.d.ts

@@ -0,0 +1,11 @@
+import { PaymentAuthorization, PaymentRequirement } from '../types/x402';
+type MessageSigner = {
+    address: string;
+    signMessage(message: string): Promise<string>;
+};
+export declare function encodePaymentRequirement(requirement: PaymentRequirement): string;
+export declare function decodePaymentRequirement(encodedRequirement: string): PaymentRequirement;
+export declare function createPaymentAuthorizationMessage(requirement: PaymentRequirement, requesterAddress: string): string;
+export declare function signPaymentRequirement(wallet: MessageSigner, requirement: PaymentRequirement, network?: string): Promise<PaymentAuthorization>;
+export declare function verifyPaymentAuthorization(requirement: PaymentRequirement, authorization: PaymentAuthorization): boolean;
+export {};

package/dist/x402/payment.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodePaymentRequirement = encodePaymentRequirement;
+exports.decodePaymentRequirement = decodePaymentRequirement;
+exports.createPaymentAuthorizationMessage = createPaymentAuthorizationMessage;
+exports.signPaymentRequirement = signPaymentRequirement;
+exports.verifyPaymentAuthorization = verifyPaymentAuthorization;
+const ethers_1 = require("ethers");
+const x402_1 = require("../types/x402");
+const hash_1 = require("../utils/hash");
+function encodePaymentRequirement(requirement) {
+    return Buffer.from(JSON.stringify(x402_1.PaymentRequirementSchema.parse(requirement))).toString('base64');
+}
+function decodePaymentRequirement(encodedRequirement) {
+    return x402_1.PaymentRequirementSchema.parse(JSON.parse(Buffer.from(encodedRequirement, 'base64').toString('utf8')));
+}
+function createPaymentAuthorizationMessage(requirement, requesterAddress) {
+    const accept = requirement.accepts.find((option) => option.network === requirement.accepts[0]?.network) ?? requirement.accepts[0];
+    return (0, hash_1.hashValue)({
+        quoteId: requirement.quoteId,
+        network: accept.network,
+        amount: accept.amount,
+        token: accept.token,
+        payTo: accept.payTo,
+        memo: accept.memo,
+        expiresAt: requirement.expiresAt,
+        requesterAddress,
+    });
+}
+async function signPaymentRequirement(wallet, requirement, network) {
+    const requesterAddress = (0, ethers_1.getAddress)(wallet.address);
+    const accept = requirement.accepts.find((option) => option.network === network) ?? requirement.accepts[0];
+    const message = (0, hash_1.hashValue)({
+        quoteId: requirement.quoteId,
+        network: accept.network,
+        amount: accept.amount,
+        token: accept.token,
+        payTo: accept.payTo,
+        memo: accept.memo,
+        expiresAt: requirement.expiresAt,
+        requesterAddress,
+    });
+    const signature = await wallet.signMessage(message);
+    return {
+        quoteId: requirement.quoteId,
+        network: accept.network,
+        amount: accept.amount,
+        token: accept.token,
+        payTo: accept.payTo,
+        memo: accept.memo,
+        expiresAt: requirement.expiresAt,
+        requesterAddress,
+        signature,
+    };
+}
+function verifyPaymentAuthorization(requirement, authorization) {
+    const message = (0, hash_1.hashValue)({
+        quoteId: requirement.quoteId,
+        network: authorization.network,
+        amount: authorization.amount,
+        token: authorization.token,
+        payTo: authorization.payTo,
+        memo: authorization.memo,
+        expiresAt: requirement.expiresAt,
+        requesterAddress: authorization.requesterAddress,
+    });
+    return (0, ethers_1.getAddress)((0, ethers_1.verifyMessage)(message, authorization.signature)) === (0, ethers_1.getAddress)(authorization.requesterAddress);
+}