@zero-two-labs/sekisho 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zero Two Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,97 @@
-# Temporary Holding Version
+# Sekisho 関所
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**x402 payments with automatic revenue split on Avalanche.**
+
+Sekisho turns any API or MCP tool into a paid endpoint that AI agents can pay for with USDC, using the [x402](https://x402.org) protocol. Every payment lands in the seller's on-chain **SplitVault**, which distributes the platform fee and the seller's share automatically.
+
+> Status: `v0.1.0` — Avalanche Fuji testnet.
+
+## Install
+
+```bash
+npm install @zero-two-labs/sekisho viem
+```
+
+## How it works
+
+```
+Agent ──(x402, USDC)──▶ Seller's SplitVault ──distribute()──┬──▶ Platform fee
+                              ▲                              └──▶ Seller
+                              │
+                     SplitVaultFactory (one vault per seller, deterministic address)
+```
+
+- Each seller gets a **deterministic vault address** (`payTo`) — payments can arrive before the vault is deployed.
+- `distribute()` is permissionless: funds can only go to the seller and the platform treasury.
+- Platform fee is hard-capped at **10%** in the contract.
+
+## Usage
+
+### 1. Read vaults and split payments
+
+```ts
+import { createSekishoClient } from "@zero-two-labs/sekisho";
+
+const sekisho = createSekishoClient({ network: "avalancheFuji" });
+
+const payTo = await sekisho.getPayTo("0xSeller...");
+const { total, fee, merchantAmount } = await sekisho.pending("0xSeller...");
+```
+
+### 2. Sell an HTTP endpoint (Hono example)
+
+```ts
+import { paymentMiddleware, x402ResourceServer } from "@x402/hono";
+import { ExactEvmScheme } from "@x402/evm/exact/server";
+import {
+  createSekishoClient,
+  createPaymentOption,
+  createSekishoFacilitator,
+  toFacilitatorClient,
+} from "@zero-two-labs/sekisho";
+
+const sekisho = createSekishoClient({ network: "avalancheFuji" });
+const option = await createPaymentOption(sekisho, { merchant: "0xSeller...", price: "0.01" });
+
+const facilitator = createSekishoFacilitator({ account: facilitatorAccount });
+const server = new x402ResourceServer(toFacilitatorClient(facilitator))
+  .register(option.network, new ExactEvmScheme());
+
+app.use(paymentMiddleware({ "GET /premium": { accepts: [option] } }, server));
+```
+
+### 3. Pay as an agent (with spend limits)
+
+```ts
+import { createSekishoFetch } from "@zero-two-labs/sekisho";
+
+const { fetch: payFetch } = createSekishoFetch({ account, maxPerPayment: "0.05" });
+const res = await payFetch("https://api.example.com/premium");
+```
+
+### 4. Paid MCP tools
+
+```ts
+import { createSekishoMcpPaywall, createSekishoMcpClient } from "@zero-two-labs/sekisho";
+
+// Server
+const paid = await createSekishoMcpPaywall({
+  sekisho, facilitator, merchant: "0xSeller...", price: "0.01",
+  onSettled: () => sekisho.distribute("0xSeller..."),
+});
+mcpServer.tool("premium_insight", "Costs 0.01 USDC", { topic: z.string() }, paid(handler));
+
+// Agent
+const client = createSekishoMcpClient({ account, maxPerPayment: "0.05" });
+const result = await client.callTool("premium_insight", { topic: "Avalanche" });
+```
+
+## Deployments
+
+| Network | SplitVaultFactory | USDC |
+| --- | --- | --- |
+| Avalanche Fuji (`eip155:43113`) | [`0xA1967201adD1Ac57d1c72D04Ca4d9159B98C8C5D`](https://testnet.snowtrace.io/address/0xA1967201adD1Ac57d1c72D04Ca4d9159B98C8C5D) | `0x5425890298aed601595a70AB815c96711a31Bc65` |
+
+## License
+
+MIT © Zero Two Labs

package/dist/abi.d.ts

@@ -0,0 +1,104 @@
+export declare const splitVaultFactoryAbi: readonly [{
+    readonly name: "predictVault";
+    readonly type: 'function';
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "merchant";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "vaultOf";
+    readonly type: 'function';
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "merchant";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "treasury";
+    readonly type: 'function';
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "feeBps";
+    readonly type: 'function';
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint16";
+    }];
+}, {
+    readonly name: "createVault";
+    readonly type: 'function';
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "merchant";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "vault";
+    }];
+}];
+export declare const splitVaultAbi: readonly [{
+    readonly name: "merchant";
+    readonly type: 'function';
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "pending";
+    readonly type: 'function';
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "token";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "total";
+    }, {
+        readonly type: "uint256";
+        readonly name: "fee";
+    }, {
+        readonly type: "uint256";
+        readonly name: "merchantAmount";
+    }];
+}, {
+    readonly name: "distribute";
+    readonly type: 'function';
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "token";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "fee";
+    }, {
+        readonly type: "uint256";
+        readonly name: "merchantAmount";
+    }];
+}];
+export declare const erc20Abi: readonly [{
+    readonly name: "balanceOf";
+    readonly type: 'function';
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];

package/dist/abi.js

@@ -0,0 +1,16 @@
+import { parseAbi } from "viem";
+export const splitVaultFactoryAbi = parseAbi([
+    "function predictVault(address merchant) view returns (address)",
+    "function vaultOf(address merchant) view returns (address)",
+    "function treasury() view returns (address)",
+    "function feeBps() view returns (uint16)",
+    "function createVault(address merchant) returns (address vault)",
+]);
+export const splitVaultAbi = parseAbi([
+    "function merchant() view returns (address)",
+    "function pending(address token) view returns (uint256 total, uint256 fee, uint256 merchantAmount)",
+    "function distribute(address token) returns (uint256 fee, uint256 merchantAmount)",
+]);
+export const erc20Abi = parseAbi([
+    "function balanceOf(address) view returns (uint256)",
+]);

package/dist/agent.d.ts

@@ -0,0 +1,26 @@
+import { x402Client } from "@x402/core/client";
+import { x402HTTPClient } from "@x402/fetch";
+import { type LocalAccount } from "viem";
+import { type SekishoNetwork } from "./chains.js";
+export interface SekishoAgentOptions {
+    /** Cuenta del agente que firma los pagos (viem LocalAccount). */
+    account: LocalAccount;
+    network?: SekishoNetwork;
+    /** Máximo a pagar por petición, en USD. Por defecto "1". */
+    maxPerPayment?: string;
+}
+/** @deprecated Usa SekishoAgentOptions. Se mantiene por compatibilidad. */
+export type SekishoFetchOptions = SekishoAgentOptions;
+export interface SekishoFetch {
+    /** fetch que paga automáticamente cuando recibe un 402. */
+    fetch: typeof fetch;
+    /** Utilidad oficial de x402 para leer el resultado del pago. */
+    httpClient: x402HTTPClient;
+}
+/**
+ * Cliente de pagos x402 para agentes: autoriza el USDC de la red
+ * de Sekisho y aplica un tope por pago.
+ */
+export declare function createSekishoPaymentClient(options: SekishoAgentOptions): x402Client;
+/** fetch con pagos x402 automáticos. */
+export declare function createSekishoFetch(options: SekishoAgentOptions): SekishoFetch;

package/dist/agent.js

@@ -0,0 +1,31 @@
+import { x402Client } from "@x402/core/client";
+import { wrapFetchWithPayment, x402HTTPClient } from "@x402/fetch";
+import { ExactEvmScheme } from "@x402/evm/exact/client";
+import { parseUnits } from "viem";
+import { NETWORKS } from "./chains.js";
+/**
+ * Cliente de pagos x402 para agentes: autoriza el USDC de la red
+ * de Sekisho y aplica un tope por pago.
+ */
+export function createSekishoPaymentClient(options) {
+    const network = options.network ?? "avalancheFuji";
+    const config = NETWORKS[network];
+    const caip2 = `eip155:${config.chain.id}`;
+    const maxAtomic = parseUnits(options.maxPerPayment ?? "1", 6).toString();
+    return x402Client.fromConfig({
+        schemes: [{ network: caip2, client: new ExactEvmScheme(options.account) }],
+        spendControls: {
+            allowedAssets: [
+                { network: caip2, asset: config.usdc, maxAmountPerPayment: maxAtomic },
+            ],
+        },
+    });
+}
+/** fetch con pagos x402 automáticos. */
+export function createSekishoFetch(options) {
+    const client = createSekishoPaymentClient(options);
+    return {
+        fetch: wrapFetchWithPayment(fetch, client),
+        httpClient: new x402HTTPClient(client),
+    };
+}

package/dist/chains.d.ts

@@ -0,0 +1,15 @@
+import type { Address, Chain } from "viem";
+export type SekishoNetwork = "avalancheFuji" | "avalanche";
+export interface NetworkConfig {
+    chain: Chain;
+    rpcUrl: string;
+    explorer: string;
+    usdc: Address;
+    /** Dominio EIP-712 del USDC (necesario para firmas EIP-3009 en x402). */
+    usdcEip712: {
+        name: string;
+        version: string;
+    };
+    factory?: Address;
+}
+export declare const NETWORKS: Record<SekishoNetwork, NetworkConfig>;

package/dist/chains.js

@@ -0,0 +1,19 @@
+import { avalanche, avalancheFuji } from "viem/chains";
+export const NETWORKS = {
+    avalancheFuji: {
+        chain: avalancheFuji,
+        rpcUrl: "https://api.avax-test.network/ext/bc/C/rpc",
+        explorer: "https://testnet.snowtrace.io",
+        usdc: "0x5425890298aed601595a70AB815c96711a31Bc65",
+        usdcEip712: { name: "USD Coin", version: "2" },
+        factory: "0xA1967201adD1Ac57d1c72D04Ca4d9159B98C8C5D",
+    },
+    avalanche: {
+        chain: avalanche,
+        rpcUrl: "https://api.avax.network/ext/bc/C/rpc",
+        explorer: "https://snowtrace.io",
+        usdc: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+        usdcEip712: { name: "USD Coin", version: "2" },
+        // factory: se agrega cuando despleguemos en mainnet
+    },
+};

package/dist/client.d.ts

@@ -0,0 +1,43 @@
+import { type Account, type Address, type Hash, type PublicClient } from "viem";
+import { type NetworkConfig, type SekishoNetwork } from "./chains.js";
+export interface SekishoClientOptions {
+    network?: SekishoNetwork;
+    rpcUrl?: string;
+    /** Necesaria solo para escribir (createVault, distribute). */
+    account?: Account;
+}
+export interface SekishoConfig {
+    network: SekishoNetwork;
+    chainId: number;
+    factory: Address;
+    usdc: Address;
+    treasury: Address;
+    feeBps: number;
+}
+export interface PendingSplit {
+    vault: Address;
+    deployed: boolean;
+    total: bigint;
+    fee: bigint;
+    merchantAmount: bigint;
+}
+export interface SekishoClient {
+    network: SekishoNetwork;
+    config: NetworkConfig;
+    publicClient: PublicClient;
+    /** Tesorería y fee actuales de la plataforma. */
+    getConfig(): Promise<SekishoConfig>;
+    /** Dirección payTo del vendedor (su vault), exista o no todavía. */
+    getPayTo(merchant: Address): Promise<Address>;
+    isVaultDeployed(merchant: Address): Promise<boolean>;
+    /** Crea el vault del vendedor. Requiere `account`. */
+    createVault(merchant: Address): Promise<{
+        hash: Hash;
+        vault: Address;
+    }>;
+    /** Lo que se repartiría ahora mismo para el vendedor. */
+    pending(merchant: Address, token?: Address): Promise<PendingSplit>;
+    /** Reparte el saldo del vault (lo crea primero si hace falta). Requiere `account`. */
+    distribute(merchant: Address, token?: Address): Promise<Hash>;
+}
+export declare function createSekishoClient(options?: SekishoClientOptions): SekishoClient;

package/dist/client.js

@@ -0,0 +1,96 @@
+import { createPublicClient, createWalletClient, http, zeroAddress, } from "viem";
+import { splitVaultAbi, splitVaultFactoryAbi } from "./abi.js";
+import { NETWORKS } from "./chains.js";
+export function createSekishoClient(options = {}) {
+    const network = options.network ?? "avalancheFuji";
+    const config = NETWORKS[network];
+    if (!config.factory) {
+        throw new Error(`Sekisho: la factory aún no está desplegada en "${network}"`);
+    }
+    const factory = config.factory;
+    const transport = http(options.rpcUrl ?? config.rpcUrl);
+    const publicClient = createPublicClient({ chain: config.chain, transport });
+    const walletClient = options.account
+        ? createWalletClient({ chain: config.chain, transport, account: options.account })
+        : undefined;
+    function requireWallet() {
+        if (!walletClient) {
+            throw new Error("Sekisho: esta operación requiere `account` en createSekishoClient()");
+        }
+        return walletClient;
+    }
+    async function getConfig() {
+        const [treasury, feeBps] = await Promise.all([
+            publicClient.readContract({ address: factory, abi: splitVaultFactoryAbi, functionName: "treasury" }),
+            publicClient.readContract({ address: factory, abi: splitVaultFactoryAbi, functionName: "feeBps" }),
+        ]);
+        return { network, chainId: config.chain.id, factory, usdc: config.usdc, treasury, feeBps };
+    }
+    async function getPayTo(merchant) {
+        return publicClient.readContract({
+            address: factory,
+            abi: splitVaultFactoryAbi,
+            functionName: "predictVault",
+            args: [merchant],
+        });
+    }
+    async function isVaultDeployed(merchant) {
+        const vault = await publicClient.readContract({
+            address: factory,
+            abi: splitVaultFactoryAbi,
+            functionName: "vaultOf",
+            args: [merchant],
+        });
+        return vault !== zeroAddress;
+    }
+    async function createVault(merchant) {
+        const wallet = requireWallet();
+        const hash = await wallet.writeContract({
+            address: factory,
+            abi: splitVaultFactoryAbi,
+            functionName: "createVault",
+            args: [merchant],
+        });
+        await publicClient.waitForTransactionReceipt({ hash });
+        return { hash, vault: await getPayTo(merchant) };
+    }
+    async function pending(merchant, token = config.usdc) {
+        const vault = await getPayTo(merchant);
+        if (!(await isVaultDeployed(merchant))) {
+            return { vault, deployed: false, total: 0n, fee: 0n, merchantAmount: 0n };
+        }
+        const [total, fee, merchantAmount] = await publicClient.readContract({
+            address: vault,
+            abi: splitVaultAbi,
+            functionName: "pending",
+            args: [token],
+        });
+        return { vault, deployed: true, total, fee, merchantAmount };
+    }
+    async function distribute(merchant, token = config.usdc) {
+        const wallet = requireWallet();
+        if (!(await isVaultDeployed(merchant))) {
+            await createVault(merchant);
+        }
+        const vault = await getPayTo(merchant);
+        const hash = await wallet.writeContract({
+            address: vault,
+            abi: splitVaultAbi,
+            functionName: "distribute",
+            args: [token],
+        });
+        await publicClient.waitForTransactionReceipt({ hash });
+        return hash;
+    }
+    return {
+        network,
+        config,
+        publicClient,
+        getConfig,
+        getPayTo,
+        isVaultDeployed,
+        createVault,
+        pending,
+        distribute,
+    };
+}

package/dist/facilitator.d.ts

@@ -0,0 +1,24 @@
+import { x402Facilitator } from "@x402/core/facilitator";
+import { x402ResourceServer } from "@x402/core/server";
+import { type LocalAccount } from "viem";
+import { type SekishoNetwork } from "./chains.js";
+export interface SekishoFacilitatorOptions {
+    /** Wallet que envía las transacciones de liquidación (paga el gas en AVAX). */
+    account: LocalAccount;
+    network?: SekishoNetwork;
+    rpcUrl?: string;
+}
+/** Tipo que acepta x402ResourceServer como facilitator. */
+export type SekishoFacilitatorClient = NonNullable<ConstructorParameters<typeof x402ResourceServer>[0]>;
+/**
+ * Facilitator x402 en el mismo proceso (self-facilitation).
+ * Verifica y liquida pagos EIP-3009 directamente en Avalanche,
+ * sin depender de un servicio externo.
+ */
+export declare function createSekishoFacilitator(options: SekishoFacilitatorOptions): x402Facilitator;
+/**
+ * Convierte el facilitator local en el cliente que espera x402ResourceServer.
+ * En runtime solo enlaza verify/settle/getSupported; el cast ajusta el tipo
+ * de `network` (string → formato CAIP-2), que es idéntico en valor.
+ */
+export declare function toFacilitatorClient(facilitator: x402Facilitator): SekishoFacilitatorClient;

package/dist/facilitator.js

@@ -0,0 +1,47 @@
+import { x402Facilitator } from "@x402/core/facilitator";
+import { toFacilitatorEvmSigner } from "@x402/evm";
+import { registerExactEvmScheme } from "@x402/evm/exact/facilitator";
+import { createWalletClient, http, publicActions } from "viem";
+import { NETWORKS } from "./chains.js";
+/**
+ * Facilitator x402 en el mismo proceso (self-facilitation).
+ * Verifica y liquida pagos EIP-3009 directamente en Avalanche,
+ * sin depender de un servicio externo.
+ */
+export function createSekishoFacilitator(options) {
+    const network = options.network ?? "avalancheFuji";
+    const config = NETWORKS[network];
+    const viemClient = createWalletClient({
+        account: options.account,
+        chain: config.chain,
+        transport: http(options.rpcUrl ?? config.rpcUrl),
+    }).extend(publicActions);
+    const signer = toFacilitatorEvmSigner({
+        address: options.account.address,
+        getCode: viemClient.getCode,
+        readContract: viemClient.readContract,
+        // Adaptador: misma llamada en runtime, solo ajusta el tipo para TypeScript
+        verifyTypedData: (args) => viemClient.verifyTypedData(args),
+        writeContract: viemClient.writeContract,
+        sendTransaction: viemClient.sendTransaction,
+        waitForTransactionReceipt: viemClient.waitForTransactionReceipt,
+    });
+    const facilitator = new x402Facilitator();
+    registerExactEvmScheme(facilitator, {
+        signer,
+        networks: `eip155:${config.chain.id}`,
+    });
+    return facilitator;
+}
+/**
+ * Convierte el facilitator local en el cliente que espera x402ResourceServer.
+ * En runtime solo enlaza verify/settle/getSupported; el cast ajusta el tipo
+ * de `network` (string → formato CAIP-2), que es idéntico en valor.
+ */
+export function toFacilitatorClient(facilitator) {
+    return {
+        verify: facilitator.verify.bind(facilitator),
+        settle: facilitator.settle.bind(facilitator),
+        getSupported: async () => facilitator.getSupported(),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createSekishoClient, type SekishoClient, type SekishoClientOptions, type SekishoConfig, type PendingSplit, } from "./client.js";
+export { NETWORKS, type NetworkConfig, type SekishoNetwork } from "./chains.js";
+export { createPaymentOption, DEFAULT_FACILITATOR_URL, type PaymentOptionParams, type SekishoPaymentOption, } from "./x402.js";
+export { createSekishoFetch, createSekishoPaymentClient, type SekishoAgentOptions, type SekishoFetch, type SekishoFetchOptions, } from "./agent.js";
+export { createSekishoFacilitator, toFacilitatorClient, type SekishoFacilitatorClient, type SekishoFacilitatorOptions, } from "./facilitator.js";
+export { createSekishoMcpPaywall, createSekishoMcpClient, type SekishoMcpPaywall, type SekishoMcpPaywallOptions, type SekishoMcpClient, type SekishoMcpClientOptions, } from "./mcp.js";
+export { splitVaultAbi, splitVaultFactoryAbi, erc20Abi } from "./abi.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { createSekishoClient, } from "./client.js";
+export { NETWORKS } from "./chains.js";
+export { createPaymentOption, DEFAULT_FACILITATOR_URL, } from "./x402.js";
+export { createSekishoFetch, createSekishoPaymentClient, } from "./agent.js";
+export { createSekishoFacilitator, toFacilitatorClient, } from "./facilitator.js";
+export { createSekishoMcpPaywall, createSekishoMcpClient, } from "./mcp.js";
+export { splitVaultAbi, splitVaultFactoryAbi, erc20Abi } from "./abi.js";

package/dist/mcp.d.ts

@@ -0,0 +1,30 @@
+import { createPaymentWrapper, wrapMCPClientWithPayment } from "@x402/mcp";
+import type { x402Facilitator } from "@x402/core/facilitator";
+import type { Address } from "viem";
+import type { SekishoClient } from "./client.js";
+import { type SekishoAgentOptions } from "./agent.js";
+export interface SekishoMcpPaywallOptions {
+    sekisho: SekishoClient;
+    /** Facilitator que verifica y liquida (por ejemplo, createSekishoFacilitator). */
+    facilitator: x402Facilitator;
+    /** Wallet del vendedor (dueño del vault). */
+    merchant: Address;
+    /** Precio por llamada en USD, por ejemplo "0.01". */
+    price: string;
+    /** Se ejecuta después de cada pago liquidado. */
+    onSettled?: (info: {
+        toolName: string;
+        transaction: string;
+    }) => void | Promise<void>;
+}
+export type SekishoMcpPaywall = ReturnType<typeof createPaymentWrapper>;
+/**
+ * Envoltura para tools MCP de pago. El payTo es el SplitVault del vendedor.
+ */
+export declare function createSekishoMcpPaywall(options: SekishoMcpPaywallOptions): Promise<SekishoMcpPaywall>;
+export interface SekishoMcpClientOptions extends SekishoAgentOptions {
+    name?: string;
+}
+export type SekishoMcpClient = ReturnType<typeof wrapMCPClientWithPayment>;
+/** Cliente MCP para agentes que paga tools automáticamente. */
+export declare function createSekishoMcpClient(options: SekishoMcpClientOptions): SekishoMcpClient;

package/dist/mcp.js

@@ -0,0 +1,39 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { createPaymentWrapper, wrapMCPClientWithPayment, x402ResourceServer, } from "@x402/mcp";
+import { ExactEvmScheme } from "@x402/evm/exact/server";
+import { createPaymentOption } from "./x402.js";
+import { createSekishoPaymentClient } from "./agent.js";
+import { toFacilitatorClient } from "./facilitator.js";
+/**
+ * Envoltura para tools MCP de pago. El payTo es el SplitVault del vendedor.
+ */
+export async function createSekishoMcpPaywall(options) {
+    const option = await createPaymentOption(options.sekisho, {
+        merchant: options.merchant,
+        price: options.price,
+    });
+    const resourceServer = new x402ResourceServer(toFacilitatorClient(options.facilitator));
+    resourceServer.register(option.network, new ExactEvmScheme());
+    await resourceServer.initialize();
+    const accepts = await resourceServer.buildPaymentRequirements({
+        scheme: option.scheme,
+        network: option.network,
+        payTo: option.payTo,
+        price: option.price,
+    });
+    return createPaymentWrapper(resourceServer, {
+        accepts,
+        hooks: {
+            onAfterSettlement: async ({ toolName, settlement }) => {
+                await options.onSettled?.({ toolName, transaction: settlement.transaction });
+            },
+        },
+    });
+}
+/** Cliente MCP para agentes que paga tools automáticamente. */
+export function createSekishoMcpClient(options) {
+    const mcpClient = new Client({ name: options.name ?? "sekisho-agent", version: "0.1.0" });
+    return wrapMCPClientWithPayment(mcpClient, createSekishoPaymentClient(options), {
+        autoPayment: true,
+    });
+}

package/dist/x402.d.ts

@@ -0,0 +1,30 @@
+import { type Address } from "viem";
+import type { SekishoClient } from "./client.js";
+/** Facilitator x402 v2 con soporte para Avalanche Fuji y C-Chain. */
+export declare const DEFAULT_FACILITATOR_URL = "https://facilitator.ultravioletadao.xyz";
+export interface PaymentOptionParams {
+    /** Wallet del vendedor (dueño del vault). */
+    merchant: Address;
+    /** Precio en USD como texto, por ejemplo "0.01". */
+    price: string;
+}
+/** Opción de pago x402 v2 (esquema exact) lista para usar en `accepts`. */
+export interface SekishoPaymentOption {
+    scheme: "exact";
+    network: `eip155:${number}`;
+    payTo: Address;
+    price: {
+        amount: string;
+        asset: Address;
+        extra: {
+            name: string;
+            version: string;
+        };
+    };
+}
+/**
+ * Construye la opción de pago x402 de un vendedor.
+ * El payTo es el SplitVault del vendedor, así que el fee de Sekisho
+ * se aplica automáticamente al repartir.
+ */
+export declare function createPaymentOption(sekisho: SekishoClient, params: PaymentOptionParams): Promise<SekishoPaymentOption>;

package/dist/x402.js

@@ -0,0 +1,25 @@
+import { parseUnits } from "viem";
+/** Facilitator x402 v2 con soporte para Avalanche Fuji y C-Chain. */
+export const DEFAULT_FACILITATOR_URL = "https://facilitator.ultravioletadao.xyz";
+/**
+ * Construye la opción de pago x402 de un vendedor.
+ * El payTo es el SplitVault del vendedor, así que el fee de Sekisho
+ * se aplica automáticamente al repartir.
+ */
+export async function createPaymentOption(sekisho, params) {
+    const amount = parseUnits(params.price, 6);
+    if (amount <= 0n) {
+        throw new Error("Sekisho: el precio debe ser mayor a 0");
+    }
+    const payTo = await sekisho.getPayTo(params.merchant);
+    return {
+        scheme: "exact",
+        network: `eip155:${sekisho.config.chain.id}`,
+        payTo,
+        price: {
+            amount: amount.toString(),
+            asset: sekisho.config.usdc,
+            extra: { ...sekisho.config.usdcEip712 },
+        },
+    };
+}

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@zero-two-labs/sekisho",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "x402 payments with automatic revenue split on Avalanche",
+  "main": "dist/index.js",
+  "directories": {
+    "example": "examples"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "example:read": "tsx examples/read-config.ts",
+    "example:seller": "node --env-file=.env --import tsx examples/seller-server.ts",
+    "example:agent": "node --env-file=.env --import tsx examples/agent-pay.ts",
+    "example:mcp": "node --env-file=.env --import tsx examples/agent-mcp.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "x402",
+    "avalanche",
+    "ai-agents",
+    "mcp",
+    "payments",
+    "usdc",
+    "revenue-split"
+  ],
+  "author": "Zero Two Labs",
+  "license": "MIT",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@x402/fetch": "^2.28.0",
+    "@x402/mcp": "^2.28.0",
+    "viem": "^2.57.7",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@hono/node-server": "^2.1.5",
+    "@types/node": "^26.6.5",
+    "@x402/core": "^2.28.0",
+    "@x402/evm": "^2.28.0",
+    "@x402/hono": "^2.28.0",
+    "hono": "^4.13.13",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/usainbluntmx/sekisho.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}