@altaga/x402-sui 1.0.1

package/README.MD

@@ -0,0 +1,439 @@
+# @altaga/x402-sui
+
+> Modular [x402](https://www.x402.org/) implementation for **Sui Sponsored Transactions** (gas-station style).
+
+This package is a small, pluggable reference SDK for the x402 "Payment Required" HTTP
+pattern, targeting the **Sui** blockchain. The design separates concerns into three
+roles — **Client**, **Resource Server**, and **Facilitator** — and exposes an
+HTTP middleware layer so any Express-based API can gate routes behind a 402
+payment challenge with a few lines of glue.
+
+The bundled `sui/exact` scheme uses Sui's *sponsored transaction* model: the
+buyer signs the payment intent, the facilitator co-signs as the **gas owner**, and
+the resource server never touches a private key.
+
+---
+
+## Table of Contents
+
+- [Architecture](#architecture)
+- [Installation](#installation)
+- [Project Layout](#project-layout)
+- [Protocol Flow](#protocol-flow)
+- [Quick Start](#quick-start)
+  - [1. Resource Server (the paid API)](#1-resource-server-the-paid-api)
+  - [2. Facilitator (the gas station)](#2-facilitator-the-gas-station)
+  - [3. Client (the buyer)](#3-client-the-buyer)
+- [Module Reference](#module-reference)
+  - [`core/client`](#coreclient)
+  - [`core/http`](#corehttp)
+  - [`core/server`](#coreserver)
+  - [`core/server-http`](#coreserver-http)
+  - [`core/facilitator`](#corefacilitator)
+  - [`sui/exact/client`](#suiexactclient)
+  - [`sui/exact/server`](#suiexactserver)
+  - [`sui/exact/facilitator`](#suiexactfacilitator)
+- [Building](#building)
+- [Peer Dependencies](#peer-dependencies)
+- [License](#license)
+
+---
+
+## Architecture
+
+x402 is a request/response convention layered on top of HTTP 402 *Payment Required*:
+
+```
+┌─────────┐         ┌──────────────────┐         ┌──────────────┐
+│  Client │ ──GET──▶│  Resource Server │         │ Facilitator  │
+│         │         │  (Express route) │         │  (gas owner) │
+│         │◀─ 402 ──│                  │         │              │
+│         │  + x-accepts              │         │              │
+│         │  + x-facilitator-url      │         │              │
+│         │                           │         │              │
+│         │── POST /sponsor ────────────────────▶              │
+│         │◀── sponsored tx bytes ─────────────────            │
+│         │── GET + X-PAYMENT ──▶│                  │           │
+│         │                      │── /verify ──────▶│           │
+│         │                      │── /settle  ─────▶│           │
+│         │◀── 200 + x-payment-response ────────────│           │
+└─────────┘         └──────────────────┘         └──────────────┘
+```
+
+The SDK mirrors that split into three independent core modules, each of which
+is scheme-agnostic. Scheme implementations (currently just `sui/exact`) are
+plugged in with a simple `register(schemeName:network, impl)` call — wildcards
+(`sui:*`, `*:*`) are supported.
+
+| Role | Module | Responsibility |
+|------|--------|----------------|
+| Client | `core/client`, `core/http` | Parse a 402 challenge, pick a supported scheme, ask the facilitator to sponsor, sign the tx, replay the request with `X-PAYMENT`. |
+| Resource Server | `core/server`, `core/server-http` | Issue 402 challenges for protected routes; verify and settle payments via the facilitator. |
+| Facilitator | `core/facilitator` | Co-sign transactions as gas owner, dry-run to verify, and submit to the chain. |
+
+---
+
+## Installation
+
+```bash
+npm install @altaga/x402-sui
+```
+
+You also need the peer dependencies in your project:
+
+```bash
+npm install @mysten/sui @mysten/bcs express
+```
+
+> Pre-built bundles live in [`dist/`](./dist). The build step is only required
+> if you're modifying the source under `core/` or `sui/`.
+
+---
+
+## Project Layout
+
+```
+sdk/
+├── core/                       # Scheme-agnostic framework
+│   ├── client.mjs              # x402Client — scheme registry & lookup
+│   ├── http.mjs                # x402HTTPClient — parse 402, encode X-PAYMENT
+│   ├── server.mjs              # x402ResourceServer — verify+settle via facilitator
+│   ├── server-http.mjs         # x402HTTPResourceServer — Express middleware
+│   └── facilitator.mjs         # x402Facilitator — sponsor / verify / settle
+├── sui/
+│   └── exact/                  # The "exact" payment scheme on Sui
+│       ├── client.mjs          # Builds the payment PTB, signs, asks for sponsor
+│       ├── server.mjs          # Passthrough (work happens in facilitator)
+│       └── facilitator.mjs     # Co-signs as gas owner, dry-runs, submits
+├── dist/                       # esbuild output (consumed via package exports)
+├── package.json
+└── README.MD
+```
+
+`package.json` exposes each piece as a subpath export so consumers can import
+only what they need:
+
+```json
+{
+  "@altaga/x402-sui/core/client":          "…",
+  "@altaga/x402-sui/core/http":            "…",
+  "@altaga/x402-sui/core/server":          "…",
+  "@altaga/x402-sui/core/server-http":     "…",
+  "@altaga/x402-sui/core/facilitator":     "…",
+  "@altaga/x402-sui/sui/exact/client":     "…",
+  "@altaga/x402-sui/sui/exact/server":     "…",
+  "@altaga/x402-sui/sui/exact/facilitator":"…"
+}
+```
+
+---
+
+## Protocol Flow
+
+1. **Challenge.** The client requests a protected route. The server replies
+   `402 Payment Required` with:
+   - `X-Accepts`: base64-encoded JSON array of accepted `{ scheme, network, asset, payTo, maxAmountRequired, ... }` payment requirements.
+   - `X-Facilitator-Url`: where the client should ask for gas sponsorship.
+
+2. **Sponsor.** The client picks a supported scheme from `X-Accepts`, builds
+   the payment transaction (a `splitCoins` + `transferObjects` PTB on Sui),
+   and POSTs the raw tx bytes + sender address to `{facilitatorUrl}/sponsor`.
+   The facilitator returns `sponsoredTxBytes` (with itself as `gasOwner`) and
+   its `sponsorSignature`.
+
+3. **Sign.** The client signs the sponsored bytes with its own keypair.
+
+4. **Pay.** The client replays the original request with `X-PAYMENT:`
+   (base64 JSON of `{ scheme, network, transaction, signature, amount, payTo, asset }`).
+
+5. **Verify & Settle.** The server forwards the payload to the facilitator:
+   - `/verify` performs a `dryRunTransactionBlock` to mathematically prove the
+     tx would succeed.
+   - `/settle` calls `executeTransactionBlock` with the combined
+     `[buyerSignature, sponsorSignature]` array and returns the digest.
+
+6. **Respond.** On success, the server attaches `X-Payment-Response` (base64
+   JSON containing the `transactionDigest`) and hands off to the actual route
+   handler.
+
+---
+
+## Quick Start
+
+### 1. Resource Server (the paid API)
+
+```js
+import express from "express";
+import { SuiClient } from "@mysten/sui/client";
+
+import { x402ResourceServer } from "@altaga/x402-sui/core/server";
+import { HTTPFacilitatorClient } from "@altaga/x402-sui/core/http";
+import { x402HTTPResourceServer } from "@altaga/x402-sui/core/server-http";
+import { ExactSuiServerScheme } from "@altaga/x402-sui/sui/exact/server";
+
+const app = express();
+
+// 1. The server is configured with the URL of a trusted facilitator
+const facilitator = new HTTPFacilitatorClient({ url: "https://facilitator.example.com" });
+const resourceServer = new x402ResourceServer(facilitator);
+
+// 2. Register scheme(s) you want to accept. Wildcards ("sui:*", "*:*") are OK.
+resourceServer.register("exact:sui:mainnet", new ExactSuiServerScheme());
+
+// 3. Declare which routes are paid, and what they cost
+const routes = {
+  "GET /premium": {
+    accepts: {
+      scheme: "exact",
+      network: "sui:mainnet",
+      asset: "0x2::sui::SUI",
+      payTo: "0xYOUR_RECEIVING_ADDRESS",
+      maxAmountRequired: "1000000",   // 0.001 SUI
+      description: "Premium data feed"
+    }
+  }
+};
+
+app.use(new x402HTTPResourceServer(resourceServer, routes).middleware());
+
+// 4. The actual handler — req.payment is populated by the middleware
+app.get("/premium", (req, res) => {
+  res.json({ ok: true, paid: req.payment });
+});
+
+app.listen(3000);
+```
+
+### 2. Facilitator (the gas station)
+
+```js
+import express from "express";
+import { SuiClient } from "@mysten/sui/client";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+
+import { x402Facilitator } from "@altaga/x402-sui/core/facilitator";
+import { ExactSuiFacilitatorScheme } from "@altaga/x402-sui/sui/exact/facilitator";
+
+const client = new SuiClient({ url: "https://fullnode.mainnet.sui.io" });
+const keypair = Ed25519Keypair.fromSecretKey(process.env.FACILITATOR_SECRET);
+
+const facilitator = new x402Facilitator();
+facilitator.register("exact:sui:mainnet", new ExactSuiFacilitatorScheme(client, keypair));
+
+const app = express();
+app.use(express.json());
+
+// Sponsor: client posts { txBytes, sender, scheme, network }
+app.post("/sponsor", async (req, res) => {
+  try {
+    const result = await facilitator.sponsor(req.body.scheme, req.body.network, {
+      txBytes: req.body.txBytes,
+      sender: req.body.sender,
+    });
+    res.json(result); // { sponsoredTxBytes, sponsorSignature }
+  } catch (e) {
+    res.status(400).json({ error: e.message });
+  }
+});
+
+// Verify: dry-run the candidate transaction
+app.post("/verify", async (req, res) => {
+  try {
+    const result = await facilitator.verify(req.body.paymentPayload, req.body.paymentRequirement);
+    res.json(result); // { isValid: true }
+  } catch (e) {
+    res.status(400).json({ isValid: false, error: e.message });
+  }
+});
+
+// Settle: submit the transaction to the chain
+app.post("/settle", async (req, res) => {
+  try {
+    const result = await facilitator.settle(req.body.paymentPayload, req.body.paymentRequirement);
+    res.json(result); // { transactionDigest }
+  } catch (e) {
+    res.status(400).json({ error: e.message });
+  }
+});
+
+app.listen: 4000;
+```
+
+> The facilitator keypair must hold SUI for gas. If `client.getCoins` returns
+> zero gas coins, sponsorship fails with `Facilitator out of gas!`.
+
+### 3. Client (the buyer)
+
+```js
+import { SuiClient } from "@mysten/sui/client";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+
+import { x402Client } from "@altaga/x402-sui/core/client";
+import { x402HTTPClient } from "@altaga/x402-sui/core/http";
+import { ExactSuiClientScheme } from "@altaga/x402-sui/sui/exact/client";
+
+const sui = new SuiClient({ url: "https://fullnode.mainnet.sui.io" });
+const keypair = Ed25519Keypair.fromSecretKey(process.env.BUYER_SECRET);
+
+const core = new x402Client();
+core.register("exact:sui:mainnet", new ExactSuiClientScheme(sui, keypair));
+
+const http = new x402HTTPClient(core);
+
+// 1. Hit the protected endpoint
+let res = await fetch("https://api.example.com/premium");
+if (res.status === 402) {
+  // 2. Parse the challenge
+  const paymentRequired = http.getPaymentRequiredResponse(
+    (name) => res.headers.get(name),
+    null,
+  );
+
+  // 3. Build + sign + sponsor the payment
+  const payload = await http.createPaymentPayload(paymentRequired);
+
+  // 4. Replay the request with X-PAYMENT
+  res = await fetch("https://api.example.com/premium", {
+    headers: http.encodePaymentSignatureHeader(payload),
+  });
+}
+
+const settleInfo = http.getPaymentSettleResponse((n) => res.headers.get(n));
+console.log("data:", await res.json(), "settle:", settleInfo);
+```
+
+---
+
+## Module Reference
+
+### `core/client`
+
+`x402Client` — a tiny scheme registry. `register(pattern, impl)` accepts
+`scheme:network`, `scheme:*`, or `*:*`; `getScheme(scheme, network)` resolves
+with the most specific match. Throws if nothing is registered.
+
+### `core/http`
+
+`x402HTTPClient(coreClient)` — HTTP-specific glue on top of a core client:
+
+- `getPaymentRequiredResponse(getHeaderFn, bodyJson)` — decodes `X-Accepts`
+  (base64 JSON) and reads `X-Facilitator-Url` (with body fallback).
+- `createPaymentPayload(paymentRequired)` — iterates `accepts`, hands the
+  first one a registered scheme can fulfil, and returns a normalized
+  `{ scheme, network, transaction, signature, amount, payTo, asset }`.
+- `encodePaymentSignatureHeader(payload)` — base64-encodes the payload for
+  the `X-PAYMENT` request header.
+- `getPaymentSettleResponse(getHeaderFn)` — decodes `X-Payment-Response` if
+  present.
+
+### `core/server`
+
+`x402ResourceServer(facilitatorClient)` — the server-side brain.
+
+- `register(pattern, impl)` — same lookup rules as the client.
+- `initialize()` — async hook for parity with richer implementations.
+- `handlePayment(paymentPayload, routes)` — calls
+  `facilitatorClient.verify(...)` then `facilitatorClient.settle(...)` and
+  returns the settlement result.
+
+`HTTPFacilitatorClient({ url })` — the default transport, POSTing JSON to
+`{url}/verify` and `{url}/settle`. Roll your own if you need mTLS or auth
+headers.
+
+### `core/server-http`
+
+`x402HTTPResourceServer(resourceServer, routesConfig).middleware()` returns
+an Express middleware that:
+
+1. Looks up the route via `${req.method} ${req.path}`.
+2. If no `X-PAYMENT` header is present, responds `402` with
+   `X-Accepts` + `X-Facilitator-Url`.
+3. If a header is present, base64-decodes it, calls
+   `resourceServer.handlePayment(...)`, attaches `X-Payment-Response` to the
+   outgoing response, populates `req.payment`, and calls `next()`.
+4. On error, responds `400` with the error message.
+
+### `core/facilitator`
+
+`x402Facilitator` — scheme registry + dispatch for the three facilitator
+operations:
+
+- `sponsor(schemeName, network, payload)` — typically turns a raw client PTB
+  into a sponsored transaction with the facilitator as `gasOwner`.
+- `verify(paymentPayload, paymentRequirements)` — must return
+  `{ isValid: true }` or throw.
+- `settle(paymentPayload, paymentRequirements)` — must return
+  `{ transactionDigest }` or throw.
+
+### `sui/exact/client`
+
+`ExactSuiClientScheme(client, keypair)` — implements `createPaymentPayload`:
+
+1. Fetchs the buyer's coins of `requirement.asset`; aborts if none exist.
+2. Builds a PTB: `splitCoins(coin, [amount])` → `transferObjects([split], payTo)`.
+3. If a `facilitatorUrl` was advertised, POSTs the raw bytes to
+   `{facilitatorUrl}/sponsor` and receives `sponsoredTxBytes` +
+   `sponsorSignature`.
+4. Signs the (possibly sponsored) bytes with the buyer's keypair and returns
+   `{ transaction, signature: [buyer, sponsor?] }`.
+
+### `sui/exact/server`
+
+`ExactSuiServerScheme` — intentionally empty. On Sui, the heavy lifting
+(verification, gas sponsorship, submission) is done by the facilitator, so
+the server-side scheme is a passthrough. Register one for parity:
+
+```js
+resourceServer.register("exact:sui:mainnet", new ExactSuiServerScheme());
+```
+
+### `sui/exact/facilitator`
+
+`ExactSuiFacilitatorScheme(client, keypair)` — the gas station.
+
+- **`sponsor({ txBytes, sender })`** — deserializes the buyer's PTB, overrides
+  `setSender(sender)`, `setGasOwner(self)`, picks a gas coin, sets a
+  `setGasBudget(10_000_000)` and `setGasPrice(1000)`, calls `tx.build`, and
+  returns `{ sponsoredTxBytes, sponsorSignature }`.
+- **`verify(payload, reqs)`** — `dryRunTransactionBlock` on the decoded
+  bytes; succeeds only if `effects.status.status === "success"`.
+- **`settle(payload, reqs)`** — `executeTransactionBlock` with the combined
+  signature array; returns `{ transactionDigest }` on success.
+
+---
+
+## Building
+
+Source modules are written as `.mjs`. To rebuild the `dist/` bundles:
+
+```bash
+npm run build
+```
+
+Which is shorthand for:
+
+```bash
+esbuild core/*.mjs sui/exact/*.mjs \
+  --outdir=dist \
+  --minify \
+  --format=esm \
+  --target=es2022
+```
+
+---
+
+## Peer Dependencies
+
+| Package | Version | Why |
+|---------|---------|-----|
+| [`@mysten/sui`](https://www.npmjs.com/package/@mysten/sui) | `^1.14.0` | `Transaction`, `SuiClient`, keypairs |
+| [`@mysten/bcs`](https://www.npmjs.com/package/@mysten/bcs) | `^1.2.0`  | `toBase64` for serializing built PTBs |
+| [`express`](https://www.npmjs.com/package/express) | `^4.21.2` | Used by `x402HTTPResourceServer.middleware()` |
+
+`esbuild` is only needed if you re-run the build.
+
+---
+
+## License
+
+[MIT](./LICENSE) — © Altaga

package/dist/core/client.js

@@ -0,0 +1 @@
+class i{constructor(){this.schemes=new Map}register(e,s){return this.schemes.set(e,s),this}getScheme(e,s){const t=`${e}:${s}`;if(this.schemes.has(t))return this.schemes.get(t);const h=`${e}:*`;if(this.schemes.has(h))return this.schemes.get(h);if(this.schemes.has("*:*"))return this.schemes.get("*:*");throw new Error(`No payment scheme registered for ${t}`)}}export{i as x402Client};

package/dist/core/facilitator.js

@@ -0,0 +1 @@
+class c{constructor(){this.schemes=new Map}register(e,s){return this.schemes.set(e,s),this}getScheme(e,s){const t=`${e}:${s}`;if(this.schemes.has(t))return this.schemes.get(t);if(this.schemes.has(`${e}:*`))return this.schemes.get(`${e}:*`);if(this.schemes.has("*:*"))return this.schemes.get("*:*");throw new Error(`No facilitator scheme registered for ${t}`)}async sponsor(e,s,t){return await this.getScheme(e,s).sponsor(t)}async verify(e,s){return await this.getScheme(e.scheme,e.network).verify(e,s)}async settle(e,s){return await this.getScheme(e.scheme,e.network).settle(e,s)}}export{c as x402Facilitator};

package/dist/core/http.js

@@ -0,0 +1 @@
+class s{constructor(t){this.coreClient=t}getPaymentRequiredResponse(t,e){const r=t("x-accepts"),n=t("x-facilitator-url");if(!r)throw new Error("Missing x-accepts header in 402 response");return{accepts:JSON.parse(Buffer.from(r,"base64").toString("utf-8")),facilitatorUrl:n||e?.facilitatorUrl}}async createPaymentPayload(t){for(const e of t.accepts)try{const n=await this.coreClient.getScheme(e.scheme,e.network).createPaymentPayload(e,t.facilitatorUrl);return{scheme:e.scheme,network:e.network,transaction:n.transaction,signature:n.signature,amount:e.maxAmountRequired||e.amount,payTo:e.payTo,asset:e.asset}}catch(r){console.warn(`Could not fulfill payment requirement for ${e.scheme}:${e.network}:`,r.message);continue}throw new Error("Could not fulfill any payment requirements provided by the server.")}encodePaymentSignatureHeader(t){const e=JSON.stringify(t);return{"X-PAYMENT":Buffer.from(e).toString("base64")}}getPaymentSettleResponse(t){const e=t("x-payment-response");return e?JSON.parse(Buffer.from(e,"base64").toString("utf-8")):null}}export{s as x402HTTPClient};

package/dist/core/server-http.js

@@ -0,0 +1 @@
+class u{constructor(t,e){this.resourceServer=t,this.routesConfig=e}middleware(){return async(t,e,a)=>{const i=`${t.method} ${t.path}`,r=this.routesConfig[i];if(!r)return a();const o=t.headers["x-payment"];if(!o)return e.status(402),e.setHeader("x-accepts",Buffer.from(JSON.stringify([r.accepts])).toString("base64")),this.resourceServer.facilitatorClient&&e.setHeader("x-facilitator-url",this.resourceServer.facilitatorClient.url),e.setHeader("Content-Type","application/json"),e.json({error:"Payment Required",accepts:[r.accepts]});try{const s=JSON.parse(Buffer.from(o,"base64").toString("utf-8")),n=await this.resourceServer.handlePayment(s,[r.accepts]);e.setHeader("x-payment-response",Buffer.from(JSON.stringify(n)).toString("base64")),t.payment=n,a()}catch(s){console.error("Payment settlement error:",s),e.status(400).json({error:"Payment Processing Failed",message:s.message})}}}}export{u as x402HTTPResourceServer};

package/dist/core/server.js

@@ -0,0 +1 @@
+class a{constructor(t){this.url=t.url}async verify(t,e){const i=await fetch(`${this.url}/verify`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({paymentPayload:t,paymentRequirement:e})});if(!i.ok)throw new Error(`Facilitator verify failed: ${await i.text()}`);return await i.json()}async settle(t,e){const i=await fetch(`${this.url}/settle`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({paymentPayload:t,paymentRequirement:e})});if(!i.ok)throw new Error(`Facilitator settle failed: ${await i.text()}`);return await i.json()}}class n{constructor(t){this.facilitatorClient=t,this.schemes=new Map}register(t,e){return this.schemes.set(t,e),this}async initialize(){console.log("x402ResourceServer initialized.")}async handlePayment(t,e){if(!(await this.facilitatorClient.verify(t,e)).isValid)throw new Error("Payment verification failed via Facilitator");return await this.facilitatorClient.settle(t,e)}}export{a as HTTPFacilitatorClient,n as x402ResourceServer};

package/dist/sui/exact/client.js

@@ -0,0 +1 @@
+import{Transaction as l}from"@mysten/sui/transactions";import"@mysten/bcs";class S{constructor(s,t){this.client=s,this.keypair=t,this.address=t.getPublicKey().toSuiAddress()}async createPaymentPayload(s,t){const o=new l,i=await this.client.getCoins({owner:this.address,coinType:s.asset});if(i.data.length===0)throw new Error(`Buyer has no ${s.asset}!`);const d=i.data[0],h=s.maxAmountRequired||s.amount||s.price,[y]=o.splitCoins(d.coinObjectId,[h]);o.transferObjects([y],s.payTo);const r=o.serialize();let n=r,e=null;if(t){const w=t.endsWith("/")?`${t}sponsor`:`${t}/sponsor`,a=await fetch(w,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({txBytes:r,sender:this.address,scheme:s.scheme,network:s.network})});if(!a.ok)throw new Error(`Sponsor failed: ${await a.text()}`);const p=await a.json();n=p.sponsoredTxBytes,e=p.sponsorSignature}const{signature:c}=await this.keypair.signTransaction(Buffer.from(n,"base64"));return{transaction:n,signature:e?[c,e]:[c]}}}export{S as ExactSuiClientScheme};

package/dist/sui/exact/facilitator.js

@@ -0,0 +1 @@
+import{Transaction as o}from"@mysten/sui/transactions";import{toBase64 as c}from"@mysten/bcs";class l{constructor(s,e){this.client=s,this.keypair=e,this.address=e.getPublicKey().toSuiAddress()}async sponsor(s){const{txBytes:e,sender:r}=s,t=o.from(e);t.setSender(r),t.setGasOwner(this.address);const n=await this.client.getCoins({owner:this.address,coinType:"0x2::sui::SUI"});if(n.data.length===0)throw new Error("Facilitator out of gas!");t.setGasPayment([{objectId:n.data[0].coinObjectId,version:n.data[0].version,digest:n.data[0].digest}]),t.setGasBudget(1e7),t.setGasPrice(1e3);const a=await t.build({client:this.client}),{signature:i}=await this.keypair.signTransaction(a);return{sponsoredTxBytes:c(a),sponsorSignature:i}}async verify(s,e){const r=Buffer.from(s.transaction,"base64");try{const t=await this.client.dryRunTransactionBlock({transactionBlock:r});if(t.effects.status.status!=="success")throw new Error("Dry run failed: "+t.effects.status.error);return{isValid:!0}}catch(t){throw new Error(`Payment verification failed: ${t.message}`)}}async settle(s,e){const r=Buffer.from(s.transaction,"base64");try{const t=await this.client.executeTransactionBlock({transactionBlock:r,signature:s.signature,options:{showEffects:!0}});if(t.effects?.status.status!=="success")throw new Error(t.effects?.status.error||"Unknown error");return{transactionDigest:t.digest}}catch(t){throw new Error(`Payment settlement error: ${t.message}`)}}}export{l as ExactSuiFacilitatorScheme};

package/dist/sui/exact/server.js

@@ -0,0 +1 @@
+class c{}export{c as ExactSuiServerScheme};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@altaga/x402-sui",
+  "version": "1.0.1",
+  "description": "Modular x402 implementation for Sui Sponsored Transactions",
+  "main": "dist/core/client.js",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "esbuild core/*.mjs sui/exact/*.mjs --outdir=dist --minify --format=esm --target=es2022",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "exports": {
+    "./core/client": "./dist/core/client.js",
+    "./core/http": "./dist/core/http.js",
+    "./core/server": "./dist/core/server.js",
+    "./core/server-http": "./dist/core/server-http.js",
+    "./core/facilitator": "./dist/core/facilitator.js",
+    "./sui/exact/client": "./dist/sui/exact/client.js",
+    "./sui/exact/server": "./dist/sui/exact/server.js",
+    "./sui/exact/facilitator": "./dist/sui/exact/facilitator.js"
+  },
+  "keywords": [
+    "sui",
+    "x402",
+    "sponsored",
+    "transactions",
+    "crypto",
+    "payments"
+  ],
+  "author": "Altaga",
+  "license": "MIT",
+  "peerDependencies": {
+    "@mysten/bcs": "^1.2.0",
+    "@mysten/sui": "^1.14.0",
+    "express": "^4.21.2"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.0"
+  }
+}