@t2000/cli 0.22.25 → 0.23.0

package/dist/client-CK5OR2TP.js

@@ -1,746 +0,0 @@
-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-XOAZJ42V.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-CK5OR2TP.js.map