@keelcodes/sdk 2.2.0 → 2.3.0

package/dist/aa/userop.js

@@ -0,0 +1,100 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// UserOp v0.7 构建 / 编码 / 哈希（ERC-4337）
+//
+// callData = Kernel v3 execute(execMode, executionCalldata)（ERC-7579 单调用）
+// userOpHash = viem getUserOperationHash（v0.7 EIP-712，含 chainId 防跨链重放）
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXECUTE_USER_OP_SELECTOR = void 0;
+exports.encodeExecute = encodeExecute;
+exports.encodeExecuteUserOp = encodeExecuteUserOp;
+exports.buildUserOpWithCallData = buildUserOpWithCallData;
+exports.getUserOpHash = getUserOpHash;
+exports.userOpToRpc = userOpToRpc;
+const viem_1 = require("viem");
+const account_abstraction_1 = require("viem/account-abstraction");
+/** Kernel v3 execute ABI（ERC-7579：execMode + executionCalldata） */
+const KernelV3ExecuteAbi = [
+    {
+        type: 'function',
+        name: 'execute',
+        inputs: [
+            { name: 'execMode', type: 'bytes32', internalType: 'ExecMode' },
+            { name: 'executionCalldata', type: 'bytes', internalType: 'bytes' },
+        ],
+        outputs: [],
+        stateMutability: 'payable',
+    },
+];
+/** DEFAULT execMode（root / call / no-revert-on-error）→ 全零 bytes32 */
+const DEFAULT_EXEC_MODE = '0x0000000000000000000000000000000000000000000000000000000000000000';
+/** 编码 Kernel v3 单调用 callData：executionCalldata = target ‖ value(32B) ‖ data */
+function encodeExecute(target, value, data) {
+    return (0, viem_1.encodeFunctionData)({
+        abi: KernelV3ExecuteAbi,
+        functionName: 'execute',
+        args: [DEFAULT_EXEC_MODE, (0, viem_1.concatHex)([target, (0, viem_1.toHex)(value ?? 0n, { size: 32 }), data ?? '0x'])],
+    });
+}
+/**
+ * IAccountExecute.executeUserOp selector（ERC-4337 v0.7）。
+ * 挂 KeelPolicyHook 的 session 配置下，Kernel 在验证期强制 callData 以它开头。
+ */
+exports.EXECUTE_USER_OP_SELECTOR = '0x8dd7712f';
+/** 外层包装：executeUserOp.selector ‖ execute(...)（Route C / 挂真 hook 时必需） */
+function encodeExecuteUserOp(executeCallData) {
+    return (0, viem_1.concatHex)([exports.EXECUTE_USER_OP_SELECTOR, executeCallData]);
+}
+/** 以已编码 callData 构建 UserOp v0.7（未签名）。 */
+function buildUserOpWithCallData(params) {
+    return {
+        sender: params.sender,
+        nonce: params.nonce,
+        factory: params.factory,
+        factoryData: params.factoryData,
+        callData: params.callData,
+        callGasLimit: params.gas?.callGasLimit ?? 0n,
+        verificationGasLimit: params.gas?.verificationGasLimit ?? 0n,
+        preVerificationGas: params.gas?.preVerificationGas ?? 0n,
+        maxFeePerGas: params.gas?.maxFeePerGas ?? 0n,
+        maxPriorityFeePerGas: params.gas?.maxPriorityFeePerGas ?? 0n,
+        signature: '0x',
+    };
+}
+/** EIP-712 userOpHash（v0.7 标准，含 chainId）。 */
+function getUserOpHash(op, entryPoint, chainId) {
+    return (0, account_abstraction_1.getUserOperationHash)({
+        chainId,
+        entryPointAddress: entryPoint,
+        entryPointVersion: '0.7',
+        userOperation: op,
+    });
+}
+/** UserOp v0.7 → bundler RPC 参数（bigint → hex；paymaster 字段缺省剔除）。 */
+function userOpToRpc(op) {
+    const rpc = {
+        sender: op.sender,
+        nonce: (0, viem_1.toHex)(op.nonce),
+        factory: op.factory,
+        factoryData: op.factoryData,
+        callData: op.callData,
+        callGasLimit: (0, viem_1.toHex)(op.callGasLimit),
+        verificationGasLimit: (0, viem_1.toHex)(op.verificationGasLimit),
+        preVerificationGas: (0, viem_1.toHex)(op.preVerificationGas),
+        maxFeePerGas: (0, viem_1.toHex)(op.maxFeePerGas),
+        maxPriorityFeePerGas: (0, viem_1.toHex)(op.maxPriorityFeePerGas),
+        signature: op.signature,
+    };
+    if (op.paymaster) {
+        rpc.paymaster = op.paymaster;
+        if (op.paymasterVerificationGasLimit !== undefined) {
+            rpc.paymasterVerificationGasLimit = (0, viem_1.toHex)(op.paymasterVerificationGasLimit);
+        }
+        if (op.paymasterPostOpGasLimit !== undefined) {
+            rpc.paymasterPostOpGasLimit = (0, viem_1.toHex)(op.paymasterPostOpGasLimit);
+        }
+        rpc.paymasterData = op.paymasterData;
+    }
+    return rpc;
+}

