@piprail/sdk 1.0.0

package/dist/stellar-PAZ352JL.js

@@ -0,0 +1,389 @@
+import {
+  delay
+} from "./chunk-FURB5RP7.js";
+import {
+  ConfirmationTimeoutError,
+  InsufficientFundsError,
+  UnknownTokenError,
+  WrongFamilyError,
+  nativeCost,
+  parseUnits,
+  rejectForeignToken,
+  toInsufficientFundsError
+} from "./chunk-3TQJJ4SQ.js";
+
+// src/drivers/stellar/index.ts
+import { Horizon, StrKey as StrKey2 } from "@stellar/stellar-sdk";
+
+// src/drivers/stellar/chains.ts
+var STELLAR_DECIMALS = 7;
+var XLM_SYMBOL = "XLM";
+var STELLAR_PASSPHRASE = "Public Global Stellar Network ; September 2015";
+var STELLAR_MAINNET = {
+  caip2: "stellar:pubnet",
+  passphrase: STELLAR_PASSPHRASE,
+  defaultRpc: "https://horizon.stellar.org",
+  tokens: {
+    // Circle USDC — issuer + code verified live on Horizon /assets before shipping.
+    // (Mainnet issuer; NOT the testnet GBBD47IF… one.)
+    USDC: {
+      issuer: "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN",
+      code: "USDC",
+      decimals: STELLAR_DECIMALS,
+      symbol: "USDC"
+    },
+    // Circle EURC — issuer + code verified live on Horizon /assets before shipping.
+    EURC: {
+      issuer: "GDHU6WRG4IEQXM5NZ4BMPKOXHW76MZM4Y2IEMFDVXBSDP6SJY4ITNPP2",
+      code: "EURC",
+      decimals: STELLAR_DECIMALS,
+      symbol: "EURC"
+    }
+  }
+};
+function stellarAssetId(code, issuer) {
+  return `${code}:${issuer}`;
+}
+function parseStellarAssetId(asset) {
+  if (asset === "native") return null;
+  const i = asset.indexOf(":");
+  if (i <= 0 || i === asset.length - 1) return null;
+  return { code: asset.slice(0, i), issuer: asset.slice(i + 1) };
+}
+
+// src/drivers/stellar/pay.ts
+import {
+  Asset,
+  BASE_FEE,
+  Memo,
+  Operation,
+  TransactionBuilder,
+  hash
+} from "@stellar/stellar-sdk";
+function memoHashForNonce(nonce) {
+  return Buffer.from(hash(Buffer.from(nonce, "utf8")));
+}
+async function payStellar(params) {
+  const { server, keypair, accept } = params;
+  try {
+    const asset = assetForAccept(accept);
+    const source = await server.loadAccount(keypair.publicKey());
+    const tx = new TransactionBuilder(source, {
+      fee: BASE_FEE,
+      networkPassphrase: STELLAR_PASSPHRASE
+    }).addOperation(
+      Operation.payment({
+        destination: accept.payTo,
+        asset,
+        amount: accept.extra.amountFormatted
+      })
+    ).addMemo(Memo.hash(memoHashForNonce(accept.extra.nonce))).setTimeout(120).build();
+    tx.sign(keypair);
+    const res = await server.submitTransaction(tx);
+    return res.hash;
+  } catch (err) {
+    throw mapSubmitError(err);
+  }
+}
+function assetForAccept(accept) {
+  if (accept.asset === "native") return Asset.native();
+  const parts = parseStellarAssetId(accept.asset);
+  if (!parts) throw new Error(`Stellar: malformed asset id "${accept.asset}".`);
+  return new Asset(parts.code, parts.issuer);
+}
+function mapSubmitError(err) {
+  const codes = extractResultCodes(err);
+  if (codes.some((c) => /underfunded|insufficient|low_reserve|no_trust/i.test(c))) {
+    return new InsufficientFundsError(
+      "Stellar payment failed: insufficient balance/reserve, or the sender has no trustline for this asset.",
+      { cause: err }
+    );
+  }
+  if (isAccountNotFound(err)) {
+    return new InsufficientFundsError(
+      "Stellar source account not found on-chain \u2014 fund it (\u2265 base reserve) before it can pay.",
+      { cause: err }
+    );
+  }
+  return toInsufficientFundsError(err) ?? err;
+}
+function isAccountNotFound(err) {
+  const e = err;
+  return e?.response?.status === 404 || e?.name === "NotFoundError" || /not found|resource missing/i.test(e?.message ?? "");
+}
+function extractResultCodes(err) {
+  const extras = err?.response?.data?.extras?.result_codes;
+  if (!extras) return [];
+  return [extras.transaction ?? "", ...extras.operations ?? []].filter(Boolean);
+}
+
+// src/drivers/stellar/verify.ts
+import { hash as hash2 } from "@stellar/stellar-sdk";
+function memoCandidatesForNonce(nonce) {
+  const h = Buffer.from(hash2(Buffer.from(nonce, "utf8")));
+  return [h.toString("base64"), h.toString("hex")];
+}
+async function verifyStellar(params) {
+  const { reader, accept } = params;
+  const nonce = accept.extra.nonce;
+  const required = BigInt(accept.amount);
+  const wantMemo = memoCandidatesForNonce(nonce);
+  const wantAsset = parseStellarAssetId(accept.asset);
+  let txs;
+  try {
+    txs = await reader.transactionsForAccount(accept.payTo, 50);
+  } catch {
+    return rpcFailed(nonce);
+  }
+  const tx = txs.find(
+    (t) => t.memo_type === "hash" && typeof t.memo === "string" && wantMemo.includes(t.memo)
+  );
+  if (!tx) return notFound(nonce);
+  if (!tx.successful) {
+    return {
+      ok: false,
+      error: "tx_reverted",
+      detail: `Stellar tx ${tx.hash} for nonce ${nonce} failed on-chain.`
+    };
+  }
+  const ageSeconds = Math.floor(Date.now() / 1e3) - Math.floor(Date.parse(tx.created_at) / 1e3);
+  if (Number.isFinite(ageSeconds) && ageSeconds > accept.maxTimeoutSeconds) {
+    return {
+      ok: false,
+      error: "payment_expired",
+      detail: `Payment is ${ageSeconds}s old; max allowed is ${accept.maxTimeoutSeconds}s.`
+    };
+  }
+  let payments;
+  try {
+    payments = await reader.paymentsForTransaction(tx.hash);
+  } catch {
+    return rpcFailed(nonce);
+  }
+  const toUs = payments.filter(
+    (p) => p.type === "payment" && p.to === accept.payTo && assetMatches(p, wantAsset)
+  );
+  if (toUs.length === 0) {
+    return {
+      ok: false,
+      error: "transfer_not_found",
+      detail: `Stellar tx ${tx.hash} carries our nonce but has no matching ${wantAsset ? wantAsset.code : "XLM"} payment to ${accept.payTo}.`
+    };
+  }
+  const paid = toUs.reduce(
+    (sum, p) => sum + parseAmount(p.amount, accept.extra.decimals),
+    0n
+  );
+  if (paid < required) {
+    return {
+      ok: false,
+      error: "amount_too_low",
+      detail: `Paid ${paid}, required ${required}.`
+    };
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "onchain-proof",
+      success: true,
+      network: accept.network,
+      transaction: tx.hash,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer: toUs[0].from,
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function assetMatches(p, want) {
+  if (want === null) return p.asset_type === "native";
+  return p.asset_type !== "native" && p.asset_code === want.code && p.asset_issuer === want.issuer;
+}
+function parseAmount(amount, decimals) {
+  try {
+    return parseUnits(amount, decimals);
+  } catch {
+    return 0n;
+  }
+}
+function notFound(nonce) {
+  return {
+    ok: false,
+    error: "transfer_not_found",
+    detail: `No matching Stellar payment found for nonce ${nonce} (not yet settled, or wrong recipient/amount/asset/memo).`
+  };
+}
+function rpcFailed(nonce) {
+  return {
+    ok: false,
+    error: "tx_not_found",
+    detail: `Could not read Horizon for nonce ${nonce} (transient RPC failure) \u2014 retry.`
+  };
+}
+
+// src/drivers/stellar/wallet.ts
+import { Keypair, StrKey } from "@stellar/stellar-sdk";
+function assertStellarWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new WrongFamilyError(
+      `chain ${network} is Stellar; wallet must be { secret } (S\u2026 seed) or { keypair }.`
+    );
+  }
+  if ("privateKey" in wallet || "walletClient" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is Stellar; an EVM wallet can't be used \u2014 pass { secret } (S\u2026 seed) or { keypair }.`
+    );
+  }
+  if ("secretKey" in wallet || "signer" in wallet || "mnemonic" in wallet || "keyPair" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is Stellar; that looks like a Solana/TON wallet \u2014 pass { secret } (S\u2026 seed) or { keypair }.`
+    );
+  }
+  if (!("secret" in wallet) && !("keypair" in wallet)) {
+    throw new WrongFamilyError(
+      `chain ${network} is Stellar; wallet must be { secret } (S\u2026 seed) or { keypair }.`
+    );
+  }
+  return wallet;
+}
+function resolveStellarWallet(config) {
+  if (config.keypair) return config.keypair;
+  if (config.secret) {
+    if (!StrKey.isValidEd25519SecretSeed(config.secret)) {
+      throw new WrongFamilyError(
+        "Stellar wallet { secret } is not a valid S\u2026 secret seed."
+      );
+    }
+    return Keypair.fromSecret(config.secret);
+  }
+  throw new WrongFamilyError("Stellar wallet needs { secret } (S\u2026 seed) or { keypair }.");
+}
+
+// src/drivers/stellar/index.ts
+var stellarDriver = {
+  family: "stellar",
+  resolve(opts) {
+    if (opts.chain !== "stellar") return null;
+    const rpcUrl = opts.rpcUrl ?? STELLAR_MAINNET.defaultRpc;
+    return makeStellarNetwork(STELLAR_MAINNET, rpcUrl);
+  }
+};
+function makeStellarNetwork(preset, rpcUrl) {
+  const server = new Horizon.Server(rpcUrl);
+  const network = preset.caip2;
+  const reader = {
+    async transactionsForAccount(account, limit) {
+      const page = await server.transactions().forAccount(account).order("desc").limit(limit).includeFailed(true).call();
+      return page.records.map((r) => ({
+        hash: r.hash,
+        successful: r.successful,
+        memo: r.memo,
+        memo_type: r.memo_type,
+        created_at: r.created_at
+      }));
+    },
+    async paymentsForTransaction(txHash) {
+      const page = await server.payments().forTransaction(txHash).limit(100).call();
+      return page.records.filter((r) => r.type === "payment").map((r) => ({
+        type: r.type,
+        from: r.from,
+        to: r.to,
+        asset_type: r.asset_type,
+        asset_code: r.asset_code,
+        asset_issuer: r.asset_issuer,
+        amount: r.amount
+      }));
+    }
+  };
+  return {
+    family: "stellar",
+    network,
+    supports: (n) => n === network,
+    resolveToken(token) {
+      if (token === "native") {
+        return { asset: "native", decimals: STELLAR_DECIMALS, symbol: XLM_SYMBOL };
+      }
+      if (typeof token === "string") {
+        const info = preset.tokens[token.toUpperCase()];
+        if (!info) {
+          const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
+          throw new UnknownTokenError(
+            `token "${token}" isn't built in for Stellar (known: ${known}). Pass { issuer, code, decimals } for a custom asset, or use 'native'.`
+          );
+        }
+        return {
+          asset: stellarAssetId(info.code, info.issuer),
+          decimals: info.decimals,
+          symbol: info.symbol
+        };
+      }
+      rejectForeignToken(token, "stellar", network);
+      const t = token;
+      if (!t.issuer || !t.code || typeof t.decimals !== "number") {
+        throw new WrongFamilyError(
+          `chain ${network} is Stellar; a custom token must be { issuer, code, decimals }.`
+        );
+      }
+      return {
+        asset: stellarAssetId(t.code, t.issuer),
+        decimals: t.decimals,
+        symbol: t.symbol ?? t.code
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") return { symbol: XLM_SYMBOL, decimals: STELLAR_DECIMALS };
+      for (const info of Object.values(preset.tokens)) {
+        if (stellarAssetId(info.code, info.issuer) === asset) {
+          return { symbol: info.symbol, decimals: info.decimals };
+        }
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (payTo.startsWith("0x")) {
+        throw new WrongFamilyError(
+          `chain ${network} is Stellar, but payTo "${payTo}" looks like an EVM address.`
+        );
+      }
+      if (!StrKey2.isValidEd25519PublicKey(payTo)) {
+        throw new WrongFamilyError(
+          `chain ${network} is Stellar, but payTo "${payTo}" is not a valid Stellar account (G\u2026).`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      return { _native: assertStellarWallet(wallet, network) };
+    },
+    async send(wallet, accept) {
+      const keypair = resolveStellarWallet(wallet._native);
+      return payStellar({ server, keypair, accept });
+    },
+    async confirm(ref) {
+      for (let i = 0; i < 10; i += 1) {
+        try {
+          const tx = await server.transactions().transaction(ref).call();
+          return { height: String(tx.ledger_attr ?? tx.ledger ?? 0) };
+        } catch {
+          await delay(1500);
+        }
+      }
+      throw new ConfirmationTimeoutError(`Stellar tx ${ref} not visible on Horizon in time.`);
+    },
+    async estimateCost() {
+      return nativeCost({
+        symbol: XLM_SYMBOL,
+        decimals: STELLAR_DECIMALS,
+        fee: 100n,
+        basis: "heuristic",
+        detail: "base fee 100 stroops (1 operation)"
+      });
+    },
+    async verify(_ref, accept) {
+      return verifyStellar({ reader, accept });
+    }
+  };
+}
+export {
+  stellarDriver
+};

package/dist/sui-6N4ZPAGD.js

@@ -0,0 +1,304 @@
+import {
+  ConfirmationTimeoutError,
+  InsufficientFundsError,
+  UnknownTokenError,
+  WrongFamilyError,
+  nativeCost,
+  rejectForeignToken,
+  toInsufficientFundsError
+} from "./chunk-3TQJJ4SQ.js";
+
+// src/drivers/sui/index.ts
+import { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
+import { isValidSuiAddress } from "@mysten/sui/utils";
+
+// src/drivers/sui/chains.ts
+var SUI_DECIMALS = 9;
+var SUI_SYMBOL = "SUI";
+var SUI_NATIVE_COINTYPE = "0x2::sui::SUI";
+var SUI_MAINNET = {
+  caip2: "sui:mainnet",
+  defaultRpc: "https://fullnode.mainnet.sui.io:443",
+  tokens: {
+    // Circle USDC — coin type + 6 decimals verified live on mainnet
+    // (suix_getCoinMetadata) before shipping. No native USDT on Sui.
+    USDC: {
+      coinType: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+      decimals: 6,
+      symbol: "USDC"
+    }
+  }
+};
+
+// src/drivers/sui/pay.ts
+import { Transaction } from "@mysten/sui/transactions";
+async function paySui(params) {
+  const { client, keypair, accept } = params;
+  const sender = keypair.getPublicKey().toSuiAddress();
+  const amount = BigInt(accept.amount);
+  try {
+    const tx = new Transaction();
+    tx.setSender(sender);
+    if (accept.asset === "native") {
+      const [coin] = tx.splitCoins(tx.gas, [amount]);
+      tx.transferObjects([coin], accept.payTo);
+    } else {
+      const coins = await client.getCoins({ owner: sender, coinType: accept.asset });
+      if (!coins.data.length) {
+        throw new InsufficientFundsError(
+          `Sui wallet holds no ${accept.asset} coin objects to pay from.`
+        );
+      }
+      const ids = coins.data.map((c) => c.coinObjectId);
+      const primary = ids[0];
+      if (ids.length > 1) {
+        tx.mergeCoins(tx.object(primary), ids.slice(1).map((id) => tx.object(id)));
+      }
+      const [coin] = tx.splitCoins(tx.object(primary), [amount]);
+      tx.transferObjects([coin], accept.payTo);
+    }
+    const res = await client.signAndExecuteTransaction({
+      signer: keypair,
+      transaction: tx,
+      options: { showEffects: true }
+    });
+    return res.digest;
+  } catch (err) {
+    if (err instanceof InsufficientFundsError) throw err;
+    if (isSuiAffordability(err)) {
+      throw new InsufficientFundsError(
+        err instanceof Error ? err.message : "Insufficient SUI/coin balance for the payment.",
+        { cause: err }
+      );
+    }
+    throw toInsufficientFundsError(err) ?? err;
+  }
+}
+function isSuiAffordability(err) {
+  const m = err instanceof Error ? err.message : String(err);
+  return /no valid gas|gas.*(balance|coin)|insufficient|balance is too low|GasBalanceTooLow/i.test(m);
+}
+
+// src/drivers/sui/verify.ts
+async function verifySui(params) {
+  const { reader, digest, accept } = params;
+  const required = BigInt(accept.amount);
+  const wantCoinType = accept.asset === "native" ? SUI_NATIVE_COINTYPE : accept.asset;
+  let tx;
+  try {
+    tx = await reader.getTransaction(digest);
+  } catch {
+    return txNotFound(digest);
+  }
+  if (!tx) return txNotFound(digest);
+  if (tx.status !== "success") {
+    return { ok: false, error: "tx_reverted", detail: `Sui tx ${digest} did not succeed (status=${tx.status}).` };
+  }
+  if (typeof tx.timestampMs === "number") {
+    const ageSeconds = Math.floor(Date.now() / 1e3) - Math.floor(tx.timestampMs / 1e3);
+    if (ageSeconds > accept.maxTimeoutSeconds) {
+      return {
+        ok: false,
+        error: "payment_expired",
+        detail: `Payment is ${ageSeconds}s old; max allowed is ${accept.maxTimeoutSeconds}s.`
+      };
+    }
+  }
+  let paid = 0n;
+  let payer = "";
+  for (const bc of tx.balanceChanges) {
+    if (bc.coinType !== wantCoinType) continue;
+    let v;
+    try {
+      v = BigInt(bc.amount);
+    } catch {
+      continue;
+    }
+    if (bc.owner === accept.payTo && v > 0n) paid += v;
+    else if (v < 0n && !payer) payer = bc.owner;
+  }
+  if (paid < required) {
+    return {
+      ok: false,
+      error: "transfer_not_found",
+      detail: `No Sui transfer of >= ${required} (${wantCoinType}) to ${accept.payTo} in ${digest}.`
+    };
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "onchain-proof",
+      success: true,
+      network: accept.network,
+      transaction: digest,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer,
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function txNotFound(digest) {
+  return {
+    ok: false,
+    error: "tx_not_found",
+    detail: `Sui tx ${digest} not found or not yet propagated \u2014 retry.`
+  };
+}
+
+// src/drivers/sui/wallet.ts
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+function assertSuiWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new WrongFamilyError(
+      `chain ${network} is Sui; wallet must be { privateKey } (suiprivkey1\u2026 ) or { keypair }.`
+    );
+  }
+  if ("walletClient" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is Sui; a viem { walletClient } can't be used \u2014 pass { privateKey } (suiprivkey1\u2026) or { keypair }.`
+    );
+  }
+  if ("secretKey" in wallet || "signer" in wallet || "mnemonic" in wallet || "keyPair" in wallet || "secret" in wallet || "seed" in wallet || "accountId" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is Sui; that looks like another family's wallet \u2014 pass { privateKey } (suiprivkey1\u2026) or { keypair }.`
+    );
+  }
+  if (!("privateKey" in wallet) && !("keypair" in wallet)) {
+    throw new WrongFamilyError(
+      `chain ${network} is Sui; wallet must be { privateKey } (suiprivkey1\u2026) or { keypair }.`
+    );
+  }
+  return wallet;
+}
+function resolveSuiKeypair(config) {
+  if (config.keypair) return config.keypair;
+  if (config.privateKey != null) {
+    try {
+      return Ed25519Keypair.fromSecretKey(config.privateKey);
+    } catch (cause) {
+      throw new WrongFamilyError(
+        "Sui wallet { privateKey } is not a valid suiprivkey1\u2026 secret (or 32-byte key).",
+        { cause }
+      );
+    }
+  }
+  throw new WrongFamilyError("Sui wallet needs { privateKey } (suiprivkey1\u2026) or { keypair }.");
+}
+
+// src/drivers/sui/index.ts
+var suiDriver = {
+  family: "sui",
+  resolve(opts) {
+    if (opts.chain !== "sui") return null;
+    const rpcUrl = opts.rpcUrl ?? SUI_MAINNET.defaultRpc;
+    return makeSuiNetwork(SUI_MAINNET, rpcUrl);
+  }
+};
+function ownerAddress(owner) {
+  if (owner && typeof owner === "object" && "AddressOwner" in owner) {
+    return owner.AddressOwner;
+  }
+  return "";
+}
+function makeSuiNetwork(preset, rpcUrl) {
+  const client = new SuiJsonRpcClient({ url: rpcUrl, network: "mainnet" });
+  const network = preset.caip2;
+  const reader = {
+    async getTransaction(digest) {
+      const tx = await client.getTransactionBlock({
+        digest,
+        options: { showBalanceChanges: true, showEffects: true }
+      });
+      if (!tx) return null;
+      const balanceChanges = (tx.balanceChanges ?? []).map((bc) => ({
+        owner: ownerAddress(bc.owner),
+        coinType: bc.coinType,
+        amount: bc.amount
+      }));
+      return {
+        status: tx.effects?.status?.status ?? "unknown",
+        timestampMs: tx.timestampMs != null ? Number(tx.timestampMs) : void 0,
+        balanceChanges
+      };
+    }
+  };
+  return {
+    family: "sui",
+    network,
+    supports: (n) => n === network,
+    resolveToken(token) {
+      if (token === "native") {
+        return { asset: "native", decimals: SUI_DECIMALS, symbol: SUI_SYMBOL };
+      }
+      if (typeof token === "string") {
+        const info = preset.tokens[token.toUpperCase()];
+        if (!info) {
+          const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
+          throw new UnknownTokenError(
+            `token "${token}" isn't built in for Sui (known: ${known}). Note: no native USDT on Sui. Pass { coinType, decimals } for a custom coin, or use 'native'.`
+          );
+        }
+        return { asset: info.coinType, decimals: info.decimals, symbol: info.symbol };
+      }
+      rejectForeignToken(token, "sui", network);
+      const t = token;
+      if (!t.coinType || typeof t.decimals !== "number") {
+        throw new WrongFamilyError(
+          `chain ${network} is Sui; a custom token must be { coinType, decimals }.`
+        );
+      }
+      return {
+        asset: t.coinType,
+        decimals: t.decimals,
+        ...t.symbol ? { symbol: t.symbol } : {}
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") return { symbol: SUI_SYMBOL, decimals: SUI_DECIMALS };
+      for (const info of Object.values(preset.tokens)) {
+        if (info.coinType === asset) return { symbol: info.symbol, decimals: info.decimals };
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (!isValidSuiAddress(payTo)) {
+        throw new WrongFamilyError(
+          `chain ${network} is Sui, but payTo "${payTo}" is not a valid Sui address (0x + 32 bytes).`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      return { _native: assertSuiWallet(wallet, network) };
+    },
+    async send(wallet, accept) {
+      const keypair = resolveSuiKeypair(wallet._native);
+      return paySui({ client, keypair, accept });
+    },
+    async confirm(ref) {
+      try {
+        const tx = await client.waitForTransaction({ digest: ref, options: { showEffects: true } });
+        return { height: String(tx.checkpoint ?? "0") };
+      } catch (err) {
+        throw new ConfirmationTimeoutError(`Sui tx ${ref} did not finalize in time.`, { cause: err });
+      }
+    },
+    async estimateCost() {
+      return nativeCost({
+        symbol: SUI_SYMBOL,
+        decimals: SUI_DECIMALS,
+        fee: 3000000n,
+        // ~0.003 SUI
+        basis: "heuristic",
+        detail: "\u22480.003 SUI (computation + storage; storage is largely rebated on success)"
+      });
+    },
+    async verify(ref, accept) {
+      return verifySui({ reader, digest: ref, accept });
+    }
+  };
+}
+export {
+  suiDriver
+};