@t2000/cli 0.22.22 → 0.22.23

package/dist/client-I4SGZLVD.js

@@ -0,0 +1,746 @@
+import { createRequire as __createRequire } from 'module'; import { fileURLToPath as __fileURLToPath } from 'url'; import { dirname as __pathDirname } from 'path'; const require = __createRequire(import.meta.url); const __filename = __fileURLToPath(import.meta.url); const __dirname = __pathDirname(__filename);
+import {
+  $brand,
+  $input,
+  $output,
+  Base64_exports,
+  Json_exports,
+  NEVER,
+  TimePrecision,
+  ZodMiniAny,
+  ZodMiniArray,
+  ZodMiniBase64,
+  ZodMiniBase64URL,
+  ZodMiniBigInt,
+  ZodMiniBigIntFormat,
+  ZodMiniBoolean,
+  ZodMiniCIDRv4,
+  ZodMiniCIDRv6,
+  ZodMiniCUID,
+  ZodMiniCUID2,
+  ZodMiniCatch,
+  ZodMiniCodec,
+  ZodMiniCustom,
+  ZodMiniCustomStringFormat,
+  ZodMiniDate,
+  ZodMiniDefault,
+  ZodMiniDiscriminatedUnion,
+  ZodMiniE164,
+  ZodMiniEmail,
+  ZodMiniEmoji,
+  ZodMiniEnum,
+  ZodMiniExactOptional,
+  ZodMiniFile,
+  ZodMiniFunction,
+  ZodMiniGUID,
+  ZodMiniIPv4,
+  ZodMiniIPv6,
+  ZodMiniISODate,
+  ZodMiniISODateTime,
+  ZodMiniISODuration,
+  ZodMiniISOTime,
+  ZodMiniIntersection,
+  ZodMiniJWT,
+  ZodMiniKSUID,
+  ZodMiniLazy,
+  ZodMiniLiteral,
+  ZodMiniMAC,
+  ZodMiniMap,
+  ZodMiniNaN,
+  ZodMiniNanoID,
+  ZodMiniNever,
+  ZodMiniNonOptional,
+  ZodMiniNull,
+  ZodMiniNullable,
+  ZodMiniNumber,
+  ZodMiniNumberFormat,
+  ZodMiniObject,
+  ZodMiniOptional,
+  ZodMiniPipe,
+  ZodMiniPrefault,
+  ZodMiniPromise,
+  ZodMiniReadonly,
+  ZodMiniRecord,
+  ZodMiniSet,
+  ZodMiniString,
+  ZodMiniStringFormat,
+  ZodMiniSuccess,
+  ZodMiniSymbol,
+  ZodMiniTemplateLiteral,
+  ZodMiniTransform,
+  ZodMiniTuple,
+  ZodMiniType,
+  ZodMiniULID,
+  ZodMiniURL,
+  ZodMiniUUID,
+  ZodMiniUndefined,
+  ZodMiniUnion,
+  ZodMiniUnknown,
+  ZodMiniVoid,
+  ZodMiniXID,
+  ZodMiniXor,
+  _catch,
+  _default,
+  _endsWith,
+  _enum,
+  _function,
+  _gt,
+  _gte,
+  _includes,
+  _instanceof,
+  _lazy,
+  _length,
+  _lowercase,
+  _lt,
+  _lte,
+  _maxLength,
+  _maxSize,
+  _mime,
+  _minLength,
+  _minSize,
+  _multipleOf,
+  _negative,
+  _nonnegative,
+  _nonpositive,
+  _normalize,
+  _null,
+  _overwrite,
+  _positive,
+  _property,
+  _regex,
+  _size,
+  _startsWith,
+  _toLowerCase,
+  _toUpperCase,
+  _trim,
+  _undefined,
+  _uppercase,
+  _void,
+  any,
+  array,
+  base64,
+  base64url,
+  bigint,
+  boolean,
+  catchall,
+  check,
+  cidrv4,
+  cidrv6,
+  clone,
+  codec,
+  coerce_exports,
+  config,
+  core_exports,
+  cuid,
+  cuid2,
+  custom,
+  date,
+  decode,
+  decodeAsync,
+  describe,
+  discriminatedUnion,
+  e164,
+  email,
+  emoji,
+  encode,
+  encodeAsync,
+  exactOptional,
+  extend,
+  external_exports,
+  file,
+  flattenError,
+  float32,
+  float64,
+  formatError,
+  globalRegistry,
+  guid,
+  hex,
+  hostname,
+  httpUrl,
+  int,
+  int32,
+  int64,
+  intersection,
+  ipv4,
+  ipv6,
+  iso_exports,
+  json,
+  jwt,
+  keyof,
+  ksuid,
+  literal,
+  locales_exports,
+  looseObject,
+  looseRecord,
+  mac,
+  map,
+  merge,
+  meta,
+  nan,
+  nanoid,
+  nativeEnum,
+  never,
+  nonoptional,
+  nullable,
+  nullish,
+  number,
+  object,
+  omit,
+  optional,
+  parse,
+  parseAsync,
+  partial,
+  partialRecord,
+  pick,
+  pipe,
+  prefault,
+  prettifyError,
+  promise,
+  readonly,
+  record,
+  refine,
+  regexes_exports,
+  registry,
+  required,
+  safeDecode,
+  safeDecodeAsync,
+  safeEncode,
+  safeEncodeAsync,
+  safeExtend,
+  safeParse,
+  safeParseAsync,
+  set,
+  strictObject,
+  string,
+  stringFormat,
+  stringbool,
+  success,
+  superRefine,
+  symbol,
+  templateLiteral,
+  toJSONSchema,
+  transform,
+  treeifyError,
+  tuple,
+  uint32,
+  uint64,
+  ulid,
+  union,
+  unknown,
+  url,
+  util_exports,
+  uuid,
+  uuidv4,
+  uuidv6,
+  uuidv7,
+  xid,
+  xor
+} from "./chunk-EEPD7SHV.js";
+import "./chunk-NGS6K3I3.js";
+import "./chunk-77SWBATH.js";
+import "./chunk-7LGHVVIJ.js";
+import {
+  Transaction
+} from "./chunk-KHIL2KNW.js";
+import "./chunk-3XUF7GM3.js";
+import {
+  __export
+} from "./chunk-YPWSCLE3.js";
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.3.6__express@5.2.1_hono@4.12.9_openap_c4e524ef2c460fde6664b2d190f6f806/node_modules/mppx/dist/PaymentRequest.js
+function deserialize(encoded) {
+  const json2 = Base64_exports.toString(encoded);
+  return JSON.parse(json2);
+}
+function serialize(request) {
+  const json2 = Json_exports.canonicalize(request);
+  return Base64_exports.fromString(json2, { pad: false, url: true });
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.3.6__express@5.2.1_hono@4.12.9_openap_c4e524ef2c460fde6664b2d190f6f806/node_modules/mppx/dist/zod.js
+var zod_exports = {};
+__export(zod_exports, {
+  $brand: () => $brand,
+  $input: () => $input,
+  $output: () => $output,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  ZodMiniAny: () => ZodMiniAny,
+  ZodMiniArray: () => ZodMiniArray,
+  ZodMiniBase64: () => ZodMiniBase64,
+  ZodMiniBase64URL: () => ZodMiniBase64URL,
+  ZodMiniBigInt: () => ZodMiniBigInt,
+  ZodMiniBigIntFormat: () => ZodMiniBigIntFormat,
+  ZodMiniBoolean: () => ZodMiniBoolean,
+  ZodMiniCIDRv4: () => ZodMiniCIDRv4,
+  ZodMiniCIDRv6: () => ZodMiniCIDRv6,
+  ZodMiniCUID: () => ZodMiniCUID,
+  ZodMiniCUID2: () => ZodMiniCUID2,
+  ZodMiniCatch: () => ZodMiniCatch,
+  ZodMiniCodec: () => ZodMiniCodec,
+  ZodMiniCustom: () => ZodMiniCustom,
+  ZodMiniCustomStringFormat: () => ZodMiniCustomStringFormat,
+  ZodMiniDate: () => ZodMiniDate,
+  ZodMiniDefault: () => ZodMiniDefault,
+  ZodMiniDiscriminatedUnion: () => ZodMiniDiscriminatedUnion,
+  ZodMiniE164: () => ZodMiniE164,
+  ZodMiniEmail: () => ZodMiniEmail,
+  ZodMiniEmoji: () => ZodMiniEmoji,
+  ZodMiniEnum: () => ZodMiniEnum,
+  ZodMiniExactOptional: () => ZodMiniExactOptional,
+  ZodMiniFile: () => ZodMiniFile,
+  ZodMiniFunction: () => ZodMiniFunction,
+  ZodMiniGUID: () => ZodMiniGUID,
+  ZodMiniIPv4: () => ZodMiniIPv4,
+  ZodMiniIPv6: () => ZodMiniIPv6,
+  ZodMiniISODate: () => ZodMiniISODate,
+  ZodMiniISODateTime: () => ZodMiniISODateTime,
+  ZodMiniISODuration: () => ZodMiniISODuration,
+  ZodMiniISOTime: () => ZodMiniISOTime,
+  ZodMiniIntersection: () => ZodMiniIntersection,
+  ZodMiniJWT: () => ZodMiniJWT,
+  ZodMiniKSUID: () => ZodMiniKSUID,
+  ZodMiniLazy: () => ZodMiniLazy,
+  ZodMiniLiteral: () => ZodMiniLiteral,
+  ZodMiniMAC: () => ZodMiniMAC,
+  ZodMiniMap: () => ZodMiniMap,
+  ZodMiniNaN: () => ZodMiniNaN,
+  ZodMiniNanoID: () => ZodMiniNanoID,
+  ZodMiniNever: () => ZodMiniNever,
+  ZodMiniNonOptional: () => ZodMiniNonOptional,
+  ZodMiniNull: () => ZodMiniNull,
+  ZodMiniNullable: () => ZodMiniNullable,
+  ZodMiniNumber: () => ZodMiniNumber,
+  ZodMiniNumberFormat: () => ZodMiniNumberFormat,
+  ZodMiniObject: () => ZodMiniObject,
+  ZodMiniOptional: () => ZodMiniOptional,
+  ZodMiniPipe: () => ZodMiniPipe,
+  ZodMiniPrefault: () => ZodMiniPrefault,
+  ZodMiniPromise: () => ZodMiniPromise,
+  ZodMiniReadonly: () => ZodMiniReadonly,
+  ZodMiniRecord: () => ZodMiniRecord,
+  ZodMiniSet: () => ZodMiniSet,
+  ZodMiniString: () => ZodMiniString,
+  ZodMiniStringFormat: () => ZodMiniStringFormat,
+  ZodMiniSuccess: () => ZodMiniSuccess,
+  ZodMiniSymbol: () => ZodMiniSymbol,
+  ZodMiniTemplateLiteral: () => ZodMiniTemplateLiteral,
+  ZodMiniTransform: () => ZodMiniTransform,
+  ZodMiniTuple: () => ZodMiniTuple,
+  ZodMiniType: () => ZodMiniType,
+  ZodMiniULID: () => ZodMiniULID,
+  ZodMiniURL: () => ZodMiniURL,
+  ZodMiniUUID: () => ZodMiniUUID,
+  ZodMiniUndefined: () => ZodMiniUndefined,
+  ZodMiniUnion: () => ZodMiniUnion,
+  ZodMiniUnknown: () => ZodMiniUnknown,
+  ZodMiniVoid: () => ZodMiniVoid,
+  ZodMiniXID: () => ZodMiniXID,
+  ZodMiniXor: () => ZodMiniXor,
+  _default: () => _default,
+  _function: () => _function,
+  address: () => address,
+  amount: () => amount,
+  any: () => any,
+  array: () => array,
+  base64: () => base64,
+  base64url: () => base64url,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  catch: () => _catch,
+  catchall: () => catchall,
+  check: () => check,
+  cidrv4: () => cidrv4,
+  cidrv6: () => cidrv6,
+  clone: () => clone,
+  codec: () => codec,
+  coerce: () => coerce_exports,
+  config: () => config,
+  core: () => core_exports,
+  cuid: () => cuid,
+  cuid2: () => cuid2,
+  custom: () => custom,
+  date: () => date,
+  datetime: () => datetime,
+  decode: () => decode,
+  decodeAsync: () => decodeAsync,
+  describe: () => describe,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e164,
+  email: () => email,
+  emoji: () => emoji,
+  encode: () => encode,
+  encodeAsync: () => encodeAsync,
+  endsWith: () => _endsWith,
+  enum: () => _enum,
+  exactOptional: () => exactOptional,
+  extend: () => extend,
+  file: () => file,
+  flattenError: () => flattenError,
+  float32: () => float32,
+  float64: () => float64,
+  formatError: () => formatError,
+  function: () => _function,
+  globalRegistry: () => globalRegistry,
+  gt: () => _gt,
+  gte: () => _gte,
+  guid: () => guid,
+  hash: () => hash,
+  hex: () => hex,
+  hostname: () => hostname,
+  httpUrl: () => httpUrl,
+  includes: () => _includes,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  ipv4: () => ipv4,
+  ipv6: () => ipv6,
+  iso: () => iso_exports,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid,
+  lazy: () => _lazy,
+  length: () => _length,
+  literal: () => literal,
+  locales: () => locales_exports,
+  looseObject: () => looseObject,
+  looseRecord: () => looseRecord,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  mac: () => mac,
+  map: () => map,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  maximum: () => _lte,
+  merge: () => merge,
+  meta: () => meta,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  minimum: () => _gte,
+  multipleOf: () => _multipleOf,
+  nan: () => nan,
+  nanoid: () => nanoid,
+  nativeEnum: () => nativeEnum,
+  negative: () => _negative,
+  never: () => never,
+  nonnegative: () => _nonnegative,
+  nonoptional: () => nonoptional,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  null: () => _null,
+  nullable: () => nullable,
+  nullish: () => nullish,
+  number: () => number,
+  object: () => object,
+  omit: () => omit,
+  optional: () => optional,
+  overwrite: () => _overwrite,
+  parse: () => parse,
+  parseAsync: () => parseAsync,
+  partial: () => partial,
+  partialRecord: () => partialRecord,
+  period: () => period,
+  pick: () => pick,
+  pipe: () => pipe,
+  positive: () => _positive,
+  prefault: () => prefault,
+  prettifyError: () => prettifyError,
+  promise: () => promise,
+  property: () => _property,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  regex: () => _regex,
+  regexes: () => regexes_exports,
+  registry: () => registry,
+  required: () => required,
+  safeDecode: () => safeDecode,
+  safeDecodeAsync: () => safeDecodeAsync,
+  safeEncode: () => safeEncode,
+  safeEncodeAsync: () => safeEncodeAsync,
+  safeExtend: () => safeExtend,
+  safeParse: () => safeParse,
+  safeParseAsync: () => safeParseAsync,
+  set: () => set,
+  signature: () => signature,
+  size: () => _size,
+  startsWith: () => _startsWith,
+  strictObject: () => strictObject,
+  string: () => string,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  toJSONSchema: () => toJSONSchema,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  transform: () => transform,
+  treeifyError: () => treeifyError,
+  trim: () => _trim,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid,
+  undefined: () => _undefined,
+  union: () => union,
+  unknown: () => unknown,
+  unwrapOptional: () => unwrapOptional,
+  uppercase: () => _uppercase,
+  url: () => url,
+  util: () => util_exports,
+  uuid: () => uuid,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void,
+  xid: () => xid,
+  xor: () => xor,
+  z: () => external_exports
+});
+function amount() {
+  return external_exports.string().check(external_exports.regex(/^\d+(\.\d+)?$/, "Invalid amount"));
+}
+function datetime() {
+  return external_exports.string().check(external_exports.regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/, "Invalid ISO 8601 datetime"));
+}
+function address() {
+  return external_exports.string().check(external_exports.regex(/^0x[0-9a-fA-F]{40}$/, "Invalid address"));
+}
+function hash() {
+  return external_exports.string().check(external_exports.regex(/^0x[0-9a-fA-F]{64}$/, "Invalid hash"));
+}
+function period() {
+  return external_exports.string().check(external_exports.regex(/^(day|week|month|year|\d+)$/, "Invalid period"));
+}
+function signature() {
+  return external_exports.string().check(external_exports.regex(/^0x[0-9a-fA-F]+$/, "Invalid signature"));
+}
+function unwrapOptional(schema) {
+  if (schema._zod.def.type === "optional")
+    return schema._zod.def.innerType;
+  return schema;
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.3.6__express@5.2.1_hono@4.12.9_openap_c4e524ef2c460fde6664b2d190f6f806/node_modules/mppx/dist/Challenge.js
+var Schema = object({
+  /** Optional human-readable description of the payment. */
+  description: optional(string()),
+  /** Optional digest of the request body (format: "sha-256=base64hash"). */
+  digest: optional(string().check(_regex(/^sha-256=/, "Invalid digest format"))),
+  /** Optional expiration timestamp (ISO 8601). */
+  expires: optional(datetime()),
+  /** Unique challenge identifier (HMAC-bound). */
+  id: string(),
+  /** Intent type (e.g., "charge", "session"). */
+  intent: string(),
+  /** Payment method (e.g., "tempo", "stripe"). */
+  method: string(),
+  /** Optional server-defined correlation data. Flat string-to-string map; clients MUST NOT modify. */
+  opaque: optional(record(string(), string())),
+  /** Server realm (e.g., hostname). */
+  realm: string(),
+  /** Method-specific request data. */
+  request: record(string(), unknown())
+});
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.3.6__express@5.2.1_hono@4.12.9_openap_c4e524ef2c460fde6664b2d190f6f806/node_modules/mppx/dist/Credential.js
+var Credential_exports = {};
+__export(Credential_exports, {
+  deserialize: () => deserialize2,
+  extractPaymentScheme: () => extractPaymentScheme,
+  from: () => from,
+  fromRequest: () => fromRequest,
+  serialize: () => serialize2
+});
+function deserialize2(value) {
+  const prefixMatch = value.match(/^Payment\s+(.+)$/i);
+  if (!prefixMatch?.[1])
+    throw new Error("Missing Payment scheme.");
+  try {
+    const json2 = Base64_exports.toString(prefixMatch[1]);
+    const parsed = JSON.parse(json2);
+    const challenge = Schema.parse({
+      ...parsed.challenge,
+      request: deserialize(parsed.challenge.request)
+    });
+    return {
+      challenge,
+      payload: parsed.payload,
+      ...parsed.source && { source: parsed.source }
+    };
+  } catch {
+    throw new Error("Invalid base64url or JSON.");
+  }
+}
+function from(parameters) {
+  const { challenge, payload, source } = parameters;
+  return {
+    challenge,
+    payload,
+    ...source && { source }
+  };
+}
+function fromRequest(request) {
+  const header = request.headers.get("Authorization");
+  if (!header)
+    throw new Error("Missing Authorization header.");
+  const payment = extractPaymentScheme(header);
+  if (!payment)
+    throw new Error("Missing Payment scheme.");
+  return deserialize2(payment);
+}
+function serialize2(credential) {
+  const wire = {
+    challenge: {
+      ...credential.challenge,
+      request: serialize(credential.challenge.request)
+    },
+    payload: credential.payload,
+    ...credential.source && { source: credential.source }
+  };
+  const json2 = JSON.stringify(wire);
+  const encoded = Base64_exports.fromString(json2, { pad: false, url: true });
+  return `Payment ${encoded}`;
+}
+function extractPaymentScheme(header) {
+  const schemes = header.split(",").map((s) => s.trim());
+  return schemes.find((s) => /^Payment\s+/i.test(s)) ?? null;
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.3.6__express@5.2.1_hono@4.12.9_openap_c4e524ef2c460fde6664b2d190f6f806/node_modules/mppx/dist/Method.js
+var Method_exports = {};
+__export(Method_exports, {
+  from: () => from2,
+  toClient: () => toClient,
+  toServer: () => toServer
+});
+function from2(method) {
+  return method;
+}
+function toClient(method, options) {
+  const { context, createCredential } = options;
+  return {
+    ...method,
+    context,
+    createCredential
+  };
+}
+function toServer(method, options) {
+  const { defaults, request, respond, transport, verify } = options;
+  return {
+    ...method,
+    defaults,
+    request,
+    respond,
+    transport,
+    verify
+  };
+}
+
+// ../mpp-sui/dist/client.js
+var suiCharge = Method_exports.from({
+  intent: "charge",
+  name: "sui",
+  schema: {
+    credential: {
+      payload: zod_exports.object({
+        digest: zod_exports.string()
+      })
+    },
+    request: zod_exports.object({
+      amount: zod_exports.string(),
+      currency: zod_exports.string(),
+      recipient: zod_exports.string()
+    })
+  }
+});
+var SUI_USDC_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
+async function fetchCoins(client, owner, coinType) {
+  const coins = [];
+  let cursor;
+  let hasNext = true;
+  while (hasNext) {
+    const page = await client.getCoins({ owner, coinType, cursor: cursor ?? void 0 });
+    coins.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
+    cursor = page.nextCursor;
+    hasNext = page.hasNextPage;
+  }
+  return coins;
+}
+function parseAmountToRaw(amount2, decimals) {
+  const [whole = "0", frac = ""] = amount2.split(".");
+  const paddedFrac = frac.padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(whole + paddedFrac);
+}
+function sui(options) {
+  const address2 = options.signer.getAddress();
+  return Method_exports.toClient(suiCharge, {
+    async createCredential({ challenge }) {
+      const { amount: amount2, currency, recipient } = challenge.request;
+      const amountRaw = parseAmountToRaw(amount2, 6);
+      const coins = await fetchCoins(options.client, address2, currency);
+      if (coins.length === 0) {
+        throw new Error(
+          `No ${currency.split("::").pop()} balance to pay with`
+        );
+      }
+      const totalBalance = coins.reduce(
+        (sum, c) => sum + BigInt(c.balance),
+        0n
+      );
+      if (totalBalance < amountRaw) {
+        const available = Number(totalBalance) / 1e6;
+        const requested = Number(amountRaw) / 1e6;
+        throw new Error(
+          `Not enough USDC to pay $${requested.toFixed(2)} (available: $${available.toFixed(2)})`
+        );
+      }
+      const tx = new Transaction();
+      tx.setSender(address2);
+      const primaryCoin = tx.object(coins[0].coinObjectId);
+      if (coins.length > 1) {
+        tx.mergeCoins(
+          primaryCoin,
+          coins.slice(1).map((c) => tx.object(c.coinObjectId))
+        );
+      }
+      const [payment] = tx.splitCoins(primaryCoin, [amountRaw]);
+      tx.transferObjects([payment], recipient);
+      let result;
+      try {
+        if (options.execute) {
+          result = await options.execute(tx);
+        } else {
+          tx.setSender(address2);
+          const built = await tx.build({ client: options.client });
+          const { signature: signature2 } = await options.signer.signTransaction(built);
+          result = await options.client.executeTransactionBlock({
+            transactionBlock: built,
+            signature: signature2,
+            options: { showEffects: true }
+          });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Payment transaction failed: ${msg}`);
+      }
+      return Credential_exports.serialize({
+        challenge,
+        payload: { digest: result.digest }
+      });
+    }
+  });
+}
+export {
+  SUI_USDC_TYPE,
+  sui,
+  suiCharge
+};
+//# sourceMappingURL=client-I4SGZLVD.js.map