package/dist/aa/x402-session.d.ts

@@ -0,0 +1,96 @@
+import { type Address, type Hex } from 'viem';
+import type { BundlerLike, ChainAAConfig, SessionPolicy, Signer, UserOperationV7 } from './types';
+import { type X402Accept, type X402Payment, type X402PaymentPayload, type X402PaymentRequired, type X402TypedData } from './x402';
+/** Kernel 包装结构类型哈希：`Kernel(bytes32 hash)` */
+export declare const KERNEL_WRAPPER_TYPE_HASH: Hex;
+/** Kernel EIP-712 domain */
+export declare const KERNEL_DOMAIN_NAME = "Kernel";
+export declare const KERNEL_DOMAIN_VERSION = "0.3.1";
+/**
+ * Kernel ERC-1271 包装摘要：与 `Kernel._toWrappedHash` 完全一致
+ * （domain = Kernel/0.3.1/chainId/account）。
+ */
+export declare function kernelWrappedDigest(args: {
+    account: Address;
+    chainId: number;
+    digest: Hex;
+    kernelVersion?: string;
+}): Hex;
+/**
+ * session key 在 ERC-1271 场景要签的摘要：
+ *   keccak256(kernelWrapped(x402Digest) ‖ keccak256(policyData))
+ * —— 与 `KeelSessionValidator.isValidSignatureWithSender` 逐字节一致。
+ */
+export declare function sessionX402Digest(args: {
+    typed: X402TypedData;
+    account: Address;
+    chainId: number;
+    policy: SessionPolicy;
+    kernelVersion?: string;
+}): Hex;
+export interface SignX402WithSessionParams {
+    /** x402 待签结构（由 {@link buildX402TypedData} 生成） */
+    typed: X402TypedData;
+    chainConfig: ChainAAConfig;
+    account: Address;
+    policy: SessionPolicy;
+    /** session validator 副本 slot（一 key 一副本） */
+    slot: number;
+    /** session key（客户端自持） */
+    sessionSigner: Signer;
+}
+/**
+ * 产出可直接放进 x402 `payload.signature` 的 ERC-1271 签名：
+ *   `0x01 ‖ validator ‖ sessionId ‖ policyData ‖ sessionKeySig`
+ */
+export declare function signX402WithSession(p: SignX402WithSessionParams): Promise<Hex>;
+export interface PayX402WithSessionParams {
+    challenge: X402PaymentRequired;
+    /** 指定 accept；缺省按 `token` 自动匹配（只接受稳定币） */
+    accept?: X402Accept;
+    chainConfig: ChainAAConfig;
+    account: Address;
+    policy: SessionPolicy;
+    slot: number;
+    sessionSigner: Signer;
+    /** 查询 nonce（viem PublicClient 可直接传入） */
+    publicClient: {
+        readContract: (args: any) => Promise<unknown>;
+    };
+    bundler: BundlerLike;
+    /** KeelTokenPaymaster：gas 由它垫付，按 token 向账户结算 */
+    paymaster: {
+        address: Address;
+        token: Address;
+        /** 客户端自报价（可选，只有比链上价更保守才生效） */
+        clientPrice?: bigint;
+        validationGasLimit?: bigint;
+        postOpGasLimit?: bigint;
+    };
+    /** EIP-1559 费用（调用方按链取实时值；BSC 必须给非零 tip） */
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    /** agent 通道号（nonceKey 隔离并发 agent），缺省 0 */
+    agentIndex?: number;
+    method?: string;
+    url?: string;
+    salt?: Hex;
+}
+export interface PayX402WithSessionResult {
+    /** 可直接写入 `PAYMENT-SIGNATURE` 头 */
+    header: string;
+    payload: X402PaymentPayload;
+    /** 链上付款交易哈希（= payload.payload.txHash） */
+    txHash: Hex;
+    userOpHash: Hex;
+    payment: X402Payment;
+    userOp: UserOperationV7;
+    accept: X402Accept;
+}
+/**
+ * 一次完成「链上付款 + gas 垫付 + x402 凭证签名」。
+ *
+ * 流程：session key 签 UserOp（ERC-20 transfer → payTo，paymaster 计费）
+ *      → bundler 广播并等待收据 → 组 x402 payload → session key 产 ERC-1271 签名。
+ */
+export declare function payX402WithSession(p: PayX402WithSessionParams): Promise<PayX402WithSessionResult>;

package/dist/aa/x402-session.js

@@ -0,0 +1,203 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// x402 + Keel session 整合：agent 自主付款 + paymaster 垫付 gas
+//
+// 闭环：
+//   1. agent 用 session key 签一笔 UserOp：ERC-20 transfer → x402 payTo
+//   2. 同一笔 UserOp 由 KeelTokenPaymaster 计费（gas 从 paymaster deposit 垫付，
+//      账户以同一 token 结算）——零 native
+//   3. 上链后 session key 再产一份 ERC-1271 签名，作为 x402 `PAYMENT-SIGNATURE`
+//      （服务端用 `Kernel.isValidSignature` 校验，返回 0x1626ba7e）
+//
+// 签名布局：
+//   UserOp.signature = sessionId(32B) ‖ policyData ‖ agentSig(65B)
+//   ERC-1271 sig     = 0x01 ‖ validator(20B) ‖ sessionId(32B) ‖ policyData ‖ agentSig(65B)
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KERNEL_DOMAIN_VERSION = exports.KERNEL_DOMAIN_NAME = exports.KERNEL_WRAPPER_TYPE_HASH = void 0;
+exports.kernelWrappedDigest = kernelWrappedDigest;
+exports.sessionX402Digest = sessionX402Digest;
+exports.signX402WithSession = signX402WithSession;
+exports.payX402WithSession = payX402WithSession;
+const viem_1 = require("viem");
+const keel_session_1 = require("./keel-session");
+const nonce_1 = require("./nonce");
+const token_paymaster_1 = require("./token-paymaster");
+const userop_1 = require("./userop");
+const x402_1 = require("./x402");
+/** Kernel 包装结构类型哈希：`Kernel(bytes32 hash)` */
+exports.KERNEL_WRAPPER_TYPE_HASH = '0x1547321c374afde8a591d972a084b071c594c275e36724931ff96c25f2999c83';
+/** Kernel EIP-712 domain */
+exports.KERNEL_DOMAIN_NAME = 'Kernel';
+exports.KERNEL_DOMAIN_VERSION = '0.3.1';
+/** VALIDATION_TYPE_VALIDATOR：ERC-1271 签名首字节 */
+const VALIDATION_TYPE_VALIDATOR_PREFIX = '0x01';
+const ENTRYPOINT_NONCE_ABI = (0, viem_1.parseAbi)([
+    'function getNonce(address sender, uint192 key) view returns (uint256)',
+]);
+/**
+ * 估算前的占位 gas 上限。
+ * ⚠️ 不能开太大：token paymaster 在 validation 阶段按
+ * `maxFeePerGas × 全部 gas 上限` **预扣** token（postOp 退差），
+ * ETH 主网上一笔 2M/1.2M 的占位就能预扣 ~2.4 USDC，小额账户直接 AA33。
+ * 真实用量 ~300k，这里 800k/600k 已留足余量。
+ */
+const DEFAULT_OP_GAS = {
+    callGasLimit: 800000n,
+    verificationGasLimit: 600000n,
+    preVerificationGas: 100000n,
+};
+/** paymaster 两段 gas 上限默认值；postOp 必须 ≥ refundPostopCost(40000) */
+const DEFAULT_PAYMASTER_GAS = {
+    paymasterVerificationGasLimit: 200000n,
+    paymasterPostOpGasLimit: 60000n,
+};
+/**
+ * Kernel ERC-1271 包装摘要：与 `Kernel._toWrappedHash` 完全一致
+ * （domain = Kernel/0.3.1/chainId/account）。
+ */
+function kernelWrappedDigest(args) {
+    return (0, viem_1.hashTypedData)({
+        domain: {
+            name: exports.KERNEL_DOMAIN_NAME,
+            version: args.kernelVersion ?? exports.KERNEL_DOMAIN_VERSION,
+            chainId: args.chainId,
+            verifyingContract: args.account,
+        },
+        types: { Kernel: [{ name: 'hash', type: 'bytes32' }] },
+        primaryType: 'Kernel',
+        message: { hash: args.digest },
+    });
+}
+/**
+ * session key 在 ERC-1271 场景要签的摘要：
+ *   keccak256(kernelWrapped(x402Digest) ‖ keccak256(policyData))
+ * —— 与 `KeelSessionValidator.isValidSignatureWithSender` 逐字节一致。
+ */
+function sessionX402Digest(args) {
+    const x402Digest = (0, viem_1.hashTypedData)(args.typed);
+    const wrapped = kernelWrappedDigest({
+        account: args.account,
+        chainId: args.chainId,
+        digest: x402Digest,
+        kernelVersion: args.kernelVersion,
+    });
+    return (0, viem_1.keccak256)((0, viem_1.concatHex)([wrapped, (0, viem_1.keccak256)((0, keel_session_1.encodeKeelPolicyData)(args.policy))]));
+}
+/**
+ * 产出可直接放进 x402 `payload.signature` 的 ERC-1271 签名：
+ *   `0x01 ‖ validator ‖ sessionId ‖ policyData ‖ sessionKeySig`
+ */
+async function signX402WithSession(p) {
+    const validator = (0, keel_session_1.resolveKeelValidator)(p.chainConfig, p.slot);
+    const policyData = (0, keel_session_1.encodeKeelPolicyData)(p.policy);
+    const digest = sessionX402Digest({
+        typed: p.typed,
+        account: p.account,
+        chainId: p.chainConfig.chainId,
+        policy: p.policy,
+        kernelVersion: p.chainConfig.kernelVersion,
+    });
+    const sig = await p.sessionSigner.signUserOp(digest);
+    return (0, viem_1.concatHex)([
+        VALIDATION_TYPE_VALIDATOR_PREFIX,
+        validator,
+        (0, keel_session_1.toBytes32)(p.policy.sessionId),
+        policyData,
+        sig,
+    ]);
+}
+/**
+ * 一次完成「链上付款 + gas 垫付 + x402 凭证签名」。
+ *
+ * 流程：session key 签 UserOp（ERC-20 transfer → payTo，paymaster 计费）
+ *      → bundler 广播并等待收据 → 组 x402 payload → session key 产 ERC-1271 签名。
+ */
+async function payX402WithSession(p) {
+    const accept = p.accept ??
+        (0, x402_1.selectX402Accept)(p.challenge, {
+            asset: p.paymaster.token,
+            network: `eip155:${p.chainConfig.chainId}`,
+        });
+    const payment = (0, x402_1.buildX402Payment)(accept);
+    const validator = (0, keel_session_1.resolveKeelValidator)(p.chainConfig, p.slot);
+    const nonceKey = (0, nonce_1.validatorNonceKey)(validator, p.agentIndex ?? 0);
+    const nonce = (await p.publicClient.readContract({
+        address: p.chainConfig.entryPoint,
+        abi: ENTRYPOINT_NONCE_ABI,
+        functionName: 'getNonce',
+        args: [p.account, nonceKey],
+    }));
+    const paymasterGas = {
+        paymasterVerificationGasLimit: p.paymaster.validationGasLimit ?? DEFAULT_PAYMASTER_GAS.paymasterVerificationGasLimit,
+        paymasterPostOpGasLimit: p.paymaster.postOpGasLimit ?? DEFAULT_PAYMASTER_GAS.paymasterPostOpGasLimit,
+    };
+    /** 构建未签名 session op（paymaster 字段必须在签名前就位：userOpHash 覆盖它们） */
+    const buildOp = (gas) => ({
+        ...(0, userop_1.buildUserOpWithCallData)({
+            sender: p.account,
+            nonce,
+            callData: (0, userop_1.encodeExecuteUserOp)((0, userop_1.encodeExecute)(payment.to, payment.value, payment.data)),
+            gas: {
+                ...gas,
+                maxFeePerGas: p.maxFeePerGas,
+                maxPriorityFeePerGas: p.maxPriorityFeePerGas,
+            },
+        }),
+        paymaster: p.paymaster.address,
+        paymasterData: (0, token_paymaster_1.buildTokenPaymasterData)({
+            token: p.paymaster.token,
+            clientPrice: p.paymaster.clientPrice,
+        }),
+        ...paymasterGas,
+    });
+    const policyData = (0, keel_session_1.encodeKeelPolicyData)(p.policy);
+    const signOp = async (op) => {
+        const hash = (0, userop_1.getUserOpHash)(op, p.chainConfig.entryPoint, p.chainConfig.chainId);
+        const sig = await p.sessionSigner.signUserOp((0, keel_session_1.keelSessionDigest)(hash, policyData));
+        return {
+            ...op,
+            signature: (0, keel_session_1.encodeKeelSessionSignature)({ sessionId: p.policy.sessionId, policyData, sig }),
+        };
+    };
+    // 估算必须先签名（bundler 会跑真实验证），因此用占位 gas 签一次
+    const probe = await signOp(buildOp(DEFAULT_OP_GAS));
+    const est = await p.bundler.estimateUserOperationGas(probe);
+    const op = await signOp(buildOp({
+        callGasLimit: est.callGasLimit ?? DEFAULT_OP_GAS.callGasLimit,
+        verificationGasLimit: est.verificationGasLimit ?? DEFAULT_OP_GAS.verificationGasLimit,
+        preVerificationGas: est.preVerificationGas ?? DEFAULT_OP_GAS.preVerificationGas,
+    }));
+    const sent = await p.bundler.sendUserOperation(op);
+    if (!sent.receipt?.success) {
+        throw new Error(`[keel-sdk] x402 payment UserOp failed (hash ${sent.userOpHash}): ${JSON.stringify(sent.receipt)}`);
+    }
+    const txHash = sent.receipt.txHash;
+    if (!txHash)
+        throw new Error('[keel-sdk] bundler receipt has no transactionHash');
+    const unsigned = (0, x402_1.buildX402Payload)({
+        challenge: p.challenge,
+        accepted: accept,
+        txHash,
+        method: p.method,
+        url: p.url,
+        salt: p.salt,
+    });
+    unsigned.signature = await signX402WithSession({
+        typed: (0, x402_1.buildX402TypedData)(unsigned),
+        chainConfig: p.chainConfig,
+        account: p.account,
+        policy: p.policy,
+        slot: p.slot,
+        sessionSigner: p.sessionSigner,
+    });
+    return {
+        header: (0, x402_1.encodePaymentSignature)(unsigned),
+        payload: unsigned,
+        txHash,
+        userOpHash: sent.userOpHash,
+        payment,
+        userOp: op,
+        accept,
+    };
+}

package/dist/aa/x402.d.ts

@@ -0,0 +1,144 @@
+import { type Address, type Hex } from 'viem';
+export interface X402Accept {
+    scheme: 'exact' | 'upto';
+    network: string;
+    amount: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra?: Record<string, unknown>;
+}
+export interface X402ResourceInfo {
+    url: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface X402PaymentRequired {
+    x402Version: 2;
+    error?: string;
+    resource?: X402ResourceInfo;
+    accepts: X402Accept[];
+    extensions?: Record<string, unknown>;
+}
+export interface X402PaymentPayload {
+    x402Version: 2;
+    resource?: X402ResourceInfo;
+    accepted: X402Accept;
+    payload: {
+        method: string;
+        url: string;
+        salt: Hex;
+        txHash: Hex;
+    };
+    extensions?: Record<string, unknown>;
+    signature: Hex;
+}
+export interface X402Payment {
+    /** 交易目标：native → payTo；token → token 合约 */
+    to: Address;
+    value: bigint;
+    data: Hex;
+    /** 计费资产（native 为 0x0 哨兵） */
+    asset: Address;
+}
+export interface X402TypedData {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: Address;
+    };
+    types: {
+        Payment: readonly {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: 'Payment';
+    message: Record<string, string>;
+}
+export interface PayX402Params {
+    challenge: X402PaymentRequired;
+    /** 不传则按 asset/network 自动选第一个可用 accept */
+    accept?: X402Accept;
+    /** 发起链上付款并返回 txHash */
+    sendPayment: (payment: X402Payment) => Promise<Hex>;
+    /** EIP-712 签名（EOA 用 walletClient.signTypedData；智能账户用其 1271 签名） */
+    signTypedData: (typed: X402TypedData) => Promise<Hex>;
+    /** 等 tx 上链（建议传入，避免服务端 verify 时查不到 receipt） */
+    waitForTransaction?: (hash: Hex) => Promise<unknown>;
+    method?: string;
+    url?: string;
+    /** 覆盖盐值（默认由 txHash + 时间派生） */
+    salt?: Hex;
+}
+export declare const X402_DOMAIN_NAME = "x402";
+export declare const X402_DOMAIN_VERSION = "2";
+export declare const X402_TYPES: {
+    readonly Payment: readonly [{
+        readonly name: "scheme";
+        readonly type: "string";
+    }, {
+        readonly name: "network";
+        readonly type: "string";
+    }, {
+        readonly name: "amount";
+        readonly type: "string";
+    }, {
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly name: "payTo";
+        readonly type: "address";
+    }, {
+        readonly name: "method";
+        readonly type: "string";
+    }, {
+        readonly name: "url";
+        readonly type: "string";
+    }, {
+        readonly name: "salt";
+        readonly type: "string";
+    }, {
+        readonly name: "txHash";
+        readonly type: "string";
+    }];
+};
+/** 解 `PAYMENT-REQUIRED` 头（base64 或直接 JSON）。 */
+export declare function decodePaymentRequired(header: string): X402PaymentRequired;
+/** 选 accept：优先 exact，其次按传入的 asset / network 过滤。 */
+export declare function selectX402Accept(challenge: X402PaymentRequired, opts?: {
+    asset?: string;
+    network?: string;
+}): X402Accept;
+/** 按 accept 组装链上付款参数（native 转账或 ERC20 transfer）。 */
+export declare function buildX402Payment(accept: X402Accept): X402Payment;
+/** 构造待签的 EIP-712 结构（必须与 payments 侧逐字段一致）。 */
+export declare function buildX402TypedData(payload: X402PaymentPayload): X402TypedData;
+/**
+ * 已有签名时组装 `PAYMENT-SIGNATURE` 头（base64）。
+ * 配合 {@link buildX402TypedData} + `wallet.signTypedData` 用于纯 EOA 客户端。
+ */
+export declare function encodePaymentSignature(payload: X402PaymentPayload): string;
+/** 由链上付款结果构造未签名的 payload（salt 缺省自动派生）。 */
+export declare function buildX402Payload(args: {
+    challenge: X402PaymentRequired;
+    accepted: X402Accept;
+    txHash: Hex;
+    method?: string;
+    url?: string;
+    salt?: Hex;
+}): X402PaymentPayload;
+/**
+ * 完成一次 x402 付款：发起链上支付 → 等确认 → 构造并签名 PaymentPayload。
+ * @returns `header` 可直接写入 `PAYMENT-SIGNATURE`。
+ */
+export declare function payX402(params: PayX402Params): Promise<{
+    header: string;
+    payload: X402PaymentPayload;
+    txHash: Hex;
+    payment: X402Payment;
+}>;
+/** 供调试：把任意 32 字节值转成 x402 salt 形态 */
+export declare function toX402Salt(value: bigint | number): Hex;
+export declare function toBase64(text: string): string;