@rialo/spl-token 0.3.0-alpha.0 → 0.3.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 var tsCdk = require('@rialo/ts-cdk');
 
-// src/client/spl-token-client.ts
+// src/builders/mint-builder.ts
 
 // src/constants.ts
 var TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
@@ -85,157 +85,501 @@ var TokenInstruction = /* @__PURE__ */ ((TokenInstruction2) => {
   TokenInstruction2[TokenInstruction2["InitializeAccount3"] = 18] = "InitializeAccount3";
   TokenInstruction2[TokenInstruction2["InitializeMultisig2"] = 19] = "InitializeMultisig2";
   TokenInstruction2[TokenInstruction2["InitializeMint2"] = 20] = "InitializeMint2";
+  TokenInstruction2[TokenInstruction2["TransferFeeExtension"] = 26] = "TransferFeeExtension";
+  TokenInstruction2[TokenInstruction2["InitializeNonTransferableMint"] = 32] = "InitializeNonTransferableMint";
+  TokenInstruction2[TokenInstruction2["InitializePermanentDelegate"] = 35] = "InitializePermanentDelegate";
+  TokenInstruction2[TokenInstruction2["TransferHookExtension"] = 36] = "TransferHookExtension";
+  TokenInstruction2[TokenInstruction2["MetadataPointerExtension"] = 39] = "MetadataPointerExtension";
   return TokenInstruction2;
 })(TokenInstruction || {});
 var TLV_TYPE_SIZE = 2;
 var TLV_LENGTH_SIZE = 2;
-var MINT_EXTENSIONS_OFFSET = MINT_SIZE + 1;
+var MINT_EXTENSIONS_OFFSET = TOKEN_ACCOUNT_SIZE + 1;
+var TOKEN_ACCOUNT_EXTENSIONS_OFFSET = TOKEN_ACCOUNT_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);
-    }
+// 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);
   }
-  /**
-   * 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}`
-    });
+  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);
   }
-  /**
-   * 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}`
-    });
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
   }
-  /**
-   * 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 }
-    });
+}
+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);
   }
-  /**
-   * 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 }
-    });
+  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;
   }
-  /**
-   * 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 }
-    });
+  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);
   }
-  /**
-   * 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() }
-    });
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
   }
-  /**
-   * 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}`
-    });
+  _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;
   }
-  /**
-   * 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}`
-    });
+  clone() {
+    return this._cloneInto();
   }
-  /**
-   * 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}`
-    });
+};
+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);
   }
-  /**
-   * 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 }
-    });
+  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)
+);
+var TOKEN_METADATA_NAMESPACE = "rialo_s_spl_token_metadata_interface";
+var TOKEN_METADATA_DISCRIMINATOR_LENGTH = 8;
+function metadataDiscriminator(label) {
+  const input = new TextEncoder().encode(`${TOKEN_METADATA_NAMESPACE}:${label}`);
+  return sha256(input).slice(0, TOKEN_METADATA_DISCRIMINATOR_LENGTH);
+}
+function writeU32LE({
+  data,
+  offset,
+  value
+}) {
+  data[offset] = value & 255;
+  data[offset + 1] = value >>> 8 & 255;
+  data[offset + 2] = value >>> 16 & 255;
+  data[offset + 3] = value >>> 24 & 255;
+}
+function encodeLengthPrefixedString(value) {
+  const bytes = new TextEncoder().encode(value);
+  const buffer = new Uint8Array(4 + bytes.length);
+  writeU32LE({ data: buffer, offset: 0, value: bytes.length });
+  buffer.set(bytes, 4);
+  return buffer;
+}
+function encodeAdditionalMetadata(additionalMetadata) {
+  const entries = additionalMetadata.flatMap(([key, value]) => [
+    encodeLengthPrefixedString(key),
+    encodeLengthPrefixedString(value)
+  ]);
+  const totalLength = 4 + entries.reduce((sum, entry) => sum + entry.length, 0);
+  const buffer = new Uint8Array(totalLength);
+  writeU32LE({ data: buffer, offset: 0, value: additionalMetadata.length });
+  let offset = 4;
+  for (const entry of entries) {
+    buffer.set(entry, offset);
+    offset += entry.length;
+  }
+  return buffer;
+}
+function getTokenMetadataDataSize({
+  name,
+  symbol,
+  uri,
+  additionalMetadata = []
+}) {
+  return 32 + 32 + encodeLengthPrefixedString(name).length + encodeLengthPrefixedString(symbol).length + encodeLengthPrefixedString(uri).length + encodeAdditionalMetadata(additionalMetadata).length;
+}
+function initializeTokenMetadataInstruction({
+  mint,
+  updateAuthority,
+  mintAuthority,
+  name,
+  symbol,
+  uri,
+  additionalMetadata = [],
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const nameBytes = encodeLengthPrefixedString(name);
+  const symbolBytes = encodeLengthPrefixedString(symbol);
+  const uriBytes = encodeLengthPrefixedString(uri);
+  const hasAdditionalMetadata = additionalMetadata.length > 0;
+  const additionalBytes = hasAdditionalMetadata ? encodeAdditionalMetadata(additionalMetadata) : null;
+  const dataLength = TOKEN_METADATA_DISCRIMINATOR_LENGTH + nameBytes.length + symbolBytes.length + uriBytes.length + (additionalBytes?.length ?? 0);
+  const data = new Uint8Array(dataLength);
+  data.set(metadataDiscriminator("initialize_account"), 0);
+  let offset = TOKEN_METADATA_DISCRIMINATOR_LENGTH;
+  data.set(nameBytes, offset);
+  offset += nameBytes.length;
+  data.set(symbolBytes, offset);
+  offset += symbolBytes.length;
+  data.set(uriBytes, offset);
+  if (additionalBytes) {
+    offset += uriBytes.length;
+    data.set(additionalBytes, offset);
   }
+  return {
+    programId,
+    accounts: [
+      { pubkey: mint, isSigner: false, isWritable: true },
+      { pubkey: updateAuthority, isSigner: false, isWritable: false },
+      { pubkey: mint, isSigner: false, isWritable: false },
+      { pubkey: mintAuthority, isSigner: true, isWritable: false }
+    ],
+    data
+  };
+}
+
+// src/helpers/size.ts
+var TLV_HEADER_SIZE = TLV_TYPE_SIZE + TLV_LENGTH_SIZE;
+var ACCOUNT_TYPE_SIZE = 1;
+var EXTENSION_SIZES = {
+  [1 /* TransferFeeConfig */]: 108,
+  [2 /* TransferFeeAmount */]: 8,
+  [3 /* MintCloseAuthority */]: 32,
+  [4 /* ConfidentialTransferMint */]: 97,
+  [5 /* ConfidentialTransferAccount */]: 286,
+  [6 /* DefaultAccountState */]: 1,
+  [7 /* ImmutableOwner */]: 0,
+  [8 /* MemoTransfer */]: 1,
+  [9 /* NonTransferable */]: 0,
+  [10 /* InterestBearingConfig */]: 52,
+  [11 /* CpiGuard */]: 1,
+  [12 /* PermanentDelegate */]: 32,
+  [13 /* NonTransferableAccount */]: 0,
+  [14 /* TransferHook */]: 64,
+  [15 /* TransferHookAccount */]: 1,
+  [16 /* ConfidentialTransferFeeConfig */]: 64,
+  [17 /* ConfidentialTransferFeeAmount */]: 32,
+  [18 /* MetadataPointer */]: 64,
+  // TokenMetadata is variable-sized, must use getMetadataExtensionSize
+  [20 /* GroupPointer */]: 64,
+  [21 /* TokenGroup */]: 72,
+  [22 /* GroupMemberPointer */]: 64,
+  [23 /* TokenGroupMember */]: 68
 };
+function getMintSizeWithExtensions({
+  extensions,
+  metadataSize
+}) {
+  if (extensions.length === 0) {
+    return MINT_SIZE;
+  }
+  let totalSize = TOKEN_ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE;
+  for (const extension of extensions) {
+    if (extension === 19 /* TokenMetadata */) {
+      if (metadataSize === void 0) {
+        throw new Error(
+          "metadataSize is required when ExtensionType.TokenMetadata is included. Use getMetadataExtensionSize() to calculate it."
+        );
+      }
+      totalSize += TLV_HEADER_SIZE + metadataSize;
+    } else {
+      const extSize = EXTENSION_SIZES[extension];
+      if (extSize === void 0) {
+        throw new Error(`Unknown extension type: ${extension}`);
+      }
+      totalSize += TLV_HEADER_SIZE + extSize;
+    }
+  }
+  return totalSize;
+}
+function getMetadataExtensionSize({
+  name,
+  symbol,
+  uri,
+  additionalMetadata = []
+}) {
+  return getTokenMetadataDataSize({ name, symbol, uri, additionalMetadata });
+}
+async function getMinRentForMint(client, options) {
+  const size = getMintSizeWithExtensions(options);
+  return await client.getMinimumBalanceForRentExemption(BigInt(size));
+}
+function getMintSizeWithMetadata({
+  name,
+  symbol,
+  uri,
+  additionalMetadata = []
+}) {
+  const metadataSize = getMetadataExtensionSize({ name, symbol, uri, additionalMetadata });
+  return getMintSizeWithExtensions({
+    extensions: [18 /* MetadataPointer */, 19 /* TokenMetadata */],
+    metadataSize
+  });
+}
+async function getMinRentForMintWithMetadata(client, metadata) {
+  const size = getMintSizeWithMetadata(metadata);
+  return await client.getMinimumBalanceForRentExemption(BigInt(size));
+}
 function createAssociatedTokenAccountInstruction({
   payer,
   associatedToken,
@@ -283,7 +627,7 @@ function createAssociatedTokenAccountIdempotentInstruction({
   };
 }
 
-// src/test-helpers.ts
+// src/utils/bytes.ts
 function writeU64LE({
   data,
   offset,
@@ -293,8 +637,96 @@ function writeU64LE({
     data[offset + i] = Number(value >> BigInt(i * 8) & 0xffn);
   }
 }
+function writeU16LE({
+  data,
+  offset,
+  value
+}) {
+  data[offset] = value & 255;
+  data[offset + 1] = value >> 8 & 255;
+}
+
+// src/instructions/utils.ts
+function isAuthoritySigner({ signers }) {
+  return (signers?.length ?? 0) === 0;
+}
+function writeOptionalNonZeroPubkey({
+  data,
+  offset,
+  value
+}) {
+  if (value) {
+    data.set(value.toBytes(), offset);
+  }
+}
+function writeCOptionPubkey({
+  data,
+  offset,
+  value
+}) {
+  if (value) {
+    data[offset] = 1;
+    data.set(value.toBytes(), offset + 1);
+    return 33;
+  }
+  data[offset] = 0;
+  return 1;
+}
+function appendSigners({
+  accounts,
+  signers
+}) {
+  for (const signer of signers ?? []) {
+    accounts.push({ pubkey: signer, isSigner: true, isWritable: false });
+  }
+}
 
-// src/instructions/mint.ts
+// src/instructions/metadata-pointer.ts
+var METADATA_POINTER_INSTRUCTION_INITIALIZE = 0;
+var METADATA_POINTER_INSTRUCTION_UPDATE = 1;
+function initializeMetadataPointerInstruction({
+  mint,
+  authority,
+  metadataAddress,
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const data = new Uint8Array(66);
+  data[0] = 39 /* MetadataPointerExtension */;
+  data[1] = METADATA_POINTER_INSTRUCTION_INITIALIZE;
+  writeOptionalNonZeroPubkey({ data, offset: 2, value: authority ?? null });
+  writeOptionalNonZeroPubkey({
+    data,
+    offset: 34,
+    value: metadataAddress ?? null
+  });
+  return {
+    programId,
+    accounts: [{ pubkey: mint, isSigner: false, isWritable: true }],
+    data
+  };
+}
+function updateMetadataPointerInstruction({
+  mint,
+  authority,
+  metadataAddress,
+  signers,
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const data = new Uint8Array(34);
+  data[0] = 39 /* MetadataPointerExtension */;
+  data[1] = METADATA_POINTER_INSTRUCTION_UPDATE;
+  writeOptionalNonZeroPubkey({
+    data,
+    offset: 2,
+    value: metadataAddress ?? null
+  });
+  const accounts = [
+    { pubkey: mint, isSigner: false, isWritable: true },
+    { pubkey: authority, isSigner: isAuthoritySigner({ signers }), isWritable: false }
+  ];
+  appendSigners({ accounts, signers });
+  return { programId, accounts, data };
+}
 function initializeMintInstruction({
   mint,
   decimals,
@@ -330,29 +762,43 @@ function mintToInstruction({
   destination,
   authority,
   amount,
+  signers,
   programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
 }) {
   const data = new Uint8Array(9);
   data[0] = 7 /* MintTo */;
   writeU64LE({ data, offset: 1, value: amount });
+  const accounts = [
+    { pubkey: mint, isSigner: false, isWritable: true },
+    { pubkey: destination, isSigner: false, isWritable: true },
+    { pubkey: authority, isSigner: isAuthoritySigner({ signers }), isWritable: false }
+  ];
+  appendSigners({ accounts, signers });
+  return { programId, accounts, data };
+}
+function initializeNonTransferableMintInstruction({
+  mint,
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
   return {
     programId,
-    accounts: [
-      { pubkey: mint, isSigner: false, isWritable: true },
-      { pubkey: destination, isSigner: false, isWritable: true },
-      { pubkey: authority, isSigner: true, isWritable: false }
-    ],
-    data
+    accounts: [{ pubkey: mint, isSigner: false, isWritable: true }],
+    data: new Uint8Array([32 /* InitializeNonTransferableMint */])
   };
 }
-function writeU64LE2({
-  data,
-  offset,
-  value
+function initializePermanentDelegateInstruction({
+  mint,
+  delegate,
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
 }) {
-  for (let i = 0; i < 8; i++) {
-    data[offset + i] = Number(value >> BigInt(i * 8) & 0xffn);
-  }
+  const data = new Uint8Array(33);
+  data[0] = 35 /* InitializePermanentDelegate */;
+  data.set(delegate.toBytes(), 1);
+  return {
+    programId,
+    accounts: [{ pubkey: mint, isSigner: false, isWritable: true }],
+    data
+  };
 }
 function transferCheckedInstruction({
   source,
@@ -361,359 +807,289 @@ function transferCheckedInstruction({
   authority,
   amount,
   decimals,
+  signers,
   programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
 }) {
   const data = new Uint8Array(10);
   data[0] = 12 /* TransferChecked */;
-  writeU64LE2({ data, offset: 1, value: amount });
+  writeU64LE({ 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
-  };
+  const accounts = [
+    { pubkey: source, isSigner: false, isWritable: true },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: destination, isSigner: false, isWritable: true },
+    { pubkey: authority, isSigner: isAuthoritySigner({ signers }), isWritable: false }
+  ];
+  appendSigners({ accounts, signers });
+  return { programId, accounts, data };
 }
 function transferInstruction({
   source,
   destination,
   authority,
   amount,
+  signers,
   programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
 }) {
   const data = new Uint8Array(9);
   data[0] = 3 /* Transfer */;
-  writeU64LE2({ data, offset: 1, value: amount });
+  writeU64LE({ data, offset: 1, value: amount });
+  const accounts = [
+    { pubkey: source, isSigner: false, isWritable: true },
+    { pubkey: destination, isSigner: false, isWritable: true },
+    { pubkey: authority, isSigner: isAuthoritySigner({ signers }), isWritable: false }
+  ];
+  appendSigners({ accounts, signers });
+  return { programId, accounts, data };
+}
+var TRANSFER_FEE_INSTRUCTION_INITIALIZE_CONFIG = 0;
+var TRANSFER_FEE_INSTRUCTION_TRANSFER_CHECKED_WITH_FEE = 1;
+var TRANSFER_FEE_INSTRUCTION_SET_TRANSFER_FEE = 5;
+function initializeTransferFeeConfigInstruction({
+  mint,
+  transferFeeConfigAuthority,
+  withdrawWithheldAuthority,
+  transferFeeBasisPoints,
+  maximumFee,
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const authorityLength = transferFeeConfigAuthority ? 33 : 1;
+  const withdrawLength = withdrawWithheldAuthority ? 33 : 1;
+  const data = new Uint8Array(2 + authorityLength + withdrawLength + 2 + 8);
+  data[0] = 26 /* TransferFeeExtension */;
+  data[1] = TRANSFER_FEE_INSTRUCTION_INITIALIZE_CONFIG;
+  let offset = 2;
+  offset += writeCOptionPubkey({
+    data,
+    offset,
+    value: transferFeeConfigAuthority ?? null
+  });
+  offset += writeCOptionPubkey({
+    data,
+    offset,
+    value: withdrawWithheldAuthority ?? null
+  });
+  writeU16LE({ data, offset, value: transferFeeBasisPoints });
+  offset += 2;
+  writeU64LE({ data, offset, value: maximumFee });
   return {
     programId,
-    accounts: [
-      { pubkey: source, isSigner: false, isWritable: true },
-      { pubkey: destination, isSigner: false, isWritable: true },
-      { pubkey: authority, isSigner: true, isWritable: false }
-    ],
+    accounts: [{ pubkey: mint, isSigner: false, isWritable: true }],
     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 transferCheckedWithFeeInstruction({
+  source,
+  mint,
+  destination,
+  authority,
+  amount,
+  decimals,
+  fee,
+  signers,
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const data = new Uint8Array(2 + 8 + 1 + 8);
+  data[0] = 26 /* TransferFeeExtension */;
+  data[1] = TRANSFER_FEE_INSTRUCTION_TRANSFER_CHECKED_WITH_FEE;
+  writeU64LE({ data, offset: 2, value: amount });
+  data[10] = decimals;
+  writeU64LE({ data, offset: 11, value: fee });
+  const accounts = [
+    { pubkey: source, isSigner: false, isWritable: true },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: destination, isSigner: false, isWritable: true },
+    { pubkey: authority, isSigner: isAuthoritySigner({ signers }), isWritable: false }
+  ];
+  appendSigners({ accounts, signers });
+  return { programId, accounts, data };
 }
-function rotr(word, shift) {
-  return word << 32 - shift | word >>> shift;
+function setTransferFeeInstruction({
+  mint,
+  authority,
+  transferFeeBasisPoints,
+  maximumFee,
+  signers,
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const data = new Uint8Array(2 + 2 + 8);
+  data[0] = 26 /* TransferFeeExtension */;
+  data[1] = TRANSFER_FEE_INSTRUCTION_SET_TRANSFER_FEE;
+  writeU16LE({ data, offset: 2, value: transferFeeBasisPoints });
+  writeU64LE({ data, offset: 4, value: maximumFee });
+  const accounts = [
+    { pubkey: mint, isSigner: false, isWritable: true },
+    { pubkey: authority, isSigner: isAuthoritySigner({ signers }), isWritable: false }
+  ];
+  appendSigners({ accounts, signers });
+  return { programId, accounts, data };
 }
-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 TRANSFER_HOOK_INSTRUCTION_INITIALIZE = 0;
+function initializeTransferHookInstruction({
+  mint,
+  authority,
+  hookProgramId,
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const data = new Uint8Array(66);
+  data[0] = 36 /* TransferHookExtension */;
+  data[1] = TRANSFER_HOOK_INSTRUCTION_INITIALIZE;
+  data.set(authority.toBytes(), 2);
+  data.set(hookProgramId.toBytes(), 34);
+  return {
+    programId,
+    accounts: [{ pubkey: mint, isSigner: false, isWritable: true }],
+    data
+  };
 }
-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;
+// 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);
     }
-    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;
+  /**
+   * 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}`
+    });
   }
-  _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;
+  /**
+   * 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}`
+    });
   }
-  clone() {
-    return this._cloneInto();
+  /**
+   * 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 }
+    });
   }
-};
-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);
+  /**
+   * 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 }
+    });
   }
-  get() {
-    const { A, B, C, D, E, F, G, H } = this;
-    return [A, B, C, D, E, F, G, H];
+  /**
+   * 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 }
+    });
   }
-  // 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;
+  /**
+   * 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() }
+    });
   }
-  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);
+  /**
+   * 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}`
+    });
   }
-  roundClean() {
-    clean(SHA256_W);
+  /**
+   * 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}`
+    });
   }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    clean(this.buffer);
+  /**
+   * 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}`
+    });
   }
-};
-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);
+  /**
+   * 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 }
+    });
   }
 };
-var sha256 = /* @__PURE__ */ createHasher(
-  () => new _SHA256(),
-  /* @__PURE__ */ oidNist(1)
-);
+
+// src/pda/ata.ts
 function createProgramAddress({
   seeds,
   programId
@@ -745,29 +1121,418 @@ function createProgramAddress({
       };
     }
   }
-  return null;
-}
-function findAssociatedTokenAddress({
-  wallet,
-  mint,
-  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
-}) {
-  const associatedTokenProgramId = tsCdk.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;
+  return null;
+}
+function findAssociatedTokenAddress({
+  wallet,
+  mint,
+  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  const associatedTokenProgramId = tsCdk.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 = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
+}) {
+  return findAssociatedTokenAddress({ wallet, mint, programId }).address;
+}
+
+// src/builders/mint-builder.ts
+var MintBuilder = class _MintBuilder {
+  client;
+  programId;
+  // Default of 9 matches SOL and most major Solana tokens (e.g. USDC uses 6, native SOL uses 9).
+  // SPL Token-2022 stores decimals as a u8, so the valid range is 0–255.
+  decimals = 9;
+  mintAuthority = null;
+  freezeAuthority = null;
+  metadata = null;
+  transferFee = null;
+  nonTransferable = false;
+  permanentDelegate = null;
+  transferHook = null;
+  initialSupply = null;
+  constructor(tokenClient, client) {
+    this.client = client;
+    this.programId = tokenClient.getProgramId();
+  }
+  /**
+   * Creates a new MintBuilder instance.
+   *
+   * @param tokenClient - SplTokenClient instance
+   * @returns A new MintBuilder
+   *
+   * @example
+   * ```typescript
+   * const builder = MintBuilder.create(tokenClient);
+   * ```
+   */
+  static create(tokenClient) {
+    return new _MintBuilder(tokenClient, tokenClient.getRialoClient());
+  }
+  /**
+   * Sets the number of decimals for the token.
+   *
+   * SPL Token-2022 stores decimals as a u8, so values from 0 to 255 are
+   * valid at the protocol level. Common choices are 6 (USDC-style) or 9
+   * (SOL-style). Values above 9 are uncommon on Solana but fully supported.
+   *
+   * @param decimals - Number of decimals (0-255)
+   * @returns this for chaining
+   */
+  withDecimals(decimals) {
+    if (decimals < 0 || decimals > 255) {
+      throw new Error("Decimals must be between 0 and 255");
+    }
+    this.decimals = decimals;
+    return this;
+  }
+  /**
+   * Sets the mint authority.
+   *
+   * @param authority - Public key of the mint authority
+   * @returns this for chaining
+   */
+  withMintAuthority(authority) {
+    this.mintAuthority = authority;
+    return this;
+  }
+  /**
+   * Sets the freeze authority.
+   *
+   * @param authority - Public key of the freeze authority
+   * @returns this for chaining
+   */
+  withFreezeAuthority(authority) {
+    this.freezeAuthority = authority;
+    return this;
+  }
+  /**
+   * Configures token metadata extension.
+   *
+   * This enables both MetadataPointer and TokenMetadata extensions,
+   * with the metadata stored directly on the mint account.
+   *
+   * @param metadata - Token metadata configuration
+   * @returns this for chaining
+   */
+  withMetadata(metadata) {
+    this.metadata = metadata;
+    return this;
+  }
+  /**
+   * Configures transfer fee extension.
+   *
+   * @param config - Transfer fee configuration
+   * @returns this for chaining
+   */
+  withTransferFee(config) {
+    if (this.nonTransferable) {
+      throw new Error("Cannot add transfer fee to non-transferable mint");
+    }
+    this.transferFee = config;
+    return this;
+  }
+  /**
+   * Makes the mint non-transferable.
+   *
+   * Non-transferable tokens (soulbound tokens) cannot be transferred
+   * after minting.
+   *
+   * @returns this for chaining
+   */
+  withNonTransferable() {
+    if (this.transferFee) {
+      throw new Error(
+        "Cannot make mint non-transferable when transfer fee is configured"
+      );
+    }
+    this.nonTransferable = true;
+    return this;
+  }
+  /**
+   * Configures permanent delegate extension.
+   *
+   * A permanent delegate has unrestricted transfer and burn authority
+   * over all token accounts for this mint.
+   *
+   * @param delegate - Public key of the permanent delegate
+   * @returns this for chaining
+   */
+  withPermanentDelegate(delegate) {
+    this.permanentDelegate = delegate;
+    return this;
+  }
+  /**
+   * Configures transfer hook extension.
+   *
+   * A transfer hook invokes a specified program on every token transfer,
+   * enabling custom transfer logic (e.g., compliance checks, royalties).
+   *
+   * @param config - Transfer hook configuration
+   * @returns this for chaining
+   */
+  withTransferHook(config) {
+    this.transferHook = config;
+    return this;
+  }
+  /**
+   * Configures initial token supply to mint after creation.
+   *
+   * The tokens will be minted to an Associated Token Account (ATA)
+   * derived from the destination wallet.
+   *
+   * @param config - Initial supply configuration
+   * @returns this for chaining
+   */
+  withInitialSupply(config) {
+    this.initialSupply = config;
+    return this;
+  }
+  /**
+   * Builds the mint transaction without sending.
+   *
+   * @param options - Build options
+   * @returns Build result with transaction and addresses
+   *
+   * @example
+   * ```typescript
+   * const { transaction, mintAddress } = await builder.build({
+   *   payer: authority,
+   *   mintKeypair,
+   *   validFrom: BigInt(Date.now()),
+   * });
+   *
+   * // Sign manually
+   * const signed = transaction.sign(authorityKeypair).sign(mintKeypair);
+   * await client.sendAndConfirmTransaction(signed.serialize());
+   * ```
+   */
+  async build(options) {
+    const { payer, mintKeypair, validFrom } = options;
+    const mintAddress = mintKeypair.publicKey;
+    if (!this.mintAuthority) {
+      throw new Error(
+        "Mint authority is required. Call withMintAuthority() first."
+      );
+    }
+    const extensions = this.getExtensions();
+    const createAccountExtensions = extensions.filter(
+      (ext) => ext !== 19 /* TokenMetadata */
+    );
+    const createAccountSize = getMintSizeWithExtensions({
+      extensions: createAccountExtensions,
+      metadataSize: void 0
+    });
+    let rentSize = createAccountSize;
+    if (this.metadata) {
+      const metadataSize = getMetadataExtensionSize({
+        name: this.metadata.name,
+        symbol: this.metadata.symbol,
+        uri: this.metadata.uri,
+        additionalMetadata: this.metadata.additionalMetadata
+      });
+      rentSize = getMintSizeWithExtensions({
+        extensions,
+        metadataSize
+      });
+    }
+    const rent = await this.client.getMinimumBalanceForRentExemption(
+      BigInt(rentSize)
+    );
+    const instructions = [];
+    instructions.push(
+      tsCdk.createAccount(
+        payer,
+        mintAddress,
+        rent,
+        BigInt(createAccountSize),
+        this.programId
+      )
+    );
+    if (this.metadata) {
+      instructions.push(
+        initializeMetadataPointerInstruction({
+          mint: mintAddress,
+          authority: this.mintAuthority,
+          metadataAddress: mintAddress,
+          // Self-referential for on-mint metadata
+          programId: this.programId
+        })
+      );
+    }
+    if (this.transferFee) {
+      instructions.push(
+        initializeTransferFeeConfigInstruction({
+          mint: mintAddress,
+          transferFeeConfigAuthority: this.transferFee.transferFeeConfigAuthority,
+          withdrawWithheldAuthority: this.transferFee.withdrawWithheldAuthority,
+          transferFeeBasisPoints: this.transferFee.transferFeeBasisPoints,
+          maximumFee: this.transferFee.maximumFee,
+          programId: this.programId
+        })
+      );
+    }
+    if (this.nonTransferable) {
+      instructions.push(
+        initializeNonTransferableMintInstruction({
+          mint: mintAddress,
+          programId: this.programId
+        })
+      );
+    }
+    if (this.permanentDelegate) {
+      instructions.push(
+        initializePermanentDelegateInstruction({
+          mint: mintAddress,
+          delegate: this.permanentDelegate,
+          programId: this.programId
+        })
+      );
+    }
+    if (this.transferHook) {
+      instructions.push(
+        initializeTransferHookInstruction({
+          mint: mintAddress,
+          authority: this.transferHook.authority,
+          hookProgramId: this.transferHook.programId,
+          programId: this.programId
+        })
+      );
+    }
+    instructions.push(
+      initializeMintInstruction({
+        mint: mintAddress,
+        decimals: this.decimals,
+        mintAuthority: this.mintAuthority,
+        freezeAuthority: this.freezeAuthority ?? void 0,
+        programId: this.programId
+      })
+    );
+    if (this.metadata) {
+      instructions.push(
+        initializeTokenMetadataInstruction({
+          mint: mintAddress,
+          updateAuthority: this.mintAuthority,
+          mintAuthority: this.mintAuthority,
+          name: this.metadata.name,
+          symbol: this.metadata.symbol,
+          uri: this.metadata.uri,
+          additionalMetadata: this.metadata.additionalMetadata,
+          programId: this.programId
+        })
+      );
+    }
+    let ataAddress;
+    if (this.initialSupply) {
+      ataAddress = getAssociatedTokenAddressSync({
+        wallet: this.initialSupply.destination,
+        mint: mintAddress,
+        programId: this.programId
+      });
+      instructions.push(
+        createAssociatedTokenAccountIdempotentInstruction({
+          payer,
+          associatedToken: ataAddress,
+          owner: this.initialSupply.destination,
+          mint: mintAddress,
+          programId: this.programId
+        })
+      );
+      instructions.push(
+        mintToInstruction({
+          mint: mintAddress,
+          destination: ataAddress,
+          authority: this.mintAuthority,
+          amount: this.initialSupply.amount,
+          programId: this.programId
+        })
+      );
+    }
+    const configHashPrefix = await this.client.getConfigHashPrefix();
+    const builder = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).setConfigHashPrefix(configHashPrefix);
+    for (const instruction of instructions) {
+      builder.addInstruction(instruction);
+    }
+    return {
+      transaction: builder.build(),
+      mintAddress,
+      ataAddress
+    };
+  }
+  /**
+   * Builds, signs, and sends the mint transaction.
+   *
+   * @param options - Send options including signers
+   * @returns Send result with signature and addresses
+   *
+   * @example
+   * ```typescript
+   * const { signature, mintAddress } = await builder.send({
+   *   payer: authority,
+   *   mintKeypair,
+   *   validFrom: BigInt(Date.now()),
+   *   signers: [authorityKeypair, mintKeypair],
+   * });
+   * ```
+   */
+  async send(options) {
+    const { signers, ...buildOptions } = options;
+    if (signers.length === 0) {
+      throw new Error("At least one signer is required");
+    }
+    const { transaction, mintAddress, ataAddress } = await this.build(buildOptions);
+    let signedTx = transaction;
+    for (const signer of signers) {
+      signedTx = signedTx.sign(signer);
+    }
+    const result = await this.client.sendAndConfirmTransaction(
+      signedTx.serialize()
+    );
+    return {
+      signature: result.signature,
+      mintAddress,
+      ataAddress
+    };
+  }
+  /**
+   * Returns the list of extensions that will be enabled.
+   */
+  getExtensions() {
+    const extensions = [];
+    if (this.metadata) {
+      extensions.push(18 /* MetadataPointer */);
+      extensions.push(19 /* TokenMetadata */);
+    }
+    if (this.transferFee) {
+      extensions.push(1 /* TransferFeeConfig */);
+    }
+    if (this.nonTransferable) {
+      extensions.push(9 /* NonTransferable */);
+    }
+    if (this.permanentDelegate) {
+      extensions.push(12 /* PermanentDelegate */);
+    }
+    if (this.transferHook) {
+      extensions.push(14 /* TransferHook */);
+    }
+    return extensions;
+  }
+};
+function readU16LE({ data, offset }) {
+  return data[offset] | data[offset + 1] << 8;
 }
-function getAssociatedTokenAddressSync({
-  wallet,
-  mint,
-  programId = tsCdk.PublicKey.fromString(TOKEN_2022_PROGRAM_ID)
-}) {
-  return findAssociatedTokenAddress({ wallet, mint, programId }).address;
+function readU32LE({ data, offset }) {
+  return (data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24) >>> 0;
 }
 function readU64LE({ data, offset }) {
   let value = 0n;
@@ -776,13 +1541,15 @@ function readU64LE({ data, offset }) {
   }
   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
 }) {
+  if (data.length < offset + 4 + PUBKEY_SIZE) {
+    throw SplTokenError.invalidExtension({
+      reason: `COption<Pubkey> out of bounds: need ${offset + 4 + PUBKEY_SIZE} bytes, got ${data.length}`
+    });
+  }
   const tag = readU32LE({ data, offset });
   if (tag === COPTION_SOME) {
     const pubkeyBytes = data.slice(offset + 4, offset + 4 + PUBKEY_SIZE);
@@ -790,122 +1557,192 @@ function readCOptionPubkey({
   }
   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}`
+function readOptionalNonZeroPubkey({
+  data,
+  offset
+}) {
+  const pubkeyBytes = data.slice(offset, offset + PUBKEY_SIZE);
+  const isZero = pubkeyBytes.every((byte) => byte === 0);
+  return isZero ? null : tsCdk.PublicKey.fromBytes(pubkeyBytes);
+}
+function readPubkey({ data, offset }) {
+  return tsCdk.PublicKey.fromBytes(data.slice(offset, offset + PUBKEY_SIZE));
+}
+
+// src/state/extensions.ts
+function parseTlvExtensions({
+  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 /* Uninitialized */ && 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;
   }
-  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 extensions;
+}
+function getMintExtensions({ data }) {
+  if (data.length <= TOKEN_ACCOUNT_SIZE) {
+    return [];
+  }
+  const accountType = data[TOKEN_ACCOUNT_SIZE];
+  if (accountType !== 1 /* Mint */) {
+    return [];
   }
+  return parseTlvExtensions({ data, extensionsOffset: MINT_EXTENSIONS_OFFSET });
+}
+function getTokenAccountExtensions({ data }) {
+  if (data.length <= TOKEN_ACCOUNT_SIZE) {
+    return [];
+  }
+  const accountType = data[TOKEN_ACCOUNT_SIZE];
+  if (accountType !== 2 /* Account */) {
+    return [];
+  }
+  return parseTlvExtensions({
+    data,
+    extensionsOffset: TOKEN_ACCOUNT_EXTENSIONS_OFFSET
+  });
+}
+
+// src/state/extension-parsers.ts
+var TRANSFER_FEE_CONFIG_SIZE = 108;
+var TRANSFER_FEE_AMOUNT_SIZE = 8;
+var METADATA_POINTER_SIZE = 64;
+var PUBKEY_SIZE2 = 32;
+var PERMANENT_DELEGATE_SIZE = 32;
+var TRANSFER_HOOK_SIZE = 64;
+var TOKEN_METADATA_MAX_SIZE = 65535;
+function parseTransferFee({ data, offset }) {
+  const epoch = readU64LE({ data, offset });
+  const maximumFee = readU64LE({ data, offset: offset + 8 });
+  const transferFeeBasisPoints = readU16LE({ data, offset: offset + 16 });
   return {
-    address,
-    supply,
-    decimals,
-    isInitialized,
-    mintAuthority,
-    freezeAuthority
+    epoch,
+    maximumFee,
+    transferFeeBasisPoints
   };
 }
-function readU64LE2({ data, offset }) {
-  let value = 0n;
-  for (let i = 0; i < 8; i++) {
-    value |= BigInt(data[offset + i]) << BigInt(i * 8);
+function parseTransferFeeConfigExtension({
+  data
+}) {
+  if (data.length < TRANSFER_FEE_CONFIG_SIZE) {
+    throw SplTokenError.invalidExtension({
+      reason: `TransferFeeConfig too short: expected ${TRANSFER_FEE_CONFIG_SIZE} bytes, got ${data.length}`
+    });
   }
-  return value;
-}
-function readU32LE2({ data, offset }) {
-  return (data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24) >>> 0;
+  const transferFeeConfigAuthority = readOptionalNonZeroPubkey({
+    data,
+    offset: 0
+  });
+  const withdrawWithheldAuthority = readOptionalNonZeroPubkey({
+    data,
+    offset: 32
+  });
+  const withheldAmount = readU64LE({ data, offset: 64 });
+  const olderTransferFee = parseTransferFee({ data, offset: 72 });
+  const newerTransferFee = parseTransferFee({ data, offset: 90 });
+  return {
+    transferFeeConfigAuthority,
+    withdrawWithheldAuthority,
+    withheldAmount,
+    olderTransferFee,
+    newerTransferFee
+  };
 }
-function readCOptionPubkey2({
-  data,
-  offset
+function parseTransferFeeAmountExtension({
+  data
 }) {
-  const tag = readU32LE2({ data, offset });
-  if (tag === COPTION_SOME) {
-    const pubkeyBytes = data.slice(offset + 4, offset + 4 + PUBKEY_SIZE);
-    return tsCdk.PublicKey.fromBytes(pubkeyBytes);
+  if (data.length < TRANSFER_FEE_AMOUNT_SIZE) {
+    throw SplTokenError.invalidExtension({
+      reason: `TransferFeeAmount too short: expected ${TRANSFER_FEE_AMOUNT_SIZE} bytes, got ${data.length}`
+    });
   }
-  return null;
+  return {
+    withheldAmount: readU64LE({ data, offset: 0 })
+  };
 }
-function readCOptionU64({ data, offset }) {
-  const tag = readU32LE2({ data, offset });
-  if (tag === COPTION_SOME) {
-    return readU64LE2({ data, offset: offset + 4 });
+function parseNonTransferableExtension({
+  data
+}) {
+  if (data.length !== 0) {
+    throw SplTokenError.invalidExtension({
+      reason: `NonTransferable has unexpected length: expected 0 bytes, got ${data.length}`
+    });
   }
-  return null;
+  return { isNonTransferable: true };
 }
-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}`
+function parseNonTransferableAccountExtension({
+  data
+}) {
+  if (data.length !== 0) {
+    throw SplTokenError.invalidExtension({
+      reason: `NonTransferableAccount has unexpected length: expected 0 bytes, got ${data.length}`
     });
   }
-  const mintBytes = data.slice(TOKEN_ACCOUNT_MINT_OFFSET, TOKEN_ACCOUNT_MINT_OFFSET + PUBKEY_SIZE);
-  const mint = tsCdk.PublicKey.fromBytes(mintBytes);
-  const ownerBytes = data.slice(
-    TOKEN_ACCOUNT_OWNER_OFFSET,
-    TOKEN_ACCOUNT_OWNER_OFFSET + PUBKEY_SIZE
-  );
-  const owner = tsCdk.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}` });
+  return { isNonTransferableAccount: true };
+}
+function parsePermanentDelegateExtension({
+  data
+}) {
+  if (data.length < PERMANENT_DELEGATE_SIZE) {
+    throw SplTokenError.invalidExtension({
+      reason: `PermanentDelegate too short: expected ${PERMANENT_DELEGATE_SIZE} bytes, got ${data.length}`
+    });
   }
-  const state = stateValue;
-  if (state === 0 /* Uninitialized */) {
-    throw SplTokenError.accountNotInitialized({ address: address.toString() });
+  return { delegate: readOptionalNonZeroPubkey({ data, offset: 0 }) };
+}
+function parseTransferHookExtension({ data }) {
+  if (data.length < TRANSFER_HOOK_SIZE) {
+    throw SplTokenError.invalidExtension({
+      reason: `TransferHook too short: expected ${TRANSFER_HOOK_SIZE} bytes, got ${data.length}`
+    });
   }
-  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
+    authority: readOptionalNonZeroPubkey({ data, offset: 0 }),
+    programId: readOptionalNonZeroPubkey({ data, offset: 32 })
   };
 }
-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
+function parseMetadataPointerExtensionData({
+  data
 }) {
-  const tag = readU32LE3({ data, offset });
-  if (tag === COPTION_SOME) {
-    const pubkeyBytes = data.slice(offset + 4, offset + 4 + PUBKEY_SIZE);
-    return tsCdk.PublicKey.fromBytes(pubkeyBytes);
+  if (data.length < METADATA_POINTER_SIZE) {
+    throw SplTokenError.invalidExtension({
+      reason: `MetadataPointer too short: expected ${METADATA_POINTER_SIZE} bytes, got ${data.length}`
+    });
   }
-  return null;
+  const authority = readOptionalNonZeroPubkey({ data, offset: 0 });
+  const metadataAddress = readOptionalNonZeroPubkey({ data, offset: 32 });
+  return { authority, metadataAddress };
 }
 function readLengthPrefixedString({
   data,
   offset
 }) {
   if (offset + 4 > data.length) {
-    throw SplTokenError.invalidMetadata({ reason: "String length prefix extends beyond data" });
+    throw SplTokenError.invalidExtension({
+      reason: "String length prefix extends beyond data"
+    });
   }
-  const length = readU32LE3({ data, offset });
+  const length = readU32LE({ data, offset });
   if (offset + 4 + length > data.length) {
-    throw SplTokenError.invalidMetadata({
+    throw SplTokenError.invalidExtension({
       reason: `String data extends beyond buffer: need ${length} bytes at offset ${offset + 4}`
     });
   }
@@ -913,47 +1750,140 @@ function readLengthPrefixedString({
   try {
     const str = new TextDecoder().decode(stringBytes);
     return [str, 4 + length];
-  } catch (error) {
-    throw SplTokenError.invalidMetadata({
+  } catch {
+    throw SplTokenError.invalidExtension({
       reason: `Invalid UTF-8 string at offset ${offset}`
     });
   }
 }
-function parseExtensions({
+function parseTokenMetadataExtensionData({ data }) {
+  if (data.length < 64) {
+    throw SplTokenError.invalidExtension({
+      reason: `TokenMetadata too short: expected at least 64 bytes, got ${data.length}`
+    });
+  }
+  if (data.length > TOKEN_METADATA_MAX_SIZE) {
+    throw SplTokenError.invalidExtension({
+      reason: `TokenMetadata too large: maximum ${TOKEN_METADATA_MAX_SIZE} bytes, got ${data.length}`
+    });
+  }
+  let offset = 0;
+  const updateAuthority = readOptionalNonZeroPubkey({ data, offset });
+  offset += PUBKEY_SIZE2;
+  const mint = readPubkey({ data, offset });
+  offset += PUBKEY_SIZE2;
+  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 = readU32LE({ 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 parseExtension({ extension }) {
+  switch (extension.type) {
+    case 1 /* TransferFeeConfig */:
+      return {
+        type: 1 /* TransferFeeConfig */,
+        value: parseTransferFeeConfigExtension({ data: extension.data })
+      };
+    case 2 /* TransferFeeAmount */:
+      return {
+        type: 2 /* TransferFeeAmount */,
+        value: parseTransferFeeAmountExtension({ data: extension.data })
+      };
+    case 9 /* NonTransferable */:
+      return {
+        type: 9 /* NonTransferable */,
+        value: parseNonTransferableExtension({ data: extension.data })
+      };
+    case 13 /* NonTransferableAccount */:
+      return {
+        type: 13 /* NonTransferableAccount */,
+        value: parseNonTransferableAccountExtension({ data: extension.data })
+      };
+    case 18 /* MetadataPointer */:
+      return {
+        type: 18 /* MetadataPointer */,
+        value: parseMetadataPointerExtensionData({ data: extension.data })
+      };
+    case 19 /* TokenMetadata */:
+      return {
+        type: 19 /* TokenMetadata */,
+        value: parseTokenMetadataExtensionData({ data: extension.data })
+      };
+    case 12 /* PermanentDelegate */:
+      return {
+        type: 12 /* PermanentDelegate */,
+        value: parsePermanentDelegateExtension({ data: extension.data })
+      };
+    case 14 /* TransferHook */:
+      return {
+        type: 14 /* TransferHook */,
+        value: parseTransferHookExtension({ data: extension.data })
+      };
+    default:
+      return null;
+  }
+}
+function getMintExtensionStates({ data }) {
+  return getMintExtensions({ data }).map((extension) => parseExtension({ extension })).filter((extension) => extension !== null);
+}
+function getTokenAccountExtensionStates({ data }) {
+  return getTokenAccountExtensions({ data }).map((extension) => parseExtension({ extension })).filter((extension) => extension !== null);
+}
+function readLengthPrefixedString2({
   data,
-  extensionsOffset
+  offset
 }) {
-  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)
+  if (offset + 4 > data.length) {
+    throw SplTokenError.invalidMetadata({
+      reason: "String length prefix extends beyond data"
+    });
+  }
+  const length = readU32LE({ 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 {
+    throw SplTokenError.invalidMetadata({
+      reason: `Invalid UTF-8 string at offset ${offset}`
     });
-    offset = dataEnd;
   }
-  return extensions;
 }
 function parseMetadataPointer({ data }) {
-  if (data.length < 72) {
+  if (data.length < 64) {
     throw SplTokenError.invalidExtension({
-      reason: `MetadataPointer too short: expected 72 bytes, got ${data.length}`
+      reason: `MetadataPointer too short: expected 64 bytes, got ${data.length}`
     });
   }
-  const authority = readCOptionPubkey3({ data, offset: 0 });
-  const metadataAddress = readCOptionPubkey3({ data, offset: 36 });
+  const authority = readOptionalNonZeroPubkey({ data, offset: 0 });
+  const metadataAddress = readOptionalNonZeroPubkey({ data, offset: 32 });
   return { authority, metadataAddress };
 }
 function parseTokenMetadataExtension({
@@ -971,20 +1901,20 @@ function parseTokenMetadataExtension({
   const updateAuthority = isZeroAuthority ? null : tsCdk.PublicKey.fromBytes(updateAuthorityBytes);
   offset += PUBKEY_SIZE;
   offset += PUBKEY_SIZE;
-  const [name, nameLen] = readLengthPrefixedString({ data, offset });
+  const [name, nameLen] = readLengthPrefixedString2({ data, offset });
   offset += nameLen;
-  const [symbol, symbolLen] = readLengthPrefixedString({ data, offset });
+  const [symbol, symbolLen] = readLengthPrefixedString2({ data, offset });
   offset += symbolLen;
-  const [uri, uriLen] = readLengthPrefixedString({ data, offset });
+  const [uri, uriLen] = readLengthPrefixedString2({ data, offset });
   offset += uriLen;
   const additionalMetadata = [];
   if (offset + 4 <= data.length) {
-    const numEntries = readU32LE3({ data, offset });
+    const numEntries = readU32LE({ data, offset });
     offset += 4;
     for (let i = 0; i < numEntries && offset < data.length; i++) {
-      const [key, keyLen] = readLengthPrefixedString({ data, offset });
+      const [key, keyLen] = readLengthPrefixedString2({ data, offset });
       offset += keyLen;
-      const [value, valueLen] = readLengthPrefixedString({ data, offset });
+      const [value, valueLen] = readLengthPrefixedString2({ data, offset });
       offset += valueLen;
       additionalMetadata.push([key, value]);
     }
@@ -1002,14 +1932,17 @@ function parseTokenMetadata({
   mint,
   data
 }) {
-  if (data.length <= MINT_SIZE) {
+  if (data.length <= TOKEN_ACCOUNT_SIZE) {
     return null;
   }
-  const accountType = data[MINT_SIZE];
+  const accountType = data[TOKEN_ACCOUNT_SIZE];
   if (accountType !== 1 /* Mint */) {
     return null;
   }
-  const extensions = parseExtensions({ data, extensionsOffset: MINT_EXTENSIONS_OFFSET });
+  const extensions = parseTlvExtensions({
+    data,
+    extensionsOffset: MINT_EXTENSIONS_OFFSET
+  });
   const metadataExt = extensions.find((ext) => ext.type === 19 /* TokenMetadata */);
   if (!metadataExt) {
     return null;
@@ -1019,29 +1952,321 @@ function parseTokenMetadata({
 function parseMetadataPointerExtension({
   data
 }) {
-  if (data.length <= MINT_SIZE) {
+  if (data.length <= TOKEN_ACCOUNT_SIZE) {
     return null;
   }
-  const accountType = data[MINT_SIZE];
+  const accountType = data[TOKEN_ACCOUNT_SIZE];
   if (accountType !== 1 /* Mint */) {
     return null;
   }
-  const extensions = parseExtensions({ data, extensionsOffset: MINT_EXTENSIONS_OFFSET });
+  const extensions = parseTlvExtensions({
+    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) {
+
+// src/state/mint.ts
+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
+  };
+}
+
+// src/state/token-account.ts
+function readCOptionU64({ data, offset }) {
+  const tag = readU32LE({ data, offset });
+  if (tag === COPTION_SOME) {
+    return readU64LE({ 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 mint = readPubkey({ data, offset: TOKEN_ACCOUNT_MINT_OFFSET });
+  const owner = readPubkey({ data, offset: TOKEN_ACCOUNT_OWNER_OFFSET });
+  const amount = readU64LE({ data, offset: TOKEN_ACCOUNT_AMOUNT_OFFSET });
+  const delegate = readCOptionPubkey({
+    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 = readU64LE({
+    data,
+    offset: TOKEN_ACCOUNT_DELEGATED_AMOUNT_OFFSET
+  });
+  const closeAuthority = readCOptionPubkey({
+    data,
+    offset: TOKEN_ACCOUNT_CLOSE_AUTHORITY_OFFSET
+  });
+  return {
+    address,
+    mint,
+    owner,
+    amount,
+    delegate,
+    state,
+    isNative,
+    delegatedAmount,
+    closeAuthority
+  };
+}
+
+// src/transfer-hook/extra-account-meta.ts
+var EXTRA_ACCOUNT_META_SIZE = 35;
+function parseExtraAccountMeta(data, offset) {
+  return {
+    discriminator: data[offset],
+    addressConfig: data.slice(offset + 1, offset + 33),
+    isSigner: data[offset + 33] !== 0,
+    isWritable: data[offset + 34] !== 0
+  };
+}
+var EXECUTE_DISCRIMINATOR = sha256(
+  new TextEncoder().encode("rialo-s-spl-transfer-hook-interface:execute")
+).slice(0, 8);
+var TLV_HEADER_SIZE2 = 16;
+function parseExtraAccountMetaList(data) {
+  if (data.length < TLV_HEADER_SIZE2) {
     return [];
   }
-  const accountType = data[MINT_SIZE];
-  if (accountType !== 1 /* Mint */) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const count = view.getUint32(12, true);
+  if (count === 0) {
     return [];
   }
-  return parseExtensions({ data, extensionsOffset: MINT_EXTENSIONS_OFFSET });
+  const entries = [];
+  let cursor = TLV_HEADER_SIZE2;
+  for (let i = 0; i < count; i++) {
+    if (cursor + EXTRA_ACCOUNT_META_SIZE > data.length) {
+      break;
+    }
+    entries.push(parseExtraAccountMeta(data, cursor));
+    cursor += EXTRA_ACCOUNT_META_SIZE;
+  }
+  return entries;
+}
+function buildExecuteInstructionData(amount) {
+  const data = new Uint8Array(16);
+  data.set(EXECUTE_DISCRIMINATOR, 0);
+  writeU64LE({ data, offset: 8, value: amount });
+  return data;
+}
+function getExtraAccountMetaAddress(mint, hookProgramId) {
+  const [pda] = tsCdk.PublicKey.findProgramAddress(
+    ["extra-account-metas", mint.toBytes()],
+    hookProgramId
+  );
+  return pda;
+}
+
+// src/transfer-hook/seeds.ts
+async function unpackSeeds(params) {
+  const { addressConfig, previousMetas, instructionData, fetchAccountData } = params;
+  const seeds = [];
+  let cursor = 0;
+  if (addressConfig.length < 32) {
+    throw SplTokenError.pdaDerivationFailed({
+      reason: `addressConfig must be at least 32 bytes, got ${addressConfig.length}`
+    });
+  }
+  while (cursor < 32) {
+    const discriminator = addressConfig[cursor];
+    if (discriminator === 0) {
+      break;
+    }
+    cursor++;
+    switch (discriminator) {
+      case 1: {
+        const length = addressConfig[cursor++];
+        seeds.push(addressConfig.slice(cursor, cursor + length));
+        cursor += length;
+        break;
+      }
+      case 2: {
+        const offset = addressConfig[cursor++];
+        const length = addressConfig[cursor++];
+        seeds.push(instructionData.slice(offset, offset + length));
+        break;
+      }
+      case 3: {
+        const index = addressConfig[cursor++];
+        seeds.push(previousMetas[index].pubkey.toBytes());
+        break;
+      }
+      case 4: {
+        const accountIndex = addressConfig[cursor++];
+        const dataOffset = addressConfig[cursor++];
+        const length = addressConfig[cursor++];
+        const data = await fetchAccountData(previousMetas[accountIndex].pubkey);
+        if (data) {
+          seeds.push(data.slice(dataOffset, dataOffset + length));
+        }
+        break;
+      }
+      default: {
+        throw SplTokenError.pdaDerivationFailed({
+          reason: `Unknown seed discriminator ${discriminator} at addressConfig offset ${cursor - 1}`
+        });
+      }
+    }
+  }
+  return seeds;
+}
+
+// src/transfer-hook/resolve-extra-accounts.ts
+async function resolveExtraAccountMeta(params) {
+  const { meta, previousMetas, instructionData, hookProgramId, fetchAccountData } = params;
+  if (meta.discriminator === 0) {
+    return {
+      pubkey: tsCdk.PublicKey.fromBytes(meta.addressConfig),
+      isSigner: meta.isSigner,
+      isWritable: meta.isWritable
+    };
+  }
+  if (meta.discriminator === 1) {
+    const seeds2 = await unpackSeeds({
+      addressConfig: meta.addressConfig,
+      previousMetas,
+      instructionData,
+      fetchAccountData
+    });
+    const [pda2] = tsCdk.PublicKey.findProgramAddress(seeds2, hookProgramId);
+    return {
+      pubkey: pda2,
+      isSigner: meta.isSigner,
+      isWritable: meta.isWritable
+    };
+  }
+  if (meta.discriminator === 2) {
+    const accountIndex2 = meta.addressConfig[0];
+    const dataOffset = meta.addressConfig[1];
+    const data = await fetchAccountData(previousMetas[accountIndex2].pubkey);
+    if (!data) {
+      throw SplTokenError.pdaDerivationFailed({
+        reason: `Failed to fetch account data for discriminator 2 resolution: account at index ${accountIndex2} returned no data`
+      });
+    }
+    if (data.length < dataOffset + 32) {
+      throw SplTokenError.pdaDerivationFailed({
+        reason: `Account data too short for discriminator 2 resolution: expected at least ${dataOffset + 32} bytes at offset ${dataOffset}, but data is only ${data.length} bytes`
+      });
+    }
+    const extracted = data.slice(dataOffset, dataOffset + 32);
+    return {
+      pubkey: tsCdk.PublicKey.fromBytes(extracted),
+      isSigner: meta.isSigner,
+      isWritable: meta.isWritable
+    };
+  }
+  const accountIndex = meta.discriminator - 128;
+  if (accountIndex >= previousMetas.length) {
+    throw SplTokenError.pdaDerivationFailed({
+      reason: `External PDA resolution failed: accountIndex ${accountIndex} (discriminator ${meta.discriminator}) is out of bounds for previousMetas of length ${previousMetas.length}`
+    });
+  }
+  const programId = previousMetas[accountIndex].pubkey;
+  const seeds = await unpackSeeds({
+    addressConfig: meta.addressConfig,
+    previousMetas,
+    instructionData,
+    fetchAccountData
+  });
+  const [pda] = tsCdk.PublicKey.findProgramAddress(seeds, programId);
+  return {
+    pubkey: pda,
+    isSigner: meta.isSigner,
+    isWritable: meta.isWritable
+  };
+}
+async function resolveTransferHookExtraAccounts(params) {
+  const { mint, hookProgramId, sourceAta, destinationAta, authority, amount, fetchAccountData } = params;
+  const validationPda = getExtraAccountMetaAddress(mint, hookProgramId);
+  const validationData = await fetchAccountData(validationPda);
+  if (!validationData) {
+    return [
+      { pubkey: hookProgramId, isSigner: false, isWritable: false },
+      { pubkey: validationPda, isSigner: false, isWritable: false }
+    ];
+  }
+  const extraMetas = parseExtraAccountMetaList(validationData);
+  if (extraMetas.length === 0) {
+    return [
+      { pubkey: hookProgramId, isSigner: false, isWritable: false },
+      { pubkey: validationPda, isSigner: false, isWritable: false }
+    ];
+  }
+  const instructionData = buildExecuteInstructionData(amount);
+  const baseMetas = [
+    { pubkey: sourceAta, isSigner: false, isWritable: true },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: destinationAta, isSigner: false, isWritable: true },
+    { pubkey: authority, isSigner: false, isWritable: false },
+    { pubkey: validationPda, isSigner: false, isWritable: false }
+  ];
+  const resolvedExtras = [];
+  for (const meta of extraMetas) {
+    const previousMetas = [...baseMetas, ...resolvedExtras];
+    const resolved = await resolveExtraAccountMeta({
+      meta,
+      previousMetas,
+      instructionData,
+      hookProgramId,
+      fetchAccountData
+    });
+    resolvedExtras.push(resolved);
+  }
+  const deEscalated = resolvedExtras.map((account) => ({
+    ...account,
+    isSigner: false
+  }));
+  return [
+    ...deEscalated,
+    { pubkey: hookProgramId, isSigner: false, isWritable: false },
+    { pubkey: validationPda, isSigner: false, isWritable: false }
+  ];
 }
 
 // src/client/spl-token-client.ts
@@ -1071,11 +2296,20 @@ var SplTokenClient = class {
     this.programId = programId;
   }
   /**
-   * Gets the token program ID this client is configured to use.
+   * Returns the Token-2022 program ID used by this client.
    */
   getProgramId() {
     return this.programId;
   }
+  /**
+   * Returns the underlying RialoClient.
+   *
+   * Useful for advanced operations that need direct RPC access,
+   * such as MintBuilder which needs to calculate rent.
+   */
+  getRialoClient() {
+    return this.client;
+  }
   /**
    * Retrieves mint account information.
    *
@@ -1085,10 +2319,8 @@ var SplTokenClient = class {
    *
    * @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'}`);
+   * const mintInfo = await tokenClient.getMintInfo({ mint });
+   * console.log(mintInfo.decimals);
    * ```
    */
   async getMintInfo({ mint }) {
@@ -1096,7 +2328,10 @@ var SplTokenClient = class {
     if (!accountInfo) {
       throw SplTokenError.mintNotFound({ address: mint.toString() });
     }
-    return parseMintAccount({ address: mint, data: decodeAccountData(accountInfo.data) });
+    return parseMintAccount({
+      address: mint,
+      data: decodeAccountData(accountInfo.data)
+    });
   }
   /**
    * Retrieves Token-2022 native metadata from a mint.
@@ -1107,20 +2342,52 @@ var SplTokenClient = class {
    *
    * @example
    * ```typescript
-   * const metadata = await tokenClient.getTokenMetadata({ mint: mintPubkey });
+   * const metadata = await tokenClient.getTokenMetadata({ mint });
    * if (metadata) {
-   *   console.log(`Name: ${metadata.name}`);
-   *   console.log(`Symbol: ${metadata.symbol}`);
-   *   console.log(`URI: ${metadata.uri}`);
+   *   console.log(metadata.name, metadata.symbol);
    * }
    * ```
    */
-  async getTokenMetadata({ mint }) {
+  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 complete mint account data in a single RPC call.
+   *
+   * Returns parsed mint info, token metadata, and raw extensions from one
+   * `getAccountInfo` call, avoiding the redundant RPC calls that occur when
+   * calling `getMintInfo()` and `getTokenMetadata()` separately.
+   *
+   * Raw extensions include ALL extension types (including PermanentDelegate,
+   * TransferHook, etc.) unlike `getMintExtensionStates()` which only parses
+   * a subset.
+   *
+   * @param options - Options containing the mint public key
+   * @returns Combined mint info, metadata, and raw extensions
+   * @throws {SplTokenError} If the mint account doesn't exist
+   */
+  async getMintAccountData({
+    mint
+  }) {
     const accountInfo = await this.client.getAccountInfo(mint);
     if (!accountInfo) {
       throw SplTokenError.mintNotFound({ address: mint.toString() });
     }
-    return parseTokenMetadata({ mint, data: decodeAccountData(accountInfo.data) });
+    const data = decodeAccountData(accountInfo.data);
+    return {
+      mintInfo: parseMintAccount({ address: mint, data }),
+      metadata: parseTokenMetadata({ mint, data }),
+      rawExtensions: getMintExtensions({ data })
+    };
   }
   /**
    * Retrieves token account information.
@@ -1134,9 +2401,14 @@ var SplTokenClient = class {
   }) {
     const accountInfo = await this.client.getAccountInfo(tokenAccount);
     if (!accountInfo) {
-      throw SplTokenError.tokenAccountNotFound({ address: tokenAccount.toString() });
+      throw SplTokenError.tokenAccountNotFound({
+        address: tokenAccount.toString()
+      });
     }
-    return parseTokenAccount({ address: tokenAccount, data: decodeAccountData(accountInfo.data) });
+    return parseTokenAccount({
+      address: tokenAccount,
+      data: decodeAccountData(accountInfo.data)
+    });
   }
   /**
    * Gets the token balance for a wallet.
@@ -1153,13 +2425,23 @@ var SplTokenClient = class {
    * console.log(`Token balance: ${balance}`);
    * ```
    */
-  async getBalance({ wallet, mint }) {
-    const ata = getAssociatedTokenAddressSync({ wallet, mint, programId: this.programId });
+  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) });
+    const tokenAccount = parseTokenAccount({
+      address: ata,
+      data: decodeAccountData(accountInfo.data)
+    });
     return tokenAccount.amount;
   }
   /**
@@ -1167,6 +2449,7 @@ var SplTokenClient = class {
    *
    * @param options - Options containing wallet and mint public keys
    * @returns The derived ATA address and bump seed
+   * @throws {SplTokenError} If the ATA derivation fails
    *
    * @example
    * ```typescript
@@ -1178,7 +2461,11 @@ var SplTokenClient = class {
     wallet,
     mint
   }) {
-    return findAssociatedTokenAddress({ wallet, mint, programId: this.programId });
+    return findAssociatedTokenAddress({
+      wallet,
+      mint,
+      programId: this.programId
+    });
   }
   /**
    * Checks if an Associated Token Account exists.
@@ -1186,20 +2473,26 @@ var SplTokenClient = class {
    * @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 });
+  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,
+   * 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
@@ -1214,7 +2507,14 @@ var SplTokenClient = class {
    * ```
    */
   async createTransferInstructions(params) {
-    const { source, destination, mint, amount, decimals, createDestinationAta = true } = params;
+    const {
+      source,
+      destination,
+      mint,
+      amount,
+      decimals,
+      createDestinationAta = true
+    } = params;
     const instructions = [];
     const sourceAta = getAssociatedTokenAddressSync({
       wallet: source,
@@ -1227,35 +2527,63 @@ var SplTokenClient = class {
       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(
+        createAssociatedTokenAccountIdempotentInstruction({
+          payer: source,
+          associatedToken: destinationAta,
+          owner: destination,
+          mint,
+          programId: this.programId
+        })
+      );
     }
-    instructions.push(
-      transferCheckedInstruction({
-        source: sourceAta,
+    if (params.transferFee) {
+      instructions.push(
+        transferCheckedWithFeeInstruction({
+          source: sourceAta,
+          mint,
+          destination: destinationAta,
+          authority: source,
+          amount,
+          decimals,
+          fee: params.transferFee.fee,
+          programId: this.programId
+        })
+      );
+    } else {
+      instructions.push(
+        transferCheckedInstruction({
+          source: sourceAta,
+          mint,
+          destination: destinationAta,
+          authority: source,
+          amount,
+          decimals,
+          programId: this.programId
+        })
+      );
+    }
+    if (params.transferHook) {
+      const { hookProgramId } = params.transferHook;
+      const transferIx = instructions[instructions.length - 1];
+      const extraAccounts = await resolveTransferHookExtraAccounts({
         mint,
-        destination: destinationAta,
+        hookProgramId,
+        sourceAta,
+        destinationAta,
         authority: source,
         amount,
-        decimals,
-        programId: this.programId
-      })
-    );
+        fetchAccountData: async (pubkey) => {
+          const info = await this.client.getAccountInfo(pubkey);
+          return info ? decodeAccountData(info.data) : null;
+        }
+      });
+      for (const account of extraAccounts) {
+        transferIx.accounts.push(account);
+      }
+    }
     return instructions;
   }
-  /**
-   * Options for creating a transfer transaction.
-   */
   /**
    * Creates a transaction for a token transfer.
    *
@@ -1288,18 +2616,19 @@ var SplTokenClient = class {
    */
   async createTransferTransaction({
     params,
+    payer,
     validFrom,
     configHashPrefix
   }) {
     const instructions = await this.createTransferInstructions(params);
-    const builder = tsCdk.TransactionBuilder.create().setPayer(params.source).setValidFrom(validFrom).setConfigHashPrefix(configHashPrefix);
-    for (const ix of instructions) {
-      builder.addInstruction(ix);
+    const builder = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).setConfigHashPrefix(configHashPrefix);
+    for (const instruction of instructions) {
+      builder.addInstruction(instruction);
     }
     return builder.build();
   }
   /**
-   * Transfers tokens from one wallet to another.
+   * Transfers tokens and sends the transaction.
    *
    * This is a high-level convenience method that:
    * 1. Creates the destination ATA if needed
@@ -1307,7 +2636,7 @@ var SplTokenClient = class {
    * 3. Signs and sends the transaction
    * 4. Waits for confirmation
    *
-   * @param options - Options containing params, validFrom, and signer
+   * @param options - Transfer params, payer, validFrom, and signers
    * @returns Transaction signature
    *
    * @example
@@ -1331,21 +2660,209 @@ var SplTokenClient = class {
    */
   async transfer({
     params,
+    payer,
     validFrom,
     configHashPrefix,
-    signer
+    signers
+  }) {
+    const tx = await this.createTransferTransaction({
+      params,
+      payer,
+      validFrom,
+      configHashPrefix
+    });
+    return this.signAndSend({ tx, signers });
+  }
+  /**
+   * Initializes a mint and sends the transaction.
+   *
+   * @param options - Initialize mint params, payer, validFrom, and signers
+   * @returns Transaction signature
+   */
+  initializeMint({
+    params,
+    payer,
+    validFrom,
+    signers
+  }) {
+    const instruction = initializeMintInstruction({
+      ...params,
+      programId: this.programId
+    });
+    const tx = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).addInstruction(instruction).build();
+    return this.signAndSend({ tx, signers });
+  }
+  /**
+   * Mints tokens and sends the transaction.
+   *
+   * @param options - Mint-to params, payer, validFrom, and signers
+   * @returns Transaction signature
+   */
+  mintTo({
+    params,
+    payer,
+    validFrom,
+    signers
+  }) {
+    const instruction = mintToInstruction({
+      ...params,
+      programId: this.programId
+    });
+    const tx = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).addInstruction(instruction).build();
+    return this.signAndSend({ tx, signers });
+  }
+  /**
+   * Initializes token metadata on a mint.
+   *
+   * Use this for the on-mint TokenMetadata extension flow.
+   *
+   * @param options - Token metadata params, payer, validFrom, and signers
+   * @returns Transaction signature
+   */
+  initializeTokenMetadata({
+    params,
+    payer,
+    validFrom,
+    signers
+  }) {
+    const instruction = initializeTokenMetadataInstruction({
+      ...params,
+      programId: params.programId ?? this.programId
+    });
+    const tx = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).addInstruction(instruction).build();
+    return this.signAndSend({ tx, signers });
+  }
+  /**
+   * Initializes a metadata pointer extension on a mint.
+   *
+   * Use this for the Metadata Pointer flow, where metadata lives in
+   * a separate account and the mint stores a pointer to it.
+   *
+   * @param options - Metadata pointer params, payer, validFrom, and signers
+   * @returns Transaction signature
+   */
+  initializeMetadataPointer({
+    params,
+    payer,
+    validFrom,
+    signers
+  }) {
+    const instruction = initializeMetadataPointerInstruction({
+      ...params,
+      programId: this.programId
+    });
+    const tx = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).addInstruction(instruction).build();
+    return this.signAndSend({ tx, signers });
+  }
+  /**
+   * Updates a metadata pointer extension on a mint.
+   *
+   * @param options - Metadata pointer params, payer, validFrom, and signers
+   * @returns Transaction signature
+   */
+  updateMetadataPointer({
+    params,
+    payer,
+    validFrom,
+    signers
+  }) {
+    const instruction = updateMetadataPointerInstruction({
+      ...params,
+      programId: this.programId
+    });
+    const tx = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).addInstruction(instruction).build();
+    return this.signAndSend({ tx, signers });
+  }
+  /**
+   * Initializes a transfer fee config on a mint.
+   *
+   * @param options - Transfer fee config params, payer, validFrom, and signers
+   * @returns Transaction signature
+   */
+  initializeTransferFeeConfig({
+    params,
+    payer,
+    validFrom,
+    signers
+  }) {
+    const instruction = initializeTransferFeeConfigInstruction({
+      ...params,
+      programId: this.programId
+    });
+    const tx = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).addInstruction(instruction).build();
+    return this.signAndSend({ tx, signers });
+  }
+  /**
+   * Transfers tokens with a fee and sends the transaction.
+   *
+   * @param options - Transfer params, payer, validFrom, and signers
+   * @returns Transaction signature
+   */
+  transferCheckedWithFee({
+    params,
+    payer,
+    validFrom,
+    signers
+  }) {
+    const instruction = transferCheckedWithFeeInstruction({
+      ...params,
+      programId: this.programId
+    });
+    const tx = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).addInstruction(instruction).build();
+    return this.signAndSend({ tx, signers });
+  }
+  /**
+   * Initializes a non-transferable mint.
+   *
+   * @param options - Non-transferable mint params, payer, validFrom, and signers
+   * @returns Transaction signature
+   */
+  initializeNonTransferableMint({
+    params,
+    payer,
+    validFrom,
+    signers
+  }) {
+    const instruction = initializeNonTransferableMintInstruction({
+      ...params,
+      programId: this.programId
+    });
+    const tx = tsCdk.TransactionBuilder.create().setPayer(payer).setValidFrom(validFrom).addInstruction(instruction).build();
+    return this.signAndSend({ tx, signers });
+  }
+  async signAndSend({
+    tx,
+    signers
   }) {
-    const tx = await this.createTransferTransaction({ params, validFrom, configHashPrefix });
-    const signedTx = await tx.signWith(signer);
-    const result = await this.client.sendAndConfirmTransaction(signedTx.serialize());
+    if (signers.length === 0) {
+      throw new Error("At least one signer required.");
+    }
+    const signedTx = await tx.signAllWith(signers);
+    const result = await this.client.sendAndConfirmTransaction(
+      signedTx.serialize()
+    );
     return result.signature;
   }
 };
-function createSplTokenClient({
-  client,
-  programId
-}) {
-  return new SplTokenClient({ client, programId });
+function createSplTokenClient(options) {
+  return new SplTokenClient(options);
+}
+
+// src/recipes/create-token-with-metadata.ts
+async function createTokenWithMetadata(tokenClient, params, options) {
+  const builder = MintBuilder.create(tokenClient).withDecimals(params.decimals).withMintAuthority(params.mintAuthority).withMetadata(params.metadata);
+  if (params.freezeAuthority) {
+    builder.withFreezeAuthority(params.freezeAuthority);
+  }
+  if (params.initialMint) {
+    builder.withInitialSupply(params.initialMint);
+  }
+  return await builder.send({
+    payer: options.payer,
+    mintKeypair: options.mintKeypair,
+    validFrom: options.validFrom,
+    signers: options.signers
+  });
 }
 /*! Bundled license information:
 
@@ -1355,29 +2872,65 @@ function createSplTokenClient({
 
 exports.ASSOCIATED_TOKEN_PROGRAM_ID = ASSOCIATED_TOKEN_PROGRAM_ID;
 exports.AccountType = AccountType;
+exports.EXECUTE_DISCRIMINATOR = EXECUTE_DISCRIMINATOR;
+exports.EXTRA_ACCOUNT_META_SIZE = EXTRA_ACCOUNT_META_SIZE;
 exports.ExtensionType = ExtensionType;
 exports.MINT_SIZE = MINT_SIZE;
+exports.MintBuilder = MintBuilder;
 exports.SplTokenClient = SplTokenClient;
 exports.SplTokenError = SplTokenError;
 exports.SplTokenErrorCode = SplTokenErrorCode;
+exports.TLV_LENGTH_SIZE = TLV_LENGTH_SIZE;
+exports.TLV_TYPE_SIZE = TLV_TYPE_SIZE;
 exports.TOKEN_2022_PROGRAM_ID = TOKEN_2022_PROGRAM_ID;
 exports.TOKEN_ACCOUNT_SIZE = TOKEN_ACCOUNT_SIZE;
 exports.TOKEN_PROGRAM_ID = TOKEN_PROGRAM_ID;
 exports.TokenAccountState = TokenAccountState;
 exports.TokenInstruction = TokenInstruction;
+exports.buildExecuteInstructionData = buildExecuteInstructionData;
 exports.createAssociatedTokenAccountIdempotentInstruction = createAssociatedTokenAccountIdempotentInstruction;
 exports.createAssociatedTokenAccountInstruction = createAssociatedTokenAccountInstruction;
 exports.createSplTokenClient = createSplTokenClient;
+exports.createTokenWithMetadata = createTokenWithMetadata;
 exports.findAssociatedTokenAddress = findAssociatedTokenAddress;
 exports.getAssociatedTokenAddressSync = getAssociatedTokenAddressSync;
+exports.getExtraAccountMetaAddress = getExtraAccountMetaAddress;
+exports.getMetadataExtensionSize = getMetadataExtensionSize;
+exports.getMinRentForMint = getMinRentForMint;
+exports.getMinRentForMintWithMetadata = getMinRentForMintWithMetadata;
+exports.getMintExtensionStates = getMintExtensionStates;
 exports.getMintExtensions = getMintExtensions;
+exports.getMintSizeWithExtensions = getMintSizeWithExtensions;
+exports.getMintSizeWithMetadata = getMintSizeWithMetadata;
+exports.getTokenAccountExtensionStates = getTokenAccountExtensionStates;
+exports.getTokenAccountExtensions = getTokenAccountExtensions;
+exports.getTokenMetadataDataSize = getTokenMetadataDataSize;
+exports.initializeMetadataPointerInstruction = initializeMetadataPointerInstruction;
 exports.initializeMintInstruction = initializeMintInstruction;
+exports.initializeNonTransferableMintInstruction = initializeNonTransferableMintInstruction;
+exports.initializePermanentDelegateInstruction = initializePermanentDelegateInstruction;
+exports.initializeTokenMetadataInstruction = initializeTokenMetadataInstruction;
+exports.initializeTransferFeeConfigInstruction = initializeTransferFeeConfigInstruction;
+exports.initializeTransferHookInstruction = initializeTransferHookInstruction;
 exports.mintToInstruction = mintToInstruction;
+exports.parseExtension = parseExtension;
+exports.parseExtraAccountMetaList = parseExtraAccountMetaList;
 exports.parseMetadataPointerExtension = parseMetadataPointerExtension;
+exports.parseMetadataPointerExtensionData = parseMetadataPointerExtensionData;
 exports.parseMintAccount = parseMintAccount;
+exports.parsePermanentDelegateExtension = parsePermanentDelegateExtension;
 exports.parseTokenAccount = parseTokenAccount;
 exports.parseTokenMetadata = parseTokenMetadata;
+exports.parseTokenMetadataExtensionData = parseTokenMetadataExtensionData;
+exports.parseTransferFeeConfigExtension = parseTransferFeeConfigExtension;
+exports.parseTransferHookExtension = parseTransferHookExtension;
+exports.resolveExtraAccountMeta = resolveExtraAccountMeta;
+exports.resolveTransferHookExtraAccounts = resolveTransferHookExtraAccounts;
+exports.setTransferFeeInstruction = setTransferFeeInstruction;
 exports.transferCheckedInstruction = transferCheckedInstruction;
+exports.transferCheckedWithFeeInstruction = transferCheckedWithFeeInstruction;
 exports.transferInstruction = transferInstruction;
+exports.unpackSeeds = unpackSeeds;
+exports.updateMetadataPointerInstruction = updateMetadataPointerInstruction;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map