@rialo/spl-token 0.3.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,1356 @@
+import { PublicKey, SYSTEM_PROGRAM_ID, TransactionBuilder, isOnCurve } from '@rialo/ts-cdk';
+
+// src/client/spl-token-client.ts
+
+// src/constants.ts
+var TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+var ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+var TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var MINT_SIZE = 82;
+var TOKEN_ACCOUNT_SIZE = 165;
+var MINT_SUPPLY_OFFSET = 36;
+var MINT_DECIMALS_OFFSET = 44;
+var MINT_IS_INITIALIZED_OFFSET = 45;
+var MINT_FREEZE_AUTHORITY_OFFSET = 46;
+var TOKEN_ACCOUNT_MINT_OFFSET = 0;
+var TOKEN_ACCOUNT_OWNER_OFFSET = 32;
+var TOKEN_ACCOUNT_AMOUNT_OFFSET = 64;
+var TOKEN_ACCOUNT_DELEGATE_OFFSET = 72;
+var TOKEN_ACCOUNT_STATE_OFFSET = 108;
+var TOKEN_ACCOUNT_IS_NATIVE_OFFSET = 109;
+var TOKEN_ACCOUNT_DELEGATED_AMOUNT_OFFSET = 121;
+var TOKEN_ACCOUNT_CLOSE_AUTHORITY_OFFSET = 129;
+var COPTION_SOME = 1;
+var PUBKEY_SIZE = 32;
+var TokenAccountState = /* @__PURE__ */ ((TokenAccountState2) => {
+  TokenAccountState2[TokenAccountState2["Uninitialized"] = 0] = "Uninitialized";
+  TokenAccountState2[TokenAccountState2["Initialized"] = 1] = "Initialized";
+  TokenAccountState2[TokenAccountState2["Frozen"] = 2] = "Frozen";
+  return TokenAccountState2;
+})(TokenAccountState || {});
+var ExtensionType = /* @__PURE__ */ ((ExtensionType2) => {
+  ExtensionType2[ExtensionType2["Uninitialized"] = 0] = "Uninitialized";
+  ExtensionType2[ExtensionType2["TransferFeeConfig"] = 1] = "TransferFeeConfig";
+  ExtensionType2[ExtensionType2["TransferFeeAmount"] = 2] = "TransferFeeAmount";
+  ExtensionType2[ExtensionType2["MintCloseAuthority"] = 3] = "MintCloseAuthority";
+  ExtensionType2[ExtensionType2["ConfidentialTransferMint"] = 4] = "ConfidentialTransferMint";
+  ExtensionType2[ExtensionType2["ConfidentialTransferAccount"] = 5] = "ConfidentialTransferAccount";
+  ExtensionType2[ExtensionType2["DefaultAccountState"] = 6] = "DefaultAccountState";
+  ExtensionType2[ExtensionType2["ImmutableOwner"] = 7] = "ImmutableOwner";
+  ExtensionType2[ExtensionType2["MemoTransfer"] = 8] = "MemoTransfer";
+  ExtensionType2[ExtensionType2["NonTransferable"] = 9] = "NonTransferable";
+  ExtensionType2[ExtensionType2["InterestBearingConfig"] = 10] = "InterestBearingConfig";
+  ExtensionType2[ExtensionType2["CpiGuard"] = 11] = "CpiGuard";
+  ExtensionType2[ExtensionType2["PermanentDelegate"] = 12] = "PermanentDelegate";
+  ExtensionType2[ExtensionType2["NonTransferableAccount"] = 13] = "NonTransferableAccount";
+  ExtensionType2[ExtensionType2["TransferHook"] = 14] = "TransferHook";
+  ExtensionType2[ExtensionType2["TransferHookAccount"] = 15] = "TransferHookAccount";
+  ExtensionType2[ExtensionType2["ConfidentialTransferFeeConfig"] = 16] = "ConfidentialTransferFeeConfig";
+  ExtensionType2[ExtensionType2["ConfidentialTransferFeeAmount"] = 17] = "ConfidentialTransferFeeAmount";
+  ExtensionType2[ExtensionType2["MetadataPointer"] = 18] = "MetadataPointer";
+  ExtensionType2[ExtensionType2["TokenMetadata"] = 19] = "TokenMetadata";
+  ExtensionType2[ExtensionType2["GroupPointer"] = 20] = "GroupPointer";
+  ExtensionType2[ExtensionType2["TokenGroup"] = 21] = "TokenGroup";
+  ExtensionType2[ExtensionType2["GroupMemberPointer"] = 22] = "GroupMemberPointer";
+  ExtensionType2[ExtensionType2["TokenGroupMember"] = 23] = "TokenGroupMember";
+  return ExtensionType2;
+})(ExtensionType || {});
+var AccountType = /* @__PURE__ */ ((AccountType2) => {
+  AccountType2[AccountType2["Uninitialized"] = 0] = "Uninitialized";
+  AccountType2[AccountType2["Mint"] = 1] = "Mint";
+  AccountType2[AccountType2["Account"] = 2] = "Account";
+  return AccountType2;
+})(AccountType || {});
+var TokenInstruction = /* @__PURE__ */ ((TokenInstruction2) => {
+  TokenInstruction2[TokenInstruction2["InitializeMint"] = 0] = "InitializeMint";
+  TokenInstruction2[TokenInstruction2["InitializeAccount"] = 1] = "InitializeAccount";
+  TokenInstruction2[TokenInstruction2["InitializeMultisig"] = 2] = "InitializeMultisig";
+  TokenInstruction2[TokenInstruction2["Transfer"] = 3] = "Transfer";
+  TokenInstruction2[TokenInstruction2["Approve"] = 4] = "Approve";
+  TokenInstruction2[TokenInstruction2["Revoke"] = 5] = "Revoke";
+  TokenInstruction2[TokenInstruction2["SetAuthority"] = 6] = "SetAuthority";
+  TokenInstruction2[TokenInstruction2["MintTo"] = 7] = "MintTo";
+  TokenInstruction2[TokenInstruction2["Burn"] = 8] = "Burn";
+  TokenInstruction2[TokenInstruction2["CloseAccount"] = 9] = "CloseAccount";
+  TokenInstruction2[TokenInstruction2["FreezeAccount"] = 10] = "FreezeAccount";
+  TokenInstruction2[TokenInstruction2["ThawAccount"] = 11] = "ThawAccount";
+  TokenInstruction2[TokenInstruction2["TransferChecked"] = 12] = "TransferChecked";
+  TokenInstruction2[TokenInstruction2["ApproveChecked"] = 13] = "ApproveChecked";
+  TokenInstruction2[TokenInstruction2["MintToChecked"] = 14] = "MintToChecked";
+  TokenInstruction2[TokenInstruction2["BurnChecked"] = 15] = "BurnChecked";
+  TokenInstruction2[TokenInstruction2["InitializeAccount2"] = 16] = "InitializeAccount2";
+  TokenInstruction2[TokenInstruction2["SyncNative"] = 17] = "SyncNative";
+  TokenInstruction2[TokenInstruction2["InitializeAccount3"] = 18] = "InitializeAccount3";
+  TokenInstruction2[TokenInstruction2["InitializeMultisig2"] = 19] = "InitializeMultisig2";
+  TokenInstruction2[TokenInstruction2["InitializeMint2"] = 20] = "InitializeMint2";
+  return TokenInstruction2;
+})(TokenInstruction || {});
+var TLV_TYPE_SIZE = 2;
+var TLV_LENGTH_SIZE = 2;
+var MINT_EXTENSIONS_OFFSET = MINT_SIZE + 1;
+
+// src/errors.ts
+var SplTokenErrorCode = /* @__PURE__ */ ((SplTokenErrorCode2) => {
+  SplTokenErrorCode2["INVALID_MINT"] = "INVALID_MINT";
+  SplTokenErrorCode2["INVALID_TOKEN_ACCOUNT"] = "INVALID_TOKEN_ACCOUNT";
+  SplTokenErrorCode2["TOKEN_ACCOUNT_NOT_FOUND"] = "TOKEN_ACCOUNT_NOT_FOUND";
+  SplTokenErrorCode2["MINT_NOT_FOUND"] = "MINT_NOT_FOUND";
+  SplTokenErrorCode2["ACCOUNT_FROZEN"] = "ACCOUNT_FROZEN";
+  SplTokenErrorCode2["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+  SplTokenErrorCode2["INVALID_EXTENSION"] = "INVALID_EXTENSION";
+  SplTokenErrorCode2["PDA_DERIVATION_FAILED"] = "PDA_DERIVATION_FAILED";
+  SplTokenErrorCode2["INVALID_METADATA"] = "INVALID_METADATA";
+  SplTokenErrorCode2["ACCOUNT_NOT_INITIALIZED"] = "ACCOUNT_NOT_INITIALIZED";
+  return SplTokenErrorCode2;
+})(SplTokenErrorCode || {});
+var SplTokenError = class _SplTokenError extends Error {
+  code;
+  details;
+  constructor({ code, message, details }) {
+    super(message);
+    this.name = "SplTokenError";
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _SplTokenError);
+    }
+  }
+  /**
+   * Creates an invalid mint error.
+   *
+   * @param options - Error options containing the reason
+   */
+  static invalidMint({ reason }) {
+    return new _SplTokenError({
+      code: "INVALID_MINT" /* INVALID_MINT */,
+      message: `Invalid mint: ${reason}`
+    });
+  }
+  /**
+   * Creates an invalid token account error.
+   *
+   * @param options - Error options containing the reason
+   */
+  static invalidTokenAccount({ reason }) {
+    return new _SplTokenError({
+      code: "INVALID_TOKEN_ACCOUNT" /* INVALID_TOKEN_ACCOUNT */,
+      message: `Invalid token account: ${reason}`
+    });
+  }
+  /**
+   * Creates a token account not found error.
+   *
+   * @param options - Error options containing the address
+   */
+  static tokenAccountNotFound({ address }) {
+    return new _SplTokenError({
+      code: "TOKEN_ACCOUNT_NOT_FOUND" /* TOKEN_ACCOUNT_NOT_FOUND */,
+      message: `Token account not found: ${address}`,
+      details: { address }
+    });
+  }
+  /**
+   * Creates a mint not found error.
+   *
+   * @param options - Error options containing the address
+   */
+  static mintNotFound({ address }) {
+    return new _SplTokenError({
+      code: "MINT_NOT_FOUND" /* MINT_NOT_FOUND */,
+      message: `Mint not found: ${address}`,
+      details: { address }
+    });
+  }
+  /**
+   * Creates an account frozen error.
+   *
+   * @param options - Error options containing the address
+   */
+  static accountFrozen({ address }) {
+    return new _SplTokenError({
+      code: "ACCOUNT_FROZEN" /* ACCOUNT_FROZEN */,
+      message: `Token account is frozen: ${address}`,
+      details: { address }
+    });
+  }
+  /**
+   * Creates an insufficient balance error.
+   *
+   * @param options - Error options containing required and available amounts
+   */
+  static insufficientBalance({
+    required,
+    available
+  }) {
+    return new _SplTokenError({
+      code: "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */,
+      message: `Insufficient balance: required ${required}, available ${available}`,
+      details: { required: required.toString(), available: available.toString() }
+    });
+  }
+  /**
+   * Creates an invalid extension error.
+   *
+   * @param options - Error options containing the reason
+   */
+  static invalidExtension({ reason }) {
+    return new _SplTokenError({
+      code: "INVALID_EXTENSION" /* INVALID_EXTENSION */,
+      message: `Invalid extension: ${reason}`
+    });
+  }
+  /**
+   * Creates a PDA derivation failed error.
+   *
+   * @param options - Error options containing the reason
+   */
+  static pdaDerivationFailed({ reason }) {
+    return new _SplTokenError({
+      code: "PDA_DERIVATION_FAILED" /* PDA_DERIVATION_FAILED */,
+      message: `PDA derivation failed: ${reason}`
+    });
+  }
+  /**
+   * Creates an invalid metadata error.
+   *
+   * @param options - Error options containing the reason
+   */
+  static invalidMetadata({ reason }) {
+    return new _SplTokenError({
+      code: "INVALID_METADATA" /* INVALID_METADATA */,
+      message: `Invalid metadata: ${reason}`
+    });
+  }
+  /**
+   * Creates an account not initialized error.
+   *
+   * @param options - Error options containing the address
+   */
+  static accountNotInitialized({ address }) {
+    return new _SplTokenError({
+      code: "ACCOUNT_NOT_INITIALIZED" /* ACCOUNT_NOT_INITIALIZED */,
+      message: `Account not initialized: ${address}`,
+      details: { address }
+    });
+  }
+};
+function createAssociatedTokenAccountInstruction({
+  payer,
+  associatedToken,
+  owner,
+  mint,
+  programId = PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const associatedTokenProgramId = PublicKey.fromString(ASSOCIATED_TOKEN_PROGRAM_ID);
+  const systemProgramId = PublicKey.fromString(SYSTEM_PROGRAM_ID);
+  return {
+    programId: associatedTokenProgramId,
+    accounts: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: associatedToken, isSigner: false, isWritable: true },
+      { pubkey: owner, isSigner: false, isWritable: false },
+      { pubkey: mint, isSigner: false, isWritable: false },
+      { pubkey: systemProgramId, isSigner: false, isWritable: false },
+      { pubkey: programId, isSigner: false, isWritable: false }
+    ],
+    // CreateAssociatedTokenAccount has no instruction data
+    data: new Uint8Array(0)
+  };
+}
+function createAssociatedTokenAccountIdempotentInstruction({
+  payer,
+  associatedToken,
+  owner,
+  mint,
+  programId = PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const associatedTokenProgramId = PublicKey.fromString(ASSOCIATED_TOKEN_PROGRAM_ID);
+  const systemProgramId = PublicKey.fromString(SYSTEM_PROGRAM_ID);
+  return {
+    programId: associatedTokenProgramId,
+    accounts: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: associatedToken, isSigner: false, isWritable: true },
+      { pubkey: owner, isSigner: false, isWritable: false },
+      { pubkey: mint, isSigner: false, isWritable: false },
+      { pubkey: systemProgramId, isSigner: false, isWritable: false },
+      { pubkey: programId, isSigner: false, isWritable: false }
+    ],
+    // Idempotent variant uses instruction discriminator 1
+    data: new Uint8Array([1])
+  };
+}
+
+// src/test-helpers.ts
+function writeU64LE({
+  data,
+  offset,
+  value
+}) {
+  for (let i = 0; i < 8; i++) {
+    data[offset + i] = Number(value >> BigInt(i * 8) & 0xffn);
+  }
+}
+
+// src/instructions/mint.ts
+function initializeMintInstruction({
+  mint,
+  decimals,
+  mintAuthority,
+  freezeAuthority,
+  programId = PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const data = new Uint8Array(67);
+  data[0] = 20 /* InitializeMint2 */;
+  data[1] = decimals;
+  data.set(mintAuthority.toBytes(), 2);
+  if (freezeAuthority) {
+    data[34] = 1;
+    data.set(freezeAuthority.toBytes(), 35);
+  } else {
+    data[34] = 0;
+  }
+  const [tombstonePda] = PublicKey.findProgramAddress(
+    ["mint_tombstone", mint.toBytes()],
+    programId
+  );
+  return {
+    programId,
+    accounts: [
+      { pubkey: mint, isSigner: false, isWritable: true },
+      { pubkey: tombstonePda, isSigner: false, isWritable: false }
+    ],
+    data
+  };
+}
+function mintToInstruction({
+  mint,
+  destination,
+  authority,
+  amount,
+  programId = PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const data = new Uint8Array(9);
+  data[0] = 7 /* MintTo */;
+  writeU64LE({ data, offset: 1, value: amount });
+  return {
+    programId,
+    accounts: [
+      { pubkey: mint, isSigner: false, isWritable: true },
+      { pubkey: destination, isSigner: false, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false }
+    ],
+    data
+  };
+}
+function writeU64LE2({
+  data,
+  offset,
+  value
+}) {
+  for (let i = 0; i < 8; i++) {
+    data[offset + i] = Number(value >> BigInt(i * 8) & 0xffn);
+  }
+}
+function transferCheckedInstruction({
+  source,
+  mint,
+  destination,
+  authority,
+  amount,
+  decimals,
+  programId = PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const data = new Uint8Array(10);
+  data[0] = 12 /* TransferChecked */;
+  writeU64LE2({ data, offset: 1, value: amount });
+  data[9] = decimals;
+  return {
+    programId,
+    accounts: [
+      { pubkey: source, isSigner: false, isWritable: true },
+      { pubkey: mint, isSigner: false, isWritable: false },
+      { pubkey: destination, isSigner: false, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false }
+    ],
+    data
+  };
+}
+function transferInstruction({
+  source,
+  destination,
+  authority,
+  amount,
+  programId = PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const data = new Uint8Array(9);
+  data[0] = 3 /* Transfer */;
+  writeU64LE2({ data, offset: 1, value: amount });
+  return {
+    programId,
+    accounts: [
+      { pubkey: source, isSigner: false, isWritable: true },
+      { pubkey: destination, isSigner: false, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false }
+    ],
+    data
+  };
+}
+
+// node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen) {
+    const prefix = title && `"${title}" `;
+    const ofLen = "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+  blockLen;
+  outputLen;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor();
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+  constructor(outputLen) {
+    super(64, outputLen, 8, false);
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var _SHA256 = class extends SHA2_32B {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  A = SHA256_IV[0] | 0;
+  B = SHA256_IV[1] | 0;
+  C = SHA256_IV[2] | 0;
+  D = SHA256_IV[3] | 0;
+  E = SHA256_IV[4] | 0;
+  F = SHA256_IV[5] | 0;
+  G = SHA256_IV[6] | 0;
+  H = SHA256_IV[7] | 0;
+  constructor() {
+    super(32);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+function createProgramAddress({
+  seeds,
+  programId
+}) {
+  for (let bump = 255; bump >= 0; bump--) {
+    const bumpSeed = new Uint8Array([bump]);
+    const allSeeds = [...seeds, bumpSeed];
+    const programIdBytes = programId.toBytes();
+    const pda_marker = new TextEncoder().encode("ProgramDerivedAddress");
+    let totalLength = 0;
+    for (const seed of allSeeds) {
+      totalLength += seed.length;
+    }
+    totalLength += programIdBytes.length + pda_marker.length;
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const seed of allSeeds) {
+      combined.set(seed, offset);
+      offset += seed.length;
+    }
+    combined.set(programIdBytes, offset);
+    offset += programIdBytes.length;
+    combined.set(pda_marker, offset);
+    const hash = sha256(combined);
+    if (!isOnCurve(hash)) {
+      return {
+        address: PublicKey.fromBytes(hash),
+        bump
+      };
+    }
+  }
+  return null;
+}
+function findAssociatedTokenAddress({
+  wallet,
+  mint,
+  programId = PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const associatedTokenProgramId = PublicKey.fromString(ASSOCIATED_TOKEN_PROGRAM_ID);
+  const seeds = [wallet.toBytes(), programId.toBytes(), mint.toBytes()];
+  const result = createProgramAddress({ seeds, programId: associatedTokenProgramId });
+  if (!result) {
+    throw SplTokenError.pdaDerivationFailed({
+      reason: `Could not find valid PDA for wallet=${wallet.toString()}, mint=${mint.toString()}`
+    });
+  }
+  return result;
+}
+function getAssociatedTokenAddressSync({
+  wallet,
+  mint,
+  programId = PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  return findAssociatedTokenAddress({ wallet, mint, programId }).address;
+}
+function readU64LE({ data, offset }) {
+  let value = 0n;
+  for (let i = 0; i < 8; i++) {
+    value |= BigInt(data[offset + i]) << BigInt(i * 8);
+  }
+  return value;
+}
+function readU32LE({ data, offset }) {
+  return (data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24) >>> 0;
+}
+function readCOptionPubkey({
+  data,
+  offset
+}) {
+  const tag = readU32LE({ data, offset });
+  if (tag === COPTION_SOME) {
+    const pubkeyBytes = data.slice(offset + 4, offset + 4 + PUBKEY_SIZE);
+    return PublicKey.fromBytes(pubkeyBytes);
+  }
+  return null;
+}
+function parseMintAccount({ address, data }) {
+  if (data.length < MINT_SIZE) {
+    throw SplTokenError.invalidMint({
+      reason: `Account data too short: expected at least ${MINT_SIZE} bytes, got ${data.length}`
+    });
+  }
+  const mintAuthority = readCOptionPubkey({ data, offset: 0 });
+  const supply = readU64LE({ data, offset: MINT_SUPPLY_OFFSET });
+  const decimals = data[MINT_DECIMALS_OFFSET];
+  const isInitialized = data[MINT_IS_INITIALIZED_OFFSET] !== 0;
+  const freezeAuthority = readCOptionPubkey({ data, offset: MINT_FREEZE_AUTHORITY_OFFSET });
+  if (!isInitialized) {
+    throw SplTokenError.accountNotInitialized({ address: address.toString() });
+  }
+  return {
+    address,
+    supply,
+    decimals,
+    isInitialized,
+    mintAuthority,
+    freezeAuthority
+  };
+}
+function readU64LE2({ data, offset }) {
+  let value = 0n;
+  for (let i = 0; i < 8; i++) {
+    value |= BigInt(data[offset + i]) << BigInt(i * 8);
+  }
+  return value;
+}
+function readU32LE2({ data, offset }) {
+  return (data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24) >>> 0;
+}
+function readCOptionPubkey2({
+  data,
+  offset
+}) {
+  const tag = readU32LE2({ data, offset });
+  if (tag === COPTION_SOME) {
+    const pubkeyBytes = data.slice(offset + 4, offset + 4 + PUBKEY_SIZE);
+    return PublicKey.fromBytes(pubkeyBytes);
+  }
+  return null;
+}
+function readCOptionU64({ data, offset }) {
+  const tag = readU32LE2({ data, offset });
+  if (tag === COPTION_SOME) {
+    return readU64LE2({ data, offset: offset + 4 });
+  }
+  return null;
+}
+function parseTokenAccount({ address, data }) {
+  if (data.length < TOKEN_ACCOUNT_SIZE) {
+    throw SplTokenError.invalidTokenAccount({
+      reason: `Account data too short: expected at least ${TOKEN_ACCOUNT_SIZE} bytes, got ${data.length}`
+    });
+  }
+  const mintBytes = data.slice(TOKEN_ACCOUNT_MINT_OFFSET, TOKEN_ACCOUNT_MINT_OFFSET + PUBKEY_SIZE);
+  const mint = PublicKey.fromBytes(mintBytes);
+  const ownerBytes = data.slice(
+    TOKEN_ACCOUNT_OWNER_OFFSET,
+    TOKEN_ACCOUNT_OWNER_OFFSET + PUBKEY_SIZE
+  );
+  const owner = PublicKey.fromBytes(ownerBytes);
+  const amount = readU64LE2({ data, offset: TOKEN_ACCOUNT_AMOUNT_OFFSET });
+  const delegate = readCOptionPubkey2({ data, offset: TOKEN_ACCOUNT_DELEGATE_OFFSET });
+  const stateValue = data[TOKEN_ACCOUNT_STATE_OFFSET];
+  if (stateValue > 2) {
+    throw SplTokenError.invalidTokenAccount({ reason: `Invalid account state: ${stateValue}` });
+  }
+  const state = stateValue;
+  if (state === 0 /* Uninitialized */) {
+    throw SplTokenError.accountNotInitialized({ address: address.toString() });
+  }
+  const isNative = readCOptionU64({ data, offset: TOKEN_ACCOUNT_IS_NATIVE_OFFSET });
+  const delegatedAmount = readU64LE2({ data, offset: TOKEN_ACCOUNT_DELEGATED_AMOUNT_OFFSET });
+  const closeAuthority = readCOptionPubkey2({ data, offset: TOKEN_ACCOUNT_CLOSE_AUTHORITY_OFFSET });
+  return {
+    address,
+    mint,
+    owner,
+    amount,
+    delegate,
+    state,
+    isNative,
+    delegatedAmount,
+    closeAuthority
+  };
+}
+function readU16LE({ data, offset }) {
+  return data[offset] | data[offset + 1] << 8;
+}
+function readU32LE3({ data, offset }) {
+  return (data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24) >>> 0;
+}
+function readCOptionPubkey3({
+  data,
+  offset
+}) {
+  const tag = readU32LE3({ data, offset });
+  if (tag === COPTION_SOME) {
+    const pubkeyBytes = data.slice(offset + 4, offset + 4 + PUBKEY_SIZE);
+    return PublicKey.fromBytes(pubkeyBytes);
+  }
+  return null;
+}
+function readLengthPrefixedString({
+  data,
+  offset
+}) {
+  if (offset + 4 > data.length) {
+    throw SplTokenError.invalidMetadata({ reason: "String length prefix extends beyond data" });
+  }
+  const length = readU32LE3({ data, offset });
+  if (offset + 4 + length > data.length) {
+    throw SplTokenError.invalidMetadata({
+      reason: `String data extends beyond buffer: need ${length} bytes at offset ${offset + 4}`
+    });
+  }
+  const stringBytes = data.slice(offset + 4, offset + 4 + length);
+  try {
+    const str = new TextDecoder().decode(stringBytes);
+    return [str, 4 + length];
+  } catch (error) {
+    throw SplTokenError.invalidMetadata({
+      reason: `Invalid UTF-8 string at offset ${offset}`
+    });
+  }
+}
+function parseExtensions({
+  data,
+  extensionsOffset
+}) {
+  const extensions = [];
+  let offset = extensionsOffset;
+  while (offset + TLV_TYPE_SIZE + TLV_LENGTH_SIZE <= data.length) {
+    const type = readU16LE({ data, offset });
+    const length = readU16LE({ data, offset: offset + TLV_TYPE_SIZE });
+    if (type === 0 && length === 0) {
+      break;
+    }
+    const dataStart = offset + TLV_TYPE_SIZE + TLV_LENGTH_SIZE;
+    const dataEnd = dataStart + length;
+    if (dataEnd > data.length) {
+      throw SplTokenError.invalidExtension({
+        reason: `Extension data extends beyond buffer: type=${type}, length=${length}`
+      });
+    }
+    extensions.push({
+      type,
+      data: data.slice(dataStart, dataEnd)
+    });
+    offset = dataEnd;
+  }
+  return extensions;
+}
+function parseMetadataPointer({ data }) {
+  if (data.length < 72) {
+    throw SplTokenError.invalidExtension({
+      reason: `MetadataPointer too short: expected 72 bytes, got ${data.length}`
+    });
+  }
+  const authority = readCOptionPubkey3({ data, offset: 0 });
+  const metadataAddress = readCOptionPubkey3({ data, offset: 36 });
+  return { authority, metadataAddress };
+}
+function parseTokenMetadataExtension({
+  data,
+  mint
+}) {
+  if (data.length < 64) {
+    throw SplTokenError.invalidMetadata({
+      reason: `TokenMetadata too short: expected at least 64 bytes, got ${data.length}`
+    });
+  }
+  let offset = 0;
+  const updateAuthorityBytes = data.slice(offset, offset + PUBKEY_SIZE);
+  const isZeroAuthority = updateAuthorityBytes.every((b) => b === 0);
+  const updateAuthority = isZeroAuthority ? null : PublicKey.fromBytes(updateAuthorityBytes);
+  offset += PUBKEY_SIZE;
+  offset += PUBKEY_SIZE;
+  const [name, nameLen] = readLengthPrefixedString({ data, offset });
+  offset += nameLen;
+  const [symbol, symbolLen] = readLengthPrefixedString({ data, offset });
+  offset += symbolLen;
+  const [uri, uriLen] = readLengthPrefixedString({ data, offset });
+  offset += uriLen;
+  const additionalMetadata = [];
+  if (offset + 4 <= data.length) {
+    const numEntries = readU32LE3({ data, offset });
+    offset += 4;
+    for (let i = 0; i < numEntries && offset < data.length; i++) {
+      const [key, keyLen] = readLengthPrefixedString({ data, offset });
+      offset += keyLen;
+      const [value, valueLen] = readLengthPrefixedString({ data, offset });
+      offset += valueLen;
+      additionalMetadata.push([key, value]);
+    }
+  }
+  return {
+    updateAuthority,
+    mint,
+    name,
+    symbol,
+    uri,
+    additionalMetadata
+  };
+}
+function parseTokenMetadata({
+  mint,
+  data
+}) {
+  if (data.length <= MINT_SIZE) {
+    return null;
+  }
+  const accountType = data[MINT_SIZE];
+  if (accountType !== 1 /* Mint */) {
+    return null;
+  }
+  const extensions = parseExtensions({ data, extensionsOffset: MINT_EXTENSIONS_OFFSET });
+  const metadataExt = extensions.find((ext) => ext.type === 19 /* TokenMetadata */);
+  if (!metadataExt) {
+    return null;
+  }
+  return parseTokenMetadataExtension({ data: metadataExt.data, mint });
+}
+function parseMetadataPointerExtension({
+  data
+}) {
+  if (data.length <= MINT_SIZE) {
+    return null;
+  }
+  const accountType = data[MINT_SIZE];
+  if (accountType !== 1 /* Mint */) {
+    return null;
+  }
+  const extensions = parseExtensions({ data, extensionsOffset: MINT_EXTENSIONS_OFFSET });
+  const pointerExt = extensions.find((ext) => ext.type === 18 /* MetadataPointer */);
+  if (!pointerExt) {
+    return null;
+  }
+  return parseMetadataPointer({ data: pointerExt.data });
+}
+function getMintExtensions({ data }) {
+  if (data.length <= MINT_SIZE) {
+    return [];
+  }
+  const accountType = data[MINT_SIZE];
+  if (accountType !== 1 /* Mint */) {
+    return [];
+  }
+  return parseExtensions({ data, extensionsOffset: MINT_EXTENSIONS_OFFSET });
+}
+
+// src/client/spl-token-client.ts
+function decodeAccountData(data) {
+  if (data instanceof Uint8Array) return data;
+  const encoded = data[0];
+  const binaryStr = atob(encoded);
+  const bytes = new Uint8Array(binaryStr.length);
+  for (let i = 0; i < binaryStr.length; i++) {
+    bytes[i] = binaryStr.charCodeAt(i);
+  }
+  return bytes;
+}
+var SplTokenClient = class {
+  client;
+  programId;
+  /**
+   * Creates a new SplTokenClient.
+   *
+   * @param options - Client configuration options
+   */
+  constructor({
+    client,
+    programId = PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+  }) {
+    this.client = client;
+    this.programId = programId;
+  }
+  /**
+   * Gets the token program ID this client is configured to use.
+   */
+  getProgramId() {
+    return this.programId;
+  }
+  /**
+   * Retrieves mint account information.
+   *
+   * @param options - Options containing the mint public key
+   * @returns Parsed mint information including supply, decimals, and authorities
+   * @throws {SplTokenError} If the mint account doesn't exist or is invalid
+   *
+   * @example
+   * ```typescript
+   * const mintInfo = await tokenClient.getMintInfo({ mint: mintPubkey });
+   * console.log(`Supply: ${mintInfo.supply}`);
+   * console.log(`Decimals: ${mintInfo.decimals}`);
+   * console.log(`Mint Authority: ${mintInfo.mintAuthority?.toString() ?? 'disabled'}`);
+   * ```
+   */
+  async getMintInfo({ mint }) {
+    const accountInfo = await this.client.getAccountInfo(mint);
+    if (!accountInfo) {
+      throw SplTokenError.mintNotFound({ address: mint.toString() });
+    }
+    return parseMintAccount({ address: mint, data: decodeAccountData(accountInfo.data) });
+  }
+  /**
+   * Retrieves Token-2022 native metadata from a mint.
+   *
+   * @param options - Options containing the mint public key
+   * @returns Parsed token metadata, or null if no metadata extension exists
+   * @throws {SplTokenError} If the mint account doesn't exist
+   *
+   * @example
+   * ```typescript
+   * const metadata = await tokenClient.getTokenMetadata({ mint: mintPubkey });
+   * if (metadata) {
+   *   console.log(`Name: ${metadata.name}`);
+   *   console.log(`Symbol: ${metadata.symbol}`);
+   *   console.log(`URI: ${metadata.uri}`);
+   * }
+   * ```
+   */
+  async getTokenMetadata({ mint }) {
+    const accountInfo = await this.client.getAccountInfo(mint);
+    if (!accountInfo) {
+      throw SplTokenError.mintNotFound({ address: mint.toString() });
+    }
+    return parseTokenMetadata({ mint, data: decodeAccountData(accountInfo.data) });
+  }
+  /**
+   * Retrieves token account information.
+   *
+   * @param options - Options containing the token account public key
+   * @returns Parsed token account information
+   * @throws {SplTokenError} If the account doesn't exist or is invalid
+   */
+  async getTokenAccountInfo({
+    tokenAccount
+  }) {
+    const accountInfo = await this.client.getAccountInfo(tokenAccount);
+    if (!accountInfo) {
+      throw SplTokenError.tokenAccountNotFound({ address: tokenAccount.toString() });
+    }
+    return parseTokenAccount({ address: tokenAccount, data: decodeAccountData(accountInfo.data) });
+  }
+  /**
+   * Gets the token balance for a wallet.
+   *
+   * Automatically derives the Associated Token Address for the wallet/mint
+   * combination and retrieves the balance.
+   *
+   * @param options - Options containing wallet and mint public keys
+   * @returns The token balance in smallest units, or 0n if the ATA doesn't exist
+   *
+   * @example
+   * ```typescript
+   * const balance = await tokenClient.getBalance({ wallet: walletPubkey, mint: mintPubkey });
+   * console.log(`Token balance: ${balance}`);
+   * ```
+   */
+  async getBalance({ wallet, mint }) {
+    const ata = getAssociatedTokenAddressSync({ wallet, mint, programId: this.programId });
+    const accountInfo = await this.client.getAccountInfo(ata);
+    if (!accountInfo) {
+      return 0n;
+    }
+    const tokenAccount = parseTokenAccount({ address: ata, data: decodeAccountData(accountInfo.data) });
+    return tokenAccount.amount;
+  }
+  /**
+   * Derives the Associated Token Address for a wallet and mint.
+   *
+   * @param options - Options containing wallet and mint public keys
+   * @returns The derived ATA address and bump seed
+   *
+   * @example
+   * ```typescript
+   * const { address, bump } = tokenClient.getAssociatedTokenAddress({ wallet: walletPubkey, mint: mintPubkey });
+   * console.log(`ATA: ${address.toString()}`);
+   * ```
+   */
+  getAssociatedTokenAddress({
+    wallet,
+    mint
+  }) {
+    return findAssociatedTokenAddress({ wallet, mint, programId: this.programId });
+  }
+  /**
+   * Checks if an Associated Token Account exists.
+   *
+   * @param options - Options containing wallet and mint public keys
+   * @returns True if the ATA exists, false otherwise
+   */
+  async ataExists({ wallet, mint }) {
+    const ata = getAssociatedTokenAddressSync({ wallet, mint, programId: this.programId });
+    const accountInfo = await this.client.getAccountInfo(ata);
+    return accountInfo !== null;
+  }
+  /**
+   * Creates instructions for a token transfer.
+   *
+   * This builds the necessary instructions for transferring tokens,
+   * optionally creating the destination ATA if it doesn't exist.
+   *
+   * @param params - Transfer parameters
+   * @returns Array of instructions to execute
+   * @throws {SplTokenError} If the mint doesn't exist
+   *
+   * @example
+   * ```typescript
+   * const instructions = await tokenClient.createTransferInstructions({
+   *   source: senderWallet,
+   *   destination: recipientWallet,
+   *   mint: mintPubkey,
+   *   amount: 1000000n,
+   *   decimals: 6,
+   *   createDestinationAta: true,
+   * });
+   * ```
+   */
+  async createTransferInstructions(params) {
+    const { source, destination, mint, amount, decimals, createDestinationAta = true } = params;
+    const instructions = [];
+    const sourceAta = getAssociatedTokenAddressSync({
+      wallet: source,
+      mint,
+      programId: this.programId
+    });
+    const destinationAta = getAssociatedTokenAddressSync({
+      wallet: destination,
+      mint,
+      programId: this.programId
+    });
+    if (createDestinationAta) {
+      const destExists = await this.ataExists({ wallet: destination, mint });
+      if (!destExists) {
+        instructions.push(
+          createAssociatedTokenAccountIdempotentInstruction({
+            payer: source,
+            associatedToken: destinationAta,
+            owner: destination,
+            mint,
+            programId: this.programId
+          })
+        );
+      }
+    }
+    instructions.push(
+      transferCheckedInstruction({
+        source: sourceAta,
+        mint,
+        destination: destinationAta,
+        authority: source,
+        amount,
+        decimals,
+        programId: this.programId
+      })
+    );
+    return instructions;
+  }
+  /**
+   * Options for creating a transfer transaction.
+   */
+  /**
+   * Creates a transaction for a token transfer.
+   *
+   * Builds a complete transaction with all necessary instructions for
+   * transferring tokens, including ATA creation if needed.
+   *
+   * @param options - Options containing params and validFrom
+   * @returns Built transaction ready for signing
+   *
+   * @example
+   * ```typescript
+   * const blockHeight = await rialoClient.getBlockHeight();
+   * const configHashPrefix = await rialoClient.getConfigHashPrefix();
+   * const tx = await tokenClient.createTransferTransaction({
+   *   params: {
+   *     source: senderWallet,
+   *     destination: recipientWallet,
+   *     mint: mintPubkey,
+   *     amount: 1000000n,
+   *     decimals: 6,
+   *   },
+   *   validFrom: blockHeight,
+   *   configHashPrefix,
+   * });
+   *
+   * // Sign and send
+   * const signedTx = tx.sign([signer]);
+   * const signature = await rialoClient.sendTransaction(signedTx.serialize());
+   * ```
+   */
+  async createTransferTransaction({
+    params,
+    validFrom,
+    configHashPrefix
+  }) {
+    const instructions = await this.createTransferInstructions(params);
+    const builder = TransactionBuilder.create().setPayer(params.source).setValidFrom(validFrom).setConfigHashPrefix(configHashPrefix);
+    for (const ix of instructions) {
+      builder.addInstruction(ix);
+    }
+    return builder.build();
+  }
+  /**
+   * Transfers tokens from one wallet to another.
+   *
+   * This is a high-level convenience method that:
+   * 1. Creates the destination ATA if needed
+   * 2. Builds the transfer transaction
+   * 3. Signs and sends the transaction
+   * 4. Waits for confirmation
+   *
+   * @param options - Options containing params, validFrom, and signer
+   * @returns Transaction signature
+   *
+   * @example
+   * ```typescript
+   * const blockHeight = await rialoClient.getBlockHeight();
+   * const configHashPrefix = await rialoClient.getConfigHashPrefix();
+   * const signature = await tokenClient.transfer({
+   *   params: {
+   *     source: senderWallet,
+   *     destination: recipientWallet,
+   *     mint: mintPubkey,
+   *     amount: 1000000n,
+   *     decimals: 6,
+   *   },
+   *   validFrom: blockHeight,
+   *   configHashPrefix,
+   *   signer: senderSigner,
+   * });
+   * console.log(`Transfer complete: ${signature}`);
+   * ```
+   */
+  async transfer({
+    params,
+    validFrom,
+    configHashPrefix,
+    signer
+  }) {
+    const tx = await this.createTransferTransaction({ params, validFrom, configHashPrefix });
+    const signedTx = await tx.signWith(signer);
+    const result = await this.client.sendAndConfirmTransaction(signedTx.serialize());
+    return result.signature;
+  }
+};
+function createSplTokenClient({
+  client,
+  programId
+}) {
+  return new SplTokenClient({ client, programId });
+}
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+
+export { ASSOCIATED_TOKEN_PROGRAM_ID, AccountType, ExtensionType, MINT_SIZE, SplTokenClient, SplTokenError, SplTokenErrorCode, TOKEN_2022_PROGRAM_ID, TOKEN_ACCOUNT_SIZE, TOKEN_PROGRAM_ID, TokenAccountState, TokenInstruction, createAssociatedTokenAccountIdempotentInstruction, createAssociatedTokenAccountInstruction, createSplTokenClient, findAssociatedTokenAddress, getAssociatedTokenAddressSync, getMintExtensions, initializeMintInstruction, mintToInstruction, parseMetadataPointerExtension, parseMintAccount, parseTokenAccount, parseTokenMetadata, transferCheckedInstruction, transferInstruction };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map