@rialo/ts-cdk 0.2.0-alpha.0 → 0.2.0-alpha.1

package/dist/index.mjs

@@ -1,3 +1,6 @@
+import { Chacha20Poly1305 } from '@hpke/chacha20poly1305';
+import { CipherSuite, HkdfSha256, DhkemX25519HkdfSha256 } from '@hpke/core';
+
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -5478,6 +5481,302 @@ var RialoError = class _RialoError extends Error {
   }
 };
 
+// src/rex/errors.ts
+var HpkeErrorCode = /* @__PURE__ */ ((HpkeErrorCode2) => {
+  HpkeErrorCode2["INVALID_KEY_LENGTH"] = "INVALID_KEY_LENGTH";
+  HpkeErrorCode2["CIPHERTEXT_TOO_SHORT"] = "CIPHERTEXT_TOO_SHORT";
+  HpkeErrorCode2["ENCRYPTION_FAILED"] = "ENCRYPTION_FAILED";
+  HpkeErrorCode2["BORSH_DESERIALIZE_FAILED"] = "BORSH_DESERIALIZE_FAILED";
+  HpkeErrorCode2["INVALID_ORACLE_VALUE"] = "INVALID_ORACLE_VALUE";
+  return HpkeErrorCode2;
+})(HpkeErrorCode || {});
+var HpkeError = class _HpkeError extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "HpkeError";
+    this.code = code;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _HpkeError);
+    }
+  }
+  /**
+   * Create an error for invalid key length.
+   *
+   * @param expected - Expected key length in bytes
+   * @param actual - Actual key length in bytes
+   * @param keyType - Description of the key type (e.g., "REX public key")
+   */
+  static invalidKeyLength(expected, actual, keyType) {
+    return new _HpkeError(
+      "INVALID_KEY_LENGTH" /* INVALID_KEY_LENGTH */,
+      `Invalid ${keyType} length: expected ${expected} bytes, got ${actual}`
+    );
+  }
+  /**
+   * Create an error for ciphertext that is too short.
+   *
+   * @param minLength - Minimum required length
+   * @param actual - Actual length
+   */
+  static ciphertextTooShort(minLength, actual) {
+    return new _HpkeError(
+      "CIPHERTEXT_TOO_SHORT" /* CIPHERTEXT_TOO_SHORT */,
+      `Ciphertext too short: minimum ${minLength} bytes required, got ${actual}`
+    );
+  }
+  /**
+   * Create an error for encryption failure.
+   *
+   * @param cause - The underlying error
+   */
+  static encryptionFailed(cause) {
+    return new _HpkeError(
+      "ENCRYPTION_FAILED" /* ENCRYPTION_FAILED */,
+      `HPKE encryption failed: ${cause.message}`,
+      cause
+    );
+  }
+  /**
+   * Create an error for Borsh deserialization failure.
+   *
+   * @param cause - The underlying error
+   */
+  static borshDeserializeFailed(cause) {
+    return new _HpkeError(
+      "BORSH_DESERIALIZE_FAILED" /* BORSH_DESERIALIZE_FAILED */,
+      `Borsh deserialization failed: ${cause.message}`,
+      cause
+    );
+  }
+  /**
+   * Create an error for invalid RexValue variant.
+   *
+   * @param variant - The invalid variant byte
+   */
+  static invalidRexValue(variant) {
+    return new _HpkeError(
+      "INVALID_ORACLE_VALUE" /* INVALID_ORACLE_VALUE */,
+      `Invalid RexValue variant: ${variant}`
+    );
+  }
+};
+
+// src/rex/constants.ts
+var USER_SECRET_AAD = new TextEncoder().encode("rex-secret-v1");
+var SECRET_SHARING_HPKE_INFO = new TextEncoder().encode(
+  "rialo/tee/secret-sharing-hpke/v1"
+);
+var X25519_PUBLIC_KEY_LENGTH = 32;
+var ED25519_PUBLIC_KEY_LENGTH = 32;
+var HPKE_ENC_LENGTH = 32;
+var CHACHA20_POLY1305_TAG_LENGTH = 16;
+var HPKE_OVERHEAD_LENGTH = HPKE_ENC_LENGTH + CHACHA20_POLY1305_TAG_LENGTH;
+
+// src/rex/rex-value.ts
+var RexValueVariant = /* @__PURE__ */ ((RexValueVariant2) => {
+  RexValueVariant2[RexValueVariant2["Plain"] = 0] = "Plain";
+  RexValueVariant2[RexValueVariant2["Encrypted"] = 1] = "Encrypted";
+  return RexValueVariant2;
+})(RexValueVariant || {});
+var RexValue = class _RexValue {
+  variant;
+  data;
+  constructor(variant, data) {
+    this.variant = variant;
+    this.data = data;
+  }
+  /**
+   * Create a plain (unencrypted) RexValue from raw bytes.
+   *
+   * @param data - The raw byte data
+   * @returns A new RexValue with Plain variant
+   */
+  static plain(data) {
+    return new _RexValue(0 /* Plain */, data);
+  }
+  /**
+   * Create a plain (unencrypted) RexValue from a UTF-8 string.
+   *
+   * @param s - The string to encode
+   * @returns A new RexValue with Plain variant
+   */
+  static plainString(s) {
+    return new _RexValue(
+      0 /* Plain */,
+      new TextEncoder().encode(s)
+    );
+  }
+  /**
+   * Create an encrypted RexValue from HPKE ciphertext.
+   *
+   * @param ciphertext - The HPKE-encrypted ciphertext (enc || ct || tag)
+   * @returns A new RexValue with Encrypted variant
+   */
+  static encrypted(ciphertext) {
+    return new _RexValue(1 /* Encrypted */, ciphertext);
+  }
+  /**
+   * Check if this is a plain (unencrypted) value.
+   */
+  isPlain() {
+    return this.variant === 0 /* Plain */;
+  }
+  /**
+   * Check if this is an encrypted value.
+   */
+  isEncrypted() {
+    return this.variant === 1 /* Encrypted */;
+  }
+  /**
+   * Get the variant type.
+   */
+  getVariant() {
+    return this.variant;
+  }
+  /**
+   * Get the raw bytes (plaintext or ciphertext).
+   *
+   * For Plain values, returns the plaintext.
+   * For Encrypted values, returns the ciphertext.
+   */
+  asBytes() {
+    return this.data;
+  }
+  /**
+   * Try to decode the plain value as a UTF-8 string.
+   *
+   * @returns The decoded string, or null if encrypted or not valid UTF-8
+   */
+  asString() {
+    if (!this.isPlain()) {
+      return null;
+    }
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(this.data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Serialize to Borsh format.
+   *
+   * Format: `[variant: u8] [length: u32 LE] [data bytes]`
+   *
+   * @returns The Borsh-serialized bytes
+   */
+  toBorsh() {
+    const result = new Uint8Array(1 + 4 + this.data.length);
+    result[0] = this.variant;
+    const dataView = new DataView(result.buffer);
+    dataView.setUint32(1, this.data.length, true);
+    result.set(this.data, 5);
+    return result;
+  }
+  /**
+   * Deserialize from Borsh format.
+   *
+   * @param data - The Borsh-serialized bytes
+   * @returns A new RexValue
+   * @throws {HpkeError} If deserialization fails
+   */
+  static fromBorsh(data) {
+    if (data.length < 5) {
+      throw HpkeError.borshDeserializeFailed(
+        new Error(`Buffer too short: expected at least 5 bytes, got ${data.length}`)
+      );
+    }
+    const variant = data[0];
+    if (variant !== 0 /* Plain */ && variant !== 1 /* Encrypted */) {
+      throw HpkeError.invalidRexValue(variant);
+    }
+    const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const length = dataView.getUint32(1, true);
+    if (data.length < 5 + length) {
+      throw HpkeError.borshDeserializeFailed(
+        new Error(`Buffer too short: expected ${5 + length} bytes, got ${data.length}`)
+      );
+    }
+    const payload = data.slice(5, 5 + length);
+    return new _RexValue(variant, payload);
+  }
+};
+var hpkeSuite = new CipherSuite({
+  kem: new DhkemX25519HkdfSha256(),
+  kdf: new HkdfSha256(),
+  aead: new Chacha20Poly1305()
+});
+function buildAad(senderPubkey) {
+  const aad = new Uint8Array(USER_SECRET_AAD.length + senderPubkey.length);
+  aad.set(USER_SECRET_AAD, 0);
+  aad.set(senderPubkey, USER_SECRET_AAD.length);
+  return aad;
+}
+async function hpkeEncrypt(rexPubkey, data, senderPubkey) {
+  if (rexPubkey.length !== X25519_PUBLIC_KEY_LENGTH) {
+    throw HpkeError.invalidKeyLength(
+      X25519_PUBLIC_KEY_LENGTH,
+      rexPubkey.length,
+      "REX public key"
+    );
+  }
+  if (senderPubkey.length !== ED25519_PUBLIC_KEY_LENGTH) {
+    throw HpkeError.invalidKeyLength(
+      ED25519_PUBLIC_KEY_LENGTH,
+      senderPubkey.length,
+      "sender public key"
+    );
+  }
+  try {
+    const recipientKey = await hpkeSuite.kem.importKey(
+      "raw",
+      rexPubkey.buffer.slice(
+        rexPubkey.byteOffset,
+        rexPubkey.byteOffset + rexPubkey.byteLength
+      )
+    );
+    const sender = await hpkeSuite.createSenderContext({
+      recipientPublicKey: recipientKey,
+      info: SECRET_SHARING_HPKE_INFO.buffer.slice(
+        SECRET_SHARING_HPKE_INFO.byteOffset,
+        SECRET_SHARING_HPKE_INFO.byteOffset + SECRET_SHARING_HPKE_INFO.byteLength
+      )
+    });
+    const aad = buildAad(senderPubkey);
+    const ciphertext = await sender.seal(
+      data.buffer.slice(
+        data.byteOffset,
+        data.byteOffset + data.byteLength
+      ),
+      aad.buffer.slice(
+        aad.byteOffset,
+        aad.byteOffset + aad.byteLength
+      )
+    );
+    const enc = new Uint8Array(sender.enc);
+    const result = new Uint8Array(enc.length + ciphertext.byteLength);
+    result.set(enc, 0);
+    result.set(new Uint8Array(ciphertext), enc.length);
+    return result;
+  } catch (error) {
+    throw HpkeError.encryptionFailed(
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+}
+async function encryptForRex(rexPubkey, data, senderPubkey) {
+  const ciphertext = await hpkeEncrypt(rexPubkey, data, senderPubkey);
+  return RexValue.encrypted(ciphertext);
+}
+function getCiphertextLength(plaintextLength) {
+  return HPKE_OVERHEAD_LENGTH + plaintextLength;
+}
+function isValidCiphertextLength(ciphertext) {
+  return ciphertext.length >= HPKE_OVERHEAD_LENGTH;
+}
+
 // src/rpc/errors.ts
 var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
   RpcErrorCode2["REQUEST_TIMEOUT"] = "REQUEST_TIMEOUT";
@@ -5736,9 +6035,7 @@ var QueryRpcClient = class extends BaseRpcClient {
    * ```
    */
   async getAccountInfo(pubkey) {
-    const result = await this.call("getAccountInfo", [
-      { address: pubkey.toString(), config: { encoding: "base64" } }
-    ]);
+    const result = await this.call("getAccountInfo", [{ address: pubkey.toString() }]);
     if (!result.value) {
       return null;
     }
@@ -6026,10 +6323,9 @@ var QueryRpcClient = class extends BaseRpcClient {
         owner: owner.toString(),
         filter,
         config: config ? {
-          encoding: config.encoding ?? "base64",
           limit: config.limit,
           after: config.after
-        } : { encoding: "base64" }
+        } : void 0
       }
     ]);
     return {
@@ -6168,6 +6464,64 @@ var QueryRpcClient = class extends BaseRpcClient {
       blockNumber: BigInt(tx.block_number)
     }));
   }
+  /**
+   * Retrieve the REX X25519 public key for secret sharing encryption.
+   *
+   * This key is used for HPKE encryption when sending encrypted data
+   * that should only be decryptable within the REX execution environment.
+   *
+   * @returns The REX X25519 public key as a 32-byte Uint8Array
+   *
+   * @example
+   * ```typescript
+   * import { encryptForRex } from "@rialo/ts-cdk";
+   *
+   * // Get the REX public key
+   * const rexPubkey = await client.getSecretSharingPubkey();
+   *
+   * // Use it for HPKE encryption
+   * const encrypted = await encryptForRex(
+   *   rexPubkey,
+   *   new TextEncoder().encode("secret data"),
+   *   keypair.publicKey.toBytes()
+   * );
+   * ```
+   */
+  async getSecretSharingPubkey() {
+    const result = await this.call(
+      "getSecretSharingPubkey",
+      []
+    );
+    const hexString = result.public_key;
+    const bytes = new Uint8Array(hexString.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Number.parseInt(hexString.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  /**
+   * Get the config hash prefix for replay protection.
+   *
+   * Returns the first 64 bits of the config hash, which is used
+   * for transaction replay protection across chains.
+   *
+   * @returns The config hash prefix as a bigint
+   *
+   * @example
+   * ```typescript
+   * const configHashPrefix = await client.getConfigHashPrefix();
+   * const tx = TransactionBuilder.create()
+   *   .setPayer(payer)
+   *   .setValidFrom(validFrom)
+   *   .setConfigHashPrefix(configHashPrefix)
+   *   .addInstruction(instruction)
+   *   .build();
+   * ```
+   */
+  async getConfigHashPrefix() {
+    const result = await this.call("getRecentValidatorConfigHash", [{}]);
+    return BigInt(result.config_hash_prefix);
+  }
 };
 
 // src/rpc/clients/transaction-client.ts
@@ -6796,189 +7150,219 @@ function getDefaultRialoClientConfig(network) {
   }
 }
 
-// src/signer/keypair-signer.ts
-var KeypairSigner = class {
-  constructor(keypair) {
-    this.keypair = keypair;
+// src/serialization/bincode/reader.ts
+var BincodeReader = class {
+  view;
+  offset;
+  bytes;
+  constructor(data) {
+    this.bytes = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    this.offset = 0;
+  }
+  // ========== Position Management ==========
+  getOffset() {
+    return this.offset;
+  }
+  remaining() {
+    return this.bytes.length - this.offset;
+  }
+  isExhausted() {
+    return this.offset >= this.bytes.length;
+  }
+  skip(bytes) {
+    this.ensureAvailable(bytes);
+    this.offset += bytes;
+    return this;
   }
   /**
-   * Returns the keypair's public key.
+   * Peek at bytes without advancing the offset
    */
-  async getPublicKey() {
-    return this.keypair.publicKey;
+  peek(length) {
+    this.ensureAvailable(length);
+    return this.bytes.slice(this.offset, this.offset + length);
   }
   /**
-   * Signs a message using the keypair's private key.
+   * Reset reader to beginning
    */
-  async signMessage(message) {
-    return this.keypair.sign(message);
+  reset() {
+    this.offset = 0;
+    return this;
   }
-};
-
-// src/transaction/account-meta-table.ts
-var AccountMetaTable = class {
-  accounts = /* @__PURE__ */ new Map();
-  accountOrder = [];
   /**
-   * Add or update an account in the table.
-   * If account already exists, merges signer/writable flags (OR operation).
+   * Seek to specific offset
    */
-  add(meta) {
-    const key = meta.pubkey.toString();
-    if (this.accounts.has(key)) {
-      const existing = this.accounts.get(key);
-      existing.isSigner ||= meta.isSigner;
-      existing.isWritable ||= meta.isWritable;
-    } else {
-      this.accounts.set(key, {
-        pubkey: meta.pubkey,
-        isSigner: meta.isSigner,
-        isWritable: meta.isWritable
-      });
-      this.accountOrder.push(key);
+  seek(offset) {
+    if (offset < 0 || offset > this.bytes.length) {
+      throw new Error(
+        `Invalid seek offset: ${offset}, buffer length: ${this.bytes.length}`
+      );
     }
+    this.offset = offset;
+    return this;
   }
-  /**
-   * Add multiple accounts at once.
-   */
-  addAll(metas) {
-    for (const meta of metas) {
-      this.add(meta);
+  // ========== Primitive Types ==========
+  readU8() {
+    this.ensureAvailable(1);
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readU16() {
+    this.ensureAvailable(2);
+    const value = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+  readU32() {
+    this.ensureAvailable(4);
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readU64() {
+    this.ensureAvailable(8);
+    const low = this.view.getUint32(this.offset, true);
+    const high = this.view.getUint32(this.offset + 4, true);
+    this.offset += 8;
+    return BigInt(low) | BigInt(high) << 32n;
+  }
+  readU128() {
+    this.ensureAvailable(16);
+    const low = this.readU64();
+    const high = this.readU64();
+    return low | high << 64n;
+  }
+  readI8() {
+    this.ensureAvailable(1);
+    const value = this.view.getInt8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readI16() {
+    this.ensureAvailable(2);
+    const value = this.view.getInt16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+  readI32() {
+    this.ensureAvailable(4);
+    const value = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readI64() {
+    this.ensureAvailable(8);
+    const low = this.view.getUint32(this.offset, true);
+    const high = this.view.getInt32(this.offset + 4, true);
+    this.offset += 8;
+    return BigInt(low) | BigInt(high) << 32n;
+  }
+  readI128() {
+    const unsigned = this.readU128();
+    const signBit = 1n << 127n;
+    if ((unsigned & signBit) !== 0n) {
+      return unsigned - (1n << 128n);
     }
+    return unsigned;
   }
-  /**
-   * Get the index of an account in the sorted order.
-   * Returns -1 if account not found.
-   */
-  getIndex(pubkey) {
-    const sorted = this.getSortedAccounts();
-    return sorted.findIndex((entry) => entry.pubkey.equals(pubkey));
+  readF32() {
+    this.ensureAvailable(4);
+    const value = this.view.getFloat32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readF64() {
+    this.ensureAvailable(8);
+    const value = this.view.getFloat64(this.offset, true);
+    this.offset += 8;
+    return value;
+  }
+  readBool() {
+    const value = this.readU8();
+    if (value > 1) {
+      throw new Error(`Invalid boolean value: ${value}`);
+    }
+    return value === 1;
+  }
+  // ========== Compound Types ==========
+  readBytes(length) {
+    this.ensureAvailable(length);
+    const bytes = this.bytes.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return bytes;
+  }
+  readFixedArray(length) {
+    return this.readBytes(length);
+  }
+  readVecBytes() {
+    const length = this.readLength();
+    return this.readBytes(length);
+  }
+  readString() {
+    const bytes = this.readVecBytes();
+    return new TextDecoder().decode(bytes);
+  }
+  readVariant() {
+    return this.readU32();
+  }
+  readOption(readValue2) {
+    const hasValue = this.readU8();
+    if (hasValue === 0) {
+      return null;
+    }
+    if (hasValue !== 1) {
+      throw new Error(`Invalid option discriminant: ${hasValue}`);
+    }
+    return readValue2();
+  }
+  readVec(readElement) {
+    const length = this.readLength();
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      result.push(readElement());
+    }
+    return result;
   }
   /**
-   * Get sorted accounts according to transaction rules.
+   * Read a tuple of fixed size with heterogeneous types
    */
-  getSortedAccounts() {
-    const entries = this.accountOrder.map((key) => this.accounts.get(key));
-    return entries.sort((a, b) => {
-      const aPriority = a.isSigner && a.isWritable ? 0 : a.isSigner ? 1 : a.isWritable ? 2 : 3;
-      const bPriority = b.isSigner && b.isWritable ? 0 : b.isSigner ? 1 : b.isWritable ? 2 : 3;
-      if (aPriority !== bPriority) {
-        return aPriority - bPriority;
-      }
-      const aBytes = a.pubkey.toBytes();
-      const bBytes = b.pubkey.toBytes();
-      for (let i = 0; i < 32; i++) {
-        if (aBytes[i] !== bBytes[i]) {
-          return aBytes[i] - bBytes[i];
-        }
-      }
-      return 0;
-    });
+  readTuple(readers) {
+    return readers.map((read) => read());
+  }
+  readMap(readKey, readValue2) {
+    const length = this.readLength();
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < length; i++) {
+      const key = readKey();
+      const value = readValue2();
+      map.set(key, value);
+    }
+    return map;
   }
+  // ========== Helpers ==========
   /**
-   * Get the message header based on sorted accounts.
+   * Read length as u64 but validate it's within safe integer range
    */
-  getHeader() {
-    const sorted = this.getSortedAccounts();
-    let numRequiredSignatures = 0;
-    let numReadonlySignedAccounts = 0;
-    let numReadonlyUnsignedAccounts = 0;
-    for (const entry of sorted) {
-      if (entry.isSigner) {
-        numRequiredSignatures++;
-        if (!entry.isWritable) {
-          numReadonlySignedAccounts++;
-        }
-      } else if (!entry.isWritable) {
-        numReadonlyUnsignedAccounts++;
-      }
+  readLength() {
+    const length = this.readU64();
+    if (length > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`Length ${length} exceeds maximum safe integer`);
     }
-    return {
-      numRequiredSignatures,
-      numReadonlySignedAccounts,
-      numReadonlyUnsignedAccounts
-    };
-  }
-  /**
-   * Get sorted public keys.
-   */
-  getPublicKeys() {
-    return this.getSortedAccounts().map((entry) => entry.pubkey);
-  }
-  /**
-   * Get number of accounts in table.
-   */
-  size() {
-    return this.accounts.size;
-  }
-};
-
-// src/transaction/errors.ts
-var TransactionErrorCode = /* @__PURE__ */ ((TransactionErrorCode2) => {
-  TransactionErrorCode2["INVALID_INSTRUCTION"] = "INVALID_INSTRUCTION";
-  TransactionErrorCode2["INVALID_ACCOUNT_META"] = "INVALID_ACCOUNT_META";
-  TransactionErrorCode2["NO_INSTRUCTIONS"] = "NO_INSTRUCTIONS";
-  TransactionErrorCode2["DUPLICATE_ACCOUNT"] = "DUPLICATE_ACCOUNT";
-  TransactionErrorCode2["MISSING_SIGNATURE"] = "MISSING_SIGNATURE";
-  TransactionErrorCode2["INVALID_SIGNATURE"] = "INVALID_SIGNATURE";
-  TransactionErrorCode2["SIGNATURE_OUT_OF_BOUNDS"] = "SIGNATURE_OUT_OF_BOUNDS";
-  TransactionErrorCode2["SIGNER_NOT_FOUND"] = "SIGNER_NOT_FOUND";
-  TransactionErrorCode2["ALREADY_SIGNED"] = "ALREADY_SIGNED";
-  TransactionErrorCode2["INVALID_MESSAGE_FORMAT"] = "INVALID_MESSAGE_FORMAT";
-  TransactionErrorCode2["INSUFFICIENT_DATA"] = "INSUFFICIENT_DATA";
-  TransactionErrorCode2["SERIALIZATION_FAILED"] = "SERIALIZATION_FAILED";
-  TransactionErrorCode2["SIMULATION_FAILED"] = "SIMULATION_FAILED";
-  TransactionErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-  TransactionErrorCode2["BLOCKHASH_EXPIRED"] = "BLOCKHASH_EXPIRED";
-  return TransactionErrorCode2;
-})(TransactionErrorCode || {});
-var TransactionError = class _TransactionError extends Error {
-  constructor(code, message, details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "TransactionError";
-  }
-  static noInstructions() {
-    return new _TransactionError(
-      "NO_INSTRUCTIONS" /* NO_INSTRUCTIONS */,
-      "Transaction must contain at least one instruction. Use addInstruction() to add instructions."
-    );
-  }
-  static signerNotFound(pubkey) {
-    return new _TransactionError(
-      "SIGNER_NOT_FOUND" /* SIGNER_NOT_FOUND */,
-      `Public key ${pubkey} is not a required signer for this transaction. Check that the account is marked as a signer in the instruction.`,
-      { pubkey }
-    );
-  }
-  static missingSignature(index, pubkey) {
-    return new _TransactionError(
-      "MISSING_SIGNATURE" /* MISSING_SIGNATURE */,
-      `Missing signature for signer ${index} (${pubkey}). Transaction requires ${index + 1} signatures.`,
-      { index, pubkey }
-    );
-  }
-  static simulationFailed(logs, error) {
-    return new _TransactionError(
-      "SIMULATION_FAILED" /* SIMULATION_FAILED */,
-      `Transaction simulation failed: ${error}`,
-      { logs, error }
-    );
-  }
-  static insufficientFunds(required, available) {
-    return new _TransactionError(
-      "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */,
-      `Insufficient funds: need ${required}, have ${available}`,
-      { required: required.toString(), available: available.toString() }
-    );
+    const numLength = Number(length);
+    if (numLength > this.remaining()) {
+      throw new Error(
+        `Length ${numLength} exceeds remaining bytes ${this.remaining()}`
+      );
+    }
+    return numLength;
   }
-  toJSON() {
-    return {
-      code: this.code,
-      message: this.message,
-      details: this.details
-    };
+  ensureAvailable(bytes) {
+    if (this.offset + bytes > this.bytes.length) {
+      throw new Error(
+        `Unexpected end of data: need ${bytes} bytes at offset ${this.offset}, but only ${this.bytes.length - this.offset} available`
+      );
+    }
   }
 };
 
@@ -7140,12 +7524,12 @@ var BincodeWriter = class {
   writeVariant(index) {
     return this.writeU32(index);
   }
-  writeOption(value, writeValue) {
+  writeOption(value, writeValue2) {
     if (value === null || value === void 0) {
       this.writeU8(0);
     } else {
       this.writeU8(1);
-      writeValue(this, value);
+      writeValue2(this, value);
     }
     return this;
   }
@@ -7168,11 +7552,11 @@ var BincodeWriter = class {
     }
     return this;
   }
-  writeMap(map, writeKey, writeValue) {
+  writeMap(map, writeKey, writeValue2) {
     this.writeU64(BigInt(map.size));
     for (const [key, value] of map) {
       writeKey(this, key);
-      writeValue(this, value);
+      writeValue2(this, value);
     }
     return this;
   }
@@ -7225,11 +7609,366 @@ var BincodeWriter = class {
   }
 };
 
+// src/serialization/bincode/schema.ts
+var Schema = {
+  u8: () => ({ type: "u8" }),
+  u16: () => ({ type: "u16" }),
+  u32: () => ({ type: "u32" }),
+  u64: () => ({ type: "u64" }),
+  u128: () => ({ type: "u128" }),
+  i8: () => ({ type: "i8" }),
+  i16: () => ({ type: "i16" }),
+  i32: () => ({ type: "i32" }),
+  i64: () => ({ type: "i64" }),
+  i128: () => ({ type: "i128" }),
+  f32: () => ({ type: "f32" }),
+  f64: () => ({ type: "f64" }),
+  bool: () => ({ type: "bool" }),
+  string: () => ({ type: "string" }),
+  bytes: () => ({ type: "bytes" }),
+  unit: () => ({ type: "unit" }),
+  fixedArray: (length) => ({
+    type: "fixedArray",
+    length
+  }),
+  vec: (element) => ({
+    type: "vec",
+    element
+  }),
+  option: (inner) => ({
+    type: "option",
+    inner
+  }),
+  tuple: (...elements) => ({
+    type: "tuple",
+    elements
+  }),
+  /**
+   * Define a struct with ordered fields
+   * @example
+   * Schema.struct([
+   *   ["id", Schema.u64()],
+   *   ["name", Schema.string()],
+   *   ["active", Schema.bool()],
+   * ])
+   */
+  struct: (fields) => ({
+    type: "struct",
+    fields: fields.map(([name, schema]) => ({ name, schema }))
+  }),
+  /**
+   * Define an enum with ordered variants
+   * @example
+   * Schema.enum([
+   *   ["None", null],
+   *   ["Some", Schema.u64()],
+   *   ["Error", Schema.string()],
+   * ])
+   */
+  enum: (variants) => ({
+    type: "enum",
+    variants: variants.map(([name, schema]) => ({ name, schema }))
+  }),
+  map: (key, value) => ({
+    type: "map",
+    key,
+    value
+  }),
+  pubkey: () => ({ type: "pubkey" })
+};
+function serialize(schema, value) {
+  const writer = new BincodeWriter();
+  writeValue(writer, schema, value);
+  return writer.toBytes();
+}
+function deserialize(schema, data) {
+  const reader = new BincodeReader(data);
+  const result = readValue(reader, schema);
+  if (!reader.isExhausted()) {
+    console.warn(
+      `Bincode deserialize: ${reader.remaining()} bytes remaining after parsing`
+    );
+  }
+  return result;
+}
+function deserializeStrict(schema, data) {
+  const reader = new BincodeReader(data);
+  const result = readValue(reader, schema);
+  if (!reader.isExhausted()) {
+    throw new Error(
+      `Unexpected data: ${reader.remaining()} bytes remaining after parsing`
+    );
+  }
+  return result;
+}
+function writeValue(writer, schema, value) {
+  switch (schema.type) {
+    case "u8":
+      writer.writeU8(value);
+      break;
+    case "u16":
+      writer.writeU16(value);
+      break;
+    case "u32":
+      writer.writeU32(value);
+      break;
+    case "u64":
+      writer.writeU64(value);
+      break;
+    case "u128":
+      writer.writeU128(value);
+      break;
+    case "i8":
+      writer.writeI8(value);
+      break;
+    case "i16":
+      writer.writeI16(value);
+      break;
+    case "i32":
+      writer.writeI32(value);
+      break;
+    case "i64":
+      writer.writeI64(value);
+      break;
+    case "i128":
+      writer.writeI128(value);
+      break;
+    case "f32":
+      writer.writeF32(value);
+      break;
+    case "f64":
+      writer.writeF64(value);
+      break;
+    case "bool":
+      writer.writeBool(value);
+      break;
+    case "string":
+      writer.writeString(value);
+      break;
+    case "bytes":
+      writer.writeVecBytes(value);
+      break;
+    case "unit":
+      break;
+    case "fixedArray": {
+      const arr = value;
+      if (arr.length !== schema.length) {
+        throw new Error(
+          `Fixed array length mismatch: expected ${schema.length}, got ${arr.length}`
+        );
+      }
+      writer.writeFixedArray(arr);
+      break;
+    }
+    case "pubkey": {
+      const arr = value;
+      if (arr.length !== 32) {
+        throw new Error(`Pubkey must be exactly 32 bytes, got ${arr.length}`);
+      }
+      writer.writeFixedArray(arr);
+      break;
+    }
+    case "vec": {
+      const arr = value;
+      writer.writeU64(BigInt(arr.length));
+      for (const item of arr) {
+        writeValue(writer, schema.element, item);
+      }
+      break;
+    }
+    case "option": {
+      if (value === null || value === void 0) {
+        writer.writeU8(0);
+      } else {
+        writer.writeU8(1);
+        writeValue(writer, schema.inner, value);
+      }
+      break;
+    }
+    case "tuple": {
+      const arr = value;
+      if (arr.length !== schema.elements.length) {
+        throw new Error(
+          `Tuple length mismatch: expected ${schema.elements.length}, got ${arr.length}`
+        );
+      }
+      for (let i = 0; i < schema.elements.length; i++) {
+        writeValue(writer, schema.elements[i], arr[i]);
+      }
+      break;
+    }
+    case "struct": {
+      const obj = value;
+      for (const field2 of schema.fields) {
+        if (!(field2.name in obj)) {
+          throw new Error(`Missing struct field: ${field2.name}`);
+        }
+        writeValue(writer, field2.schema, obj[field2.name]);
+      }
+      break;
+    }
+    case "enum": {
+      const enumValue = value;
+      const variantIndex = schema.variants.findIndex(
+        (v) => v.name === enumValue.variant
+      );
+      if (variantIndex === -1) {
+        const validVariants = schema.variants.map((v) => v.name).join(", ");
+        throw new Error(
+          `Unknown variant: ${enumValue.variant}. Valid variants: ${validVariants}`
+        );
+      }
+      writer.writeVariant(variantIndex);
+      const variantSchema = schema.variants[variantIndex].schema;
+      if (variantSchema !== null) {
+        writeValue(writer, variantSchema, enumValue.value);
+      }
+      break;
+    }
+    case "map": {
+      const map = value;
+      writer.writeU64(BigInt(map.size));
+      for (const [k, v] of map) {
+        writeValue(writer, schema.key, k);
+        writeValue(writer, schema.value, v);
+      }
+      break;
+    }
+    default: {
+      throw new Error(`Unknown schema type: ${JSON.stringify(schema)}`);
+    }
+  }
+}
+function readValue(reader, schema) {
+  switch (schema.type) {
+    case "u8":
+      return reader.readU8();
+    case "u16":
+      return reader.readU16();
+    case "u32":
+      return reader.readU32();
+    case "u64":
+      return reader.readU64();
+    case "u128":
+      return reader.readU128();
+    case "i8":
+      return reader.readI8();
+    case "i16":
+      return reader.readI16();
+    case "i32":
+      return reader.readI32();
+    case "i64":
+      return reader.readI64();
+    case "i128":
+      return reader.readI128();
+    case "f32":
+      return reader.readF32();
+    case "f64":
+      return reader.readF64();
+    case "bool":
+      return reader.readBool();
+    case "string":
+      return reader.readString();
+    case "bytes":
+      return reader.readVecBytes();
+    case "unit":
+      return void 0;
+    case "fixedArray":
+      return reader.readFixedArray(schema.length);
+    case "pubkey":
+      return reader.readFixedArray(32);
+    case "vec": {
+      const lengthBigInt = reader.readU64();
+      if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error(
+          `Vec length ${lengthBigInt} exceeds safe integer range`
+        );
+      }
+      const length = Number(lengthBigInt);
+      const result = [];
+      for (let i = 0; i < length; i++) {
+        result.push(readValue(reader, schema.element));
+      }
+      return result;
+    }
+    case "option": {
+      const hasValue = reader.readU8();
+      if (hasValue === 0) return null;
+      if (hasValue !== 1) {
+        throw new Error(`Invalid option discriminant: ${hasValue}`);
+      }
+      return readValue(reader, schema.inner);
+    }
+    case "tuple": {
+      const result = [];
+      for (const elementSchema of schema.elements) {
+        result.push(readValue(reader, elementSchema));
+      }
+      return result;
+    }
+    case "struct": {
+      const result = {};
+      for (const field2 of schema.fields) {
+        result[field2.name] = readValue(reader, field2.schema);
+      }
+      return result;
+    }
+    case "enum": {
+      const variantIndex = reader.readVariant();
+      if (variantIndex >= schema.variants.length) {
+        throw new Error(
+          `Invalid variant index: ${variantIndex}, max: ${schema.variants.length - 1}`
+        );
+      }
+      const variant = schema.variants[variantIndex];
+      if (variant.schema === null) {
+        return { variant: variant.name };
+      }
+      return {
+        variant: variant.name,
+        value: readValue(reader, variant.schema)
+      };
+    }
+    case "map": {
+      const lengthBigInt = reader.readU64();
+      if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error(
+          `Map length ${lengthBigInt} exceeds safe integer range`
+        );
+      }
+      const length = Number(lengthBigInt);
+      const map = /* @__PURE__ */ new Map();
+      for (let i = 0; i < length; i++) {
+        const key = readValue(reader, schema.key);
+        const value = readValue(reader, schema.value);
+        map.set(key, value);
+      }
+      return map;
+    }
+    default: {
+      const _exhaustive = schema;
+      throw new Error(
+        `Unknown schema type: ${_exhaustive.type}`
+      );
+    }
+  }
+}
+
 // node_modules/@dao-xyz/borsh/lib/esm/binary.js
 var import_float = __toESM(require_float());
 var import_utf8 = __toESM(require_utf8());
 
 // node_modules/@dao-xyz/borsh/lib/esm/bigint.js
+function arrayToHex(arr, reverse = false) {
+  return [...reverse ? new Uint8Array(arr).reverse() : new Uint8Array(arr)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function toBigIntLE(buf) {
+  const hex = arrayToHex(buf, true);
+  if (hex.length === 0) {
+    return BigInt(0);
+  }
+  return BigInt(`0x${hex}`);
+}
 function writeBufferLEBigInt(num, width, buffer, offset) {
   const hex = num.toString(16);
   const padded = hex.padStart(width * 2, "0").slice(0, width * 2);
@@ -7282,6 +8021,39 @@ var writeBigUint64Le = (bigIntOrNumber, buf, offset) => {
   buf[offset + 6] = hi >>> 16;
   buf[offset + 7] = hi >>> 24;
 };
+var readBigUInt64LE = (buf, offset) => {
+  const first = buf[offset];
+  const last = buf[offset + 7];
+  if (first === void 0 || last === void 0)
+    throw new Error("Out of bounds");
+  let lo = (first | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24) >>> 0;
+  let hi = (buf[offset + 4] | buf[offset + 5] << 8 | buf[offset + 6] << 16 | last << 24) >>> 0;
+  if (hi > 0) {
+    return BigInt(lo) + (BigInt(hi) << 32n);
+  }
+  return BigInt(lo);
+};
+function readUIntLE(buf, offset, width) {
+  const hex = arrayToHex(buf.subarray(offset, offset + width), true);
+  if (hex.length === 0) {
+    return BigInt(0);
+  }
+  return BigInt(`0x${hex}`);
+}
+var readUInt32LE = (buffer, offset) => {
+  const first = buffer[offset];
+  const last = buffer[offset + 3];
+  if (first === void 0 || last === void 0)
+    throw new Error("Out of bounds");
+  return first + buffer[offset + 1] * 2 ** 8 + buffer[offset + 2] * 2 ** 16 + last * 2 ** 24;
+};
+var readUInt16LE = (buffer, offset) => {
+  const first = buffer[offset];
+  const last = buffer[offset + 1];
+  if (first === void 0 || last === void 0)
+    throw new Error("Out of bounds");
+  return first + last * 2 ** 8;
+};
 var checkInt = (value, min, max, byteLength) => {
   if (value > max || value < min) {
     const n = "";
@@ -7532,6 +8304,205 @@ var BinaryWriter = class _BinaryWriter {
     return this._buf;
   }
 };
+var BinaryReader = class _BinaryReader {
+  constructor(buf) {
+    this._buf = buf;
+    this._offset = 0;
+  }
+  bool() {
+    return _BinaryReader.bool(this);
+  }
+  static bool(reader) {
+    const value = reader._buf[reader._offset];
+    reader._offset += 1;
+    if (value !== 1 && value !== 0) {
+      throw new BorshError("Unexpected value for boolean: " + value + ". Expecting either 1 or 0 ");
+    }
+    return value ? true : false;
+  }
+  u8() {
+    return _BinaryReader.u8(this);
+  }
+  static u8(reader) {
+    if (reader._offset >= reader._buf.length) {
+      throw new BorshError("Reader out of bounds");
+    }
+    const value = reader._buf[reader._offset];
+    reader._offset += 1;
+    return value;
+  }
+  u16() {
+    return _BinaryReader.u16(this);
+  }
+  static u16(reader) {
+    const value = readUInt16LE(reader._buf, reader._offset);
+    reader._offset += 2;
+    return value;
+  }
+  u32() {
+    return _BinaryReader.u32(this);
+  }
+  static u32(reader) {
+    const value = readUInt32LE(reader._buf, reader._offset);
+    reader._offset += 4;
+    return value;
+  }
+  u64() {
+    return _BinaryReader.u64(this);
+  }
+  static u64(reader) {
+    const value = readBigUInt64LE(reader._buf, reader._offset);
+    reader._offset += 8;
+    return value;
+  }
+  u128() {
+    return _BinaryReader.u128(this);
+  }
+  static u128(reader) {
+    const value = readUIntLE(reader._buf, reader._offset, 16);
+    reader._offset += 16;
+    return value;
+  }
+  u256() {
+    return _BinaryReader.u256(this);
+  }
+  static u256(reader) {
+    const value = readUIntLE(reader._buf, reader._offset, 32);
+    reader._offset += 32;
+    return value;
+  }
+  u512() {
+    return _BinaryReader.u512(this);
+  }
+  static u512(reader) {
+    const buf = reader.buffer(64);
+    return toBigIntLE(buf);
+  }
+  f32() {
+    return _BinaryReader.f32(this);
+  }
+  static f32(reader) {
+    const value = (0, import_float.readFloatLE)(reader._buf, reader._offset);
+    reader._offset += 4;
+    if (Number.isNaN(value)) {
+      throw new BorshError("Recieved NaN reading f32");
+    }
+    return value;
+  }
+  f64() {
+    return _BinaryReader.f64(this);
+  }
+  static f64(reader) {
+    const value = (0, import_float.readDoubleLE)(reader._buf, reader._offset);
+    reader._offset += 8;
+    if (Number.isNaN(value)) {
+      throw new BorshError("Recieved NaN reading f64");
+    }
+    return value;
+  }
+  string() {
+    return _BinaryReader.string(this);
+  }
+  static string(reader) {
+    const len = reader.u32();
+    const end = reader._offset + len;
+    if (end > reader._buf.length) {
+      throw new BorshError("Error decoding UTF-8 string: Invalid length");
+    }
+    try {
+      const string = import_utf8.default.read(reader._buf, reader._offset, end);
+      reader._offset = end;
+      return string;
+    } catch (e) {
+      throw new BorshError(`Error decoding UTF-8 string: ${e}`);
+    }
+  }
+  static bufferString(reader) {
+    const len = reader.u32();
+    const end = reader._offset + len;
+    if (end > reader._buf.length) {
+      throw new BorshError("Error decoding UTF-8 string: Invalid length");
+    }
+    const string = reader._buf.toString(void 0, reader._offset, end);
+    reader._offset = end;
+    return string;
+  }
+  static bufferStringCustom(reader, length) {
+    const len = length(reader);
+    const end = reader._offset + len;
+    if (end > reader._buf.length) {
+      throw new BorshError("Error decoding UTF-8 string: Invalid length");
+    }
+    try {
+      const string = reader._buf.toString(void 0, reader._offset, end);
+      reader._offset = end;
+      return string;
+    } catch (e) {
+      throw new BorshError(`Error decoding UTF-8 string: ${e}`);
+    }
+  }
+  static stringCustom(reader, length) {
+    const len = length(reader);
+    const end = reader._offset + len;
+    if (end > reader._buf.length) {
+      throw new BorshError("Error decoding UTF-8 string: Invalid length");
+    }
+    try {
+      const string = import_utf8.default.read(reader._buf, reader._offset, end);
+      reader._offset = end;
+      return string;
+    } catch (e) {
+      throw new BorshError(`Error decoding UTF-8 string: ${e}`);
+    }
+  }
+  static read(encoding, fromBuffer) {
+    if (encoding === "u8") {
+      return _BinaryReader.u8;
+    } else if (encoding === "u16") {
+      return _BinaryReader.u16;
+    } else if (encoding === "u32") {
+      return _BinaryReader.u32;
+    } else if (encoding === "u64") {
+      return _BinaryReader.u64;
+    } else if (encoding === "u128") {
+      return _BinaryReader.u128;
+    } else if (encoding === "u256") {
+      return _BinaryReader.u256;
+    } else if (encoding === "u512") {
+      return _BinaryReader.u512;
+    } else if (encoding === "string") {
+      return fromBuffer ? _BinaryReader.bufferString : _BinaryReader.string;
+    } else if (encoding === "bool") {
+      return _BinaryReader.bool;
+    } else if (encoding === "f32") {
+      return _BinaryReader.f32;
+    } else if (encoding === "f64") {
+      return _BinaryReader.f64;
+    } else {
+      throw new Error("Unsupported encoding: " + encoding);
+    }
+  }
+  buffer(len) {
+    const end = this._offset + len;
+    const result = this._buf.subarray(this._offset, end);
+    this._offset = end;
+    return result;
+  }
+  uint8Array() {
+    return _BinaryReader.uint8Array(this);
+  }
+  static uint8Array(reader, size = reader.u32()) {
+    return reader.buffer(size);
+  }
+  readArray(fn) {
+    const len = this.u32();
+    const result = new Array(len);
+    for (let i = 0; i < len; ++i) {
+      result[i] = fn();
+    }
+    return result;
+  }
+};
 
 // node_modules/@dao-xyz/borsh/lib/esm/types.js
 var extendingClasses = (clazz) => {
@@ -7570,18 +8541,53 @@ var StringType = class {
 };
 var OptionKind = class extends WrappedType {
 };
+var option = (type) => {
+  return new OptionKind(type);
+};
 var VecKind = class extends WrappedType {
   constructor(elementType, sizeEncoding) {
     super(elementType);
     this.sizeEncoding = sizeEncoding;
   }
 };
+var vec = (type, sizeEncoding = "u32") => {
+  return new VecKind(type, sizeEncoding);
+};
 var FixedArrayKind = class extends WrappedType {
   constructor(type, length) {
     super(type);
     this.length = length;
   }
 };
+var fixedArray = (type, length) => {
+  return new FixedArrayKind(type, length);
+};
+var StructKind = class {
+  constructor(properties) {
+    if (properties) {
+      this.fields = properties.fields;
+      this.variant = properties.variant;
+    } else {
+      this.fields = [];
+    }
+  }
+  getDependencies() {
+    let ret = [];
+    this.fields.forEach((field2, ix) => {
+      if (!field2) {
+        throw new BorshError("Field: " + ix + " is missing specification");
+      }
+      if (field2.type instanceof WrappedType) {
+        let dependency = field2.type.getDependency();
+        if (dependency)
+          ret.push(dependency);
+      } else if (typeof field2.type === "function") {
+        ret.push(field2.type);
+      }
+    });
+    return ret;
+  }
+};
 
 // node_modules/@dao-xyz/borsh/lib/esm/index.js
 var MAX_PROTOTYPE_SEARCH = 250;
@@ -7589,7 +8595,7 @@ var PROTOTYPE_POLLUTION_CONTEXT_RANGE = 500;
 var PROTOTYPE_DESERIALIZATION_HANDLER_OFFSET = 500;
 var PROTOTYPE_DEPENDENCY_HANDLER_OFFSET = PROTOTYPE_DESERIALIZATION_HANDLER_OFFSET + PROTOTYPE_POLLUTION_CONTEXT_RANGE;
 var PROTOTYPE_SCHEMA_OFFSET = PROTOTYPE_DESERIALIZATION_HANDLER_OFFSET + PROTOTYPE_POLLUTION_CONTEXT_RANGE * 2;
-function serialize(obj, writer = new BinaryWriter()) {
+function serialize2(obj, writer = new BinaryWriter()) {
   (obj.constructor._borsh_serialize || (obj.constructor._borsh_serialize = serializeStruct(obj.constructor, true)))(obj, writer);
   return writer.finalize();
 }
@@ -7597,6 +8603,15 @@ function recursiveSerialize(obj, writer = new BinaryWriter()) {
   (obj.constructor._borsh_serialize_recursive || (obj.constructor._borsh_serialize_recursive = serializeStruct(obj.constructor, false)))(obj, writer);
   return writer.finalize();
 }
+function deserialize2(buffer, classType, options) {
+  const reader = new BinaryReader(buffer);
+  let fromBuffer = buffer.constructor !== Uint8Array;
+  const result = deserializeStruct(classType, fromBuffer)(reader, options);
+  if (reader._offset !== buffer.length) {
+    throw new BorshError(`Unexpected ${buffer.length - reader._offset} bytes after deserialized data. This is most likely due to that you are deserializing into the wrong class`);
+  }
+  return result;
+}
 function serializeField(fieldName, fieldType, options) {
   if (typeof fieldType.serialize == "function") {
     return (obj, writer) => fieldType.serialize(obj, writer);
@@ -7717,94 +8732,517 @@ function serializeStruct(ctor, allowCustomSerializer = true) {
           } : (_obj, writer) => writer.string(index);
         }
       }
-      if (allowCustomSerializer && schema.serializer) {
-        let prev = handle;
-        handle = prev ? (obj, writer) => {
-          prev(obj, writer);
-          schema.serializer(obj, writer, (obj2) => recursiveSerialize(obj2));
-        } : (obj, writer) => schema.serializer(obj, writer, (obj2) => recursiveSerialize(obj2));
-      } else {
-        for (const field2 of schema.fields) {
-          let prev = handle;
-          const fieldHandle = serializeField(field2.key, field2.type);
-          if (prev) {
-            handle = (obj, writer) => {
-              prev(obj, writer);
-              fieldHandle(obj[field2.key], writer);
-            };
-          } else {
-            handle = (obj, writer) => fieldHandle(obj[field2.key], writer);
-          }
+      if (allowCustomSerializer && schema.serializer) {
+        let prev = handle;
+        handle = prev ? (obj, writer) => {
+          prev(obj, writer);
+          schema.serializer(obj, writer, (obj2) => recursiveSerialize(obj2));
+        } : (obj, writer) => schema.serializer(obj, writer, (obj2) => recursiveSerialize(obj2));
+      } else {
+        for (const field2 of schema.fields) {
+          let prev = handle;
+          const fieldHandle = serializeField(field2.key, field2.type);
+          if (prev) {
+            handle = (obj, writer) => {
+              prev(obj, writer);
+              fieldHandle(obj[field2.key], writer);
+            };
+          } else {
+            handle = (obj, writer) => fieldHandle(obj[field2.key], writer);
+          }
+        }
+      }
+    } else if (once && !getDependencies(ctor, i)?.length) {
+      return handle;
+    }
+    i++;
+    if (i == MAX_PROTOTYPE_SEARCH && !once) {
+      throw new BorshError(`Class ${ctor.name} is missing in schema`);
+    }
+  }
+}
+var MAX_ARRAY_SIZE_ALLOCATION = 1024 * 1024;
+function deserializeField(fieldName, fieldType, fromBuffer) {
+  try {
+    if (typeof fieldType === "string") {
+      return BinaryReader.read(fieldType, fromBuffer);
+    }
+    if (fieldType === Uint8Array) {
+      return (reader) => reader.uint8Array();
+    }
+    if (fieldType instanceof VecKind || fieldType instanceof FixedArrayKind) {
+      if (fieldType.elementType === "u8") {
+        if (fieldType instanceof FixedArrayKind) {
+          return (reader) => reader.buffer(fieldType.length);
+        } else {
+          const sizeHandle = BinaryReader.read(fieldType.sizeEncoding, fromBuffer);
+          return (reader) => BinaryReader.uint8Array(reader, sizeHandle(reader));
+        }
+      } else {
+        let sizeHandle = fieldType instanceof VecKind ? BinaryReader.read(fieldType.sizeEncoding, fromBuffer) : () => fieldType.length;
+        const fieldHandle = deserializeField(null, fieldType.elementType, fromBuffer);
+        return (reader, options) => {
+          const len = sizeHandle(reader);
+          if (len < MAX_ARRAY_SIZE_ALLOCATION) {
+            let arr = new Array(len);
+            for (let i = 0; i < len; i++) {
+              arr[i] = fieldHandle(reader, options);
+            }
+            return arr;
+          } else {
+            let arr = new Array(MAX_ARRAY_SIZE_ALLOCATION);
+            for (let i = 0; i < len; i++) {
+              arr[i] = fieldHandle(reader, options);
+            }
+            return arr;
+          }
+        };
+      }
+    }
+    if (fieldType instanceof StringType) {
+      const sizeReader = BinaryReader.read(fieldType.sizeEncoding, fromBuffer);
+      return fromBuffer ? (reader) => BinaryReader.bufferStringCustom(reader, sizeReader) : (reader) => BinaryReader.stringCustom(reader, sizeReader);
+    }
+    if (typeof fieldType["deserialize"] == "function") {
+      return (reader) => fieldType.deserialize(reader);
+    }
+    if (fieldType instanceof OptionKind) {
+      const fieldHandle = deserializeField(fieldName, fieldType.elementType, fromBuffer);
+      return (reader, options) => {
+        return reader.bool() ? fieldHandle(reader, options) : void 0;
+      };
+    }
+    return deserializeStruct(fieldType, fromBuffer);
+  } catch (error) {
+    if (error instanceof BorshError) {
+      error.addToFieldPath(fieldName);
+    }
+    throw error;
+  }
+}
+function deserializeStruct(targetClazz, fromBuffer) {
+  const handle = getCreateDeserializationHandle(targetClazz, 0, fromBuffer);
+  return (reader, options) => {
+    const result = handle({}, reader, options);
+    if (!options?.unchecked && !options?.object && !checkClazzesCompatible(result.constructor, targetClazz)) {
+      throw new BorshError(`Deserialization of ${targetClazz?.name || targetClazz} yielded another Class: ${result.constructor?.name} which are not compatible`);
+    }
+    return result;
+  };
+}
+var getCreateDeserializationHandle = (clazz, offset, fromBuffer) => getDeserializationHandle(clazz, offset, fromBuffer) || setDeserializationHandle(clazz, offset, fromBuffer, createDeserializeStructHandle(clazz, offset, fromBuffer));
+var getDeserializationHandle = (clazz, offset, fromBuffer) => clazz.prototype[PROTOTYPE_DESERIALIZATION_HANDLER_OFFSET + offset + (fromBuffer ? MAX_PROTOTYPE_SEARCH : 0)];
+var setDeserializationHandle = (clazz, offset, fromBuffer, handle) => clazz.prototype[PROTOTYPE_DESERIALIZATION_HANDLER_OFFSET + offset + (fromBuffer ? MAX_PROTOTYPE_SEARCH : 0)] = handle;
+var createDeserializeStructHandle = (currClazz, offset, fromBuffer) => {
+  let handle = void 0;
+  let endHandle = (result, reader, options) => {
+    if (options?.object) {
+      return result;
+    }
+    return Object.assign(options?.construct ? new currClazz() : Object.create(currClazz.prototype), result);
+  };
+  let structSchema = getSchema(currClazz, offset);
+  if (structSchema) {
+    if (offset === 0) {
+      let index = getVariantIndex(structSchema);
+      if (index != null) {
+        if (typeof index === "number") {
+          handle = (_, reader, __) => {
+            reader._offset += 1;
+          };
+        } else if (Array.isArray(index)) {
+          handle = (_, reader, __) => {
+            reader._offset += index.length;
+          };
+        } else {
+          handle = (_, reader, __) => {
+            reader.string();
+          };
+        }
+      }
+    }
+    for (const field2 of structSchema.fields) {
+      const prev = handle;
+      const fieldHandle = deserializeField(field2.key, field2.type, fromBuffer);
+      if (prev) {
+        handle = (result, reader, options) => {
+          prev(result, reader, options);
+          result[field2.key] = fieldHandle(reader, options);
+        };
+      } else
+        handle = (result, reader, options) => {
+          result[field2.key] = fieldHandle(reader, options);
+        };
+    }
+  }
+  let dependencies = getAllDependencies(currClazz, offset);
+  if (dependencies) {
+    let variantToDepndency = [];
+    let variantType;
+    for (const [actualClazz, dependency] of dependencies) {
+      const variantIndex = getVariantIndex(dependency.schema);
+      let currentVariantType = typeof variantIndex === "object" ? variantIndex.length : typeof variantIndex;
+      if (!variantType) {
+        variantType = currentVariantType;
+      } else if (currentVariantType !== variantType) {
+        throw new Error(`Variant extending ${currClazz.name} have different types, expecting either number, number[] (with same sizes) or string, but not a combination of them`);
+      }
+      variantToDepndency.push([variantIndex, actualClazz, dependency]);
+    }
+    if (variantType === "undefined") {
+      if (dependencies.size === 1) {
+        const dep = variantToDepndency[0];
+        return (result, reader, options) => {
+          handle && handle(result, reader, options);
+          return getCreateDeserializationHandle(dep[1], dep[2].offset, fromBuffer)(result, reader, options);
+        };
+      } else
+        throw new BorshError(`Failed to find class to deserialize to from ${currClazz.name}: but no variants are used which makes deserialization undeterministic`);
+    }
+    return (result, reader, options) => {
+      handle && handle(result, reader, options);
+      let next = void 0;
+      let nextOffset = void 0;
+      if (variantType === "number") {
+        let agg = reader.u8();
+        for (const dep of variantToDepndency) {
+          if (agg === dep[0]) {
+            return getCreateDeserializationHandle(dep[1], dep[2].offset, fromBuffer)(result, reader, options);
+          }
+        }
+      } else if (variantType === "string") {
+        let variant = reader.string();
+        for (const dep of variantToDepndency) {
+          if (variant === dep[0]) {
+            return getCreateDeserializationHandle(dep[1], dep[2].offset, fromBuffer)(result, reader, options);
+          }
+        }
+      } else {
+        let agg = [];
+        for (let i = 0; i < variantType; i++) {
+          agg.push(reader.u8());
+        }
+        for (const dep of variantToDepndency) {
+          let currentVariant = dep[0];
+          if (currentVariant.length === agg.length && currentVariant.every((value, index) => value === agg[index])) {
+            return getCreateDeserializationHandle(dep[1], dep[2].offset, fromBuffer)(result, reader, options);
+          }
+        }
+      }
+      if (next == void 0 && dependencies) {
+        if (dependencies.size == 1) {
+          const n = dependencies.entries().next().value;
+          next = n[0];
+          nextOffset = n[1].offset;
+        } else if (dependencies.size > 1) {
+          const classes = [...dependencies.entries()].map(([c]) => c.name).join(", ");
+          throw new BorshError(`Failed to find class to deserialize to from ${currClazz.name} found: ${classes} but no variant matches bytes read from the buffer.`);
+        }
+      }
+      if (next != null) {
+        getCreateDeserializationHandle(next, nextOffset, fromBuffer)(result, reader, options);
+      } else {
+        return endHandle(result, reader, options);
+      }
+    };
+  } else {
+    if (handle) {
+      return (result, reader, options) => {
+        handle(result, reader, options);
+        return endHandle(result, reader, options);
+      };
+    }
+    return endHandle;
+  }
+};
+var getOrCreateStructMeta = (clazz, offset) => {
+  let schema = getSchema(clazz, offset);
+  if (!schema) {
+    schema = new StructKind();
+  }
+  setSchema(clazz, schema, offset);
+  return schema;
+};
+var setDependencyToProtoType = (ctor, offset) => {
+  let proto = Object.getPrototypeOf(ctor);
+  while (proto.prototype?.constructor != void 0) {
+    let newOffset = --offset;
+    let dependencies = getDependencies(proto, newOffset);
+    if (dependencies) {
+      for (const dependency of dependencies) {
+        if (ctor.prototype instanceof dependency || dependency === ctor) {
+          return;
+        }
+      }
+    } else {
+      dependencies = [];
+    }
+    dependencies.push(ctor);
+    setDependencies(proto, newOffset, dependencies);
+    proto = Object.getPrototypeOf(proto);
+  }
+};
+var getSuperMostClass = (clazz) => {
+  while (Object.getPrototypeOf(clazz).prototype != void 0) {
+    clazz = Object.getPrototypeOf(clazz);
+  }
+  return clazz;
+};
+var checkClazzesCompatible = (clazzA, clazzB) => {
+  return clazzA == clazzB || clazzA.isPrototypeOf(clazzB) || clazzB.isPrototypeOf(clazzA);
+};
+var getDependencies = (ctor, offset) => ctor.prototype[PROTOTYPE_DEPENDENCY_HANDLER_OFFSET + offset];
+var setDependencies = (ctor, offset, dependencies) => {
+  ctor.prototype[PROTOTYPE_DEPENDENCY_HANDLER_OFFSET + offset] = dependencies;
+};
+var getAllDependencies = (ctor, offset) => {
+  let existing = getDependencies(ctor, offset);
+  if (existing) {
+    let ret = /* @__PURE__ */ new Map();
+    for (const v of existing) {
+      let schema = getSubMostSchema(v);
+      if (schema.fields.length > 0 || schema.variant != void 0) {
+        ret.set(v, { schema, offset: getOffset(v) });
+      } else {
+        let req = getAllDependencies(v, offset);
+        for (const [rv, rk] of req) {
+          ret.set(rv, rk);
+        }
+      }
+    }
+    return ret;
+  }
+};
+var setSchema = (ctor, schemas, offset) => {
+  ctor.prototype[PROTOTYPE_SCHEMA_OFFSET + offset] = schemas;
+};
+var getSchema = (ctor, offset = getOffset(ctor)) => ctor.prototype[PROTOTYPE_SCHEMA_OFFSET + offset];
+var getSubMostSchema = (ctor) => {
+  let last = void 0;
+  for (var i = 0; i < MAX_PROTOTYPE_SEARCH; i++) {
+    const curr = ctor.prototype[PROTOTYPE_SCHEMA_OFFSET + i];
+    if (!curr && last && !getDependencies(ctor, i)?.length) {
+      return last;
+    }
+    last = curr;
+  }
+  return;
+};
+var getVariantIndex = (schema) => {
+  return schema.variant;
+};
+function field(properties) {
+  return (target, name) => {
+    const offset = getOffset(target.constructor);
+    setDependencyToProtoType(target.constructor, offset);
+    const schemas = getOrCreateStructMeta(target.constructor, offset);
+    const schema = schemas;
+    const key = name.toString();
+    let field2 = void 0;
+    if (properties["type"] != void 0) {
+      field2 = {
+        key,
+        type: properties["type"]
+      };
+    } else {
+      field2 = {
+        key,
+        type: properties
+      };
+    }
+    if (properties.index === void 0) {
+      schema.fields.push(field2);
+    } else {
+      if (schema.fields[properties.index]) {
+        throw new BorshError("Multiple fields defined at the same index: " + properties.index + ", class: " + target.constructor.name);
+      }
+      if (properties.index >= schema.fields.length) {
+        resize(schema.fields, properties.index + 1, void 0);
+      }
+      schema.fields[properties.index] = field2;
+    }
+  };
+}
+var resize = (arr, newSize, defaultValue) => {
+  while (newSize > arr.length)
+    arr.push(defaultValue);
+  arr.length = newSize;
+};
+
+// src/serialization/borsh.ts
+function serializeBorsh(data) {
+  return serialize2(data);
+}
+function deserializeBorsh(data, type) {
+  return deserialize2(data, type);
+}
+
+// src/transaction/account-meta-table.ts
+var AccountMetaTable = class {
+  accounts = /* @__PURE__ */ new Map();
+  accountOrder = [];
+  /**
+   * Add or update an account in the table.
+   * If account already exists, merges signer/writable flags (OR operation).
+   */
+  add(meta) {
+    const key = meta.pubkey.toString();
+    if (this.accounts.has(key)) {
+      const existing = this.accounts.get(key);
+      existing.isSigner ||= meta.isSigner;
+      existing.isWritable ||= meta.isWritable;
+    } else {
+      this.accounts.set(key, {
+        pubkey: meta.pubkey,
+        isSigner: meta.isSigner,
+        isWritable: meta.isWritable
+      });
+      this.accountOrder.push(key);
+    }
+  }
+  /**
+   * Add multiple accounts at once.
+   */
+  addAll(metas) {
+    for (const meta of metas) {
+      this.add(meta);
+    }
+  }
+  /**
+   * Get the index of an account in the sorted order.
+   * Returns -1 if account not found.
+   */
+  getIndex(pubkey) {
+    const sorted = this.getSortedAccounts();
+    return sorted.findIndex((entry) => entry.pubkey.equals(pubkey));
+  }
+  /**
+   * Get sorted accounts according to transaction rules.
+   */
+  getSortedAccounts() {
+    const entries = this.accountOrder.map((key) => this.accounts.get(key));
+    return entries.sort((a, b) => {
+      const aPriority = a.isSigner && a.isWritable ? 0 : a.isSigner ? 1 : a.isWritable ? 2 : 3;
+      const bPriority = b.isSigner && b.isWritable ? 0 : b.isSigner ? 1 : b.isWritable ? 2 : 3;
+      if (aPriority !== bPriority) {
+        return aPriority - bPriority;
+      }
+      const aBytes = a.pubkey.toBytes();
+      const bBytes = b.pubkey.toBytes();
+      for (let i = 0; i < 32; i++) {
+        if (aBytes[i] !== bBytes[i]) {
+          return aBytes[i] - bBytes[i];
+        }
+      }
+      return 0;
+    });
+  }
+  /**
+   * Get the message header based on sorted accounts.
+   */
+  getHeader() {
+    const sorted = this.getSortedAccounts();
+    let numRequiredSignatures = 0;
+    let numReadonlySignedAccounts = 0;
+    let numReadonlyUnsignedAccounts = 0;
+    for (const entry of sorted) {
+      if (entry.isSigner) {
+        numRequiredSignatures++;
+        if (!entry.isWritable) {
+          numReadonlySignedAccounts++;
         }
+      } else if (!entry.isWritable) {
+        numReadonlyUnsignedAccounts++;
       }
-    } else if (once && !getDependencies(ctor, i)?.length) {
-      return handle;
-    }
-    i++;
-    if (i == MAX_PROTOTYPE_SEARCH && !once) {
-      throw new BorshError(`Class ${ctor.name} is missing in schema`);
     }
+    return {
+      numRequiredSignatures,
+      numReadonlySignedAccounts,
+      numReadonlyUnsignedAccounts
+    };
   }
-}
-var getSuperMostClass = (clazz) => {
-  while (Object.getPrototypeOf(clazz).prototype != void 0) {
-    clazz = Object.getPrototypeOf(clazz);
+  /**
+   * Get sorted public keys.
+   */
+  getPublicKeys() {
+    return this.getSortedAccounts().map((entry) => entry.pubkey);
+  }
+  /**
+   * Get number of accounts in table.
+   */
+  size() {
+    return this.accounts.size;
   }
-  return clazz;
-};
-var checkClazzesCompatible = (clazzA, clazzB) => {
-  return clazzA == clazzB || clazzA.isPrototypeOf(clazzB) || clazzB.isPrototypeOf(clazzA);
 };
-var getDependencies = (ctor, offset) => ctor.prototype[PROTOTYPE_DEPENDENCY_HANDLER_OFFSET + offset];
-var getSchema = (ctor, offset = getOffset(ctor)) => ctor.prototype[PROTOTYPE_SCHEMA_OFFSET + offset];
-
-// src/serialization/borsh.ts
-function serializeBorsh(data) {
-  return serialize(data);
-}
 
-// src/serialization/compact-u16.ts
-function deserializeCompactU16(data, currentCursor) {
-  let cursor = currentCursor;
-  if (cursor >= data.length) {
-    throw new TransactionError(
-      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-      "Insufficient data for compact-u16"
+// src/transaction/errors.ts
+var TransactionErrorCode = /* @__PURE__ */ ((TransactionErrorCode2) => {
+  TransactionErrorCode2["INVALID_INSTRUCTION"] = "INVALID_INSTRUCTION";
+  TransactionErrorCode2["INVALID_ACCOUNT_META"] = "INVALID_ACCOUNT_META";
+  TransactionErrorCode2["NO_INSTRUCTIONS"] = "NO_INSTRUCTIONS";
+  TransactionErrorCode2["DUPLICATE_ACCOUNT"] = "DUPLICATE_ACCOUNT";
+  TransactionErrorCode2["MISSING_SIGNATURE"] = "MISSING_SIGNATURE";
+  TransactionErrorCode2["INVALID_SIGNATURE"] = "INVALID_SIGNATURE";
+  TransactionErrorCode2["SIGNATURE_OUT_OF_BOUNDS"] = "SIGNATURE_OUT_OF_BOUNDS";
+  TransactionErrorCode2["SIGNER_NOT_FOUND"] = "SIGNER_NOT_FOUND";
+  TransactionErrorCode2["ALREADY_SIGNED"] = "ALREADY_SIGNED";
+  TransactionErrorCode2["INVALID_MESSAGE_FORMAT"] = "INVALID_MESSAGE_FORMAT";
+  TransactionErrorCode2["INSUFFICIENT_DATA"] = "INSUFFICIENT_DATA";
+  TransactionErrorCode2["SERIALIZATION_FAILED"] = "SERIALIZATION_FAILED";
+  TransactionErrorCode2["SIMULATION_FAILED"] = "SIMULATION_FAILED";
+  TransactionErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+  TransactionErrorCode2["BLOCKHASH_EXPIRED"] = "BLOCKHASH_EXPIRED";
+  return TransactionErrorCode2;
+})(TransactionErrorCode || {});
+var TransactionError = class _TransactionError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "TransactionError";
+  }
+  static noInstructions() {
+    return new _TransactionError(
+      "NO_INSTRUCTIONS" /* NO_INSTRUCTIONS */,
+      "Transaction must contain at least one instruction. Use addInstruction() to add instructions."
     );
   }
-  const firstByte = data[cursor++];
-  if ((firstByte & 128) === 0) {
-    return [firstByte, cursor];
+  static signerNotFound(pubkey) {
+    return new _TransactionError(
+      "SIGNER_NOT_FOUND" /* SIGNER_NOT_FOUND */,
+      `Public key ${pubkey} is not a required signer for this transaction. Check that the account is marked as a signer in the instruction.`,
+      { pubkey }
+    );
   }
-  if (cursor >= data.length) {
-    throw new TransactionError(
-      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-      "Incomplete compact-u16 encoding"
+  static missingSignature(index, pubkey) {
+    return new _TransactionError(
+      "MISSING_SIGNATURE" /* MISSING_SIGNATURE */,
+      `Missing signature for signer ${index} (${pubkey}). Transaction requires ${index + 1} signatures.`,
+      { index, pubkey }
     );
   }
-  const secondByte = data[cursor++];
-  if ((secondByte & 128) === 0) {
-    return [firstByte & 127 | secondByte << 7, cursor];
+  static simulationFailed(logs, error) {
+    return new _TransactionError(
+      "SIMULATION_FAILED" /* SIMULATION_FAILED */,
+      `Transaction simulation failed: ${error}`,
+      { logs, error }
+    );
   }
-  if (cursor >= data.length) {
-    throw new TransactionError(
-      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-      "Incomplete compact-u16 encoding"
+  static insufficientFunds(required, available) {
+    return new _TransactionError(
+      "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */,
+      `Insufficient funds: need ${required}, have ${available}`,
+      { required: required.toString(), available: available.toString() }
     );
   }
-  const thirdByte = data[cursor++];
-  const value = firstByte & 127 | (secondByte & 127) << 7 | thirdByte << 14;
-  return [value, cursor];
-}
-function writeCompactU16(buffer, offset, value) {
-  if (value < 128) {
-    buffer[offset] = value;
-    return offset + 1;
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
   }
-  buffer[offset] = value & 127 | 128;
-  buffer[offset + 1] = value >> 7;
-  return offset + 2;
-}
+};
 
 // src/transaction/instructions/borsh-instruction.ts
 function createBorshInstruction(params) {
@@ -7895,14 +9333,17 @@ var Message = class _Message {
   accountKeys;
   /** Transaction valid from (milliseconds since Unix epoch) */
   validFrom;
+  /** Config hash prefix for replay protection across chains */
+  configHashPrefix;
   /** Compiled instructions with account indices */
   instructions;
   /** Cached serialized bytes */
   serializedCache;
-  constructor(header, accountKeys, validFrom, instructions) {
+  constructor(header, accountKeys, validFrom, configHashPrefix, instructions) {
     this.header = Object.freeze({ ...header });
     this.accountKeys = Object.freeze([...accountKeys]);
     this.validFrom = validFrom;
+    this.configHashPrefix = configHashPrefix;
     this.instructions = Object.freeze(
       instructions.map((ix) => Object.freeze({ ...ix }))
     );
@@ -7936,7 +9377,7 @@ var Message = class _Message {
       numReadonlySignedAccounts: data[cursor++],
       numReadonlyUnsignedAccounts: data[cursor++]
     };
-    const [accountKeysLength, newCursor1] = deserializeCompactU162(data, cursor);
+    const [accountKeysLength, newCursor1] = deserializeCompactU16(data, cursor);
     cursor = newCursor1;
     const accountKeys = [];
     for (let i = 0; i < accountKeysLength; i++) {
@@ -7962,7 +9403,19 @@ var Message = class _Message {
       new DataView(validFromBytes.buffer).getBigUint64(0, true)
     );
     cursor += 8;
-    const [instructionsLength, newCursor2] = deserializeCompactU162(
+    if (data.length < cursor + 8) {
+      throw new TransactionError(
+        "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+        "Insufficient data for configHashPrefix"
+      );
+    }
+    const configHashPrefixBytes = data.slice(cursor, cursor + 8);
+    const configHashPrefix = BigInt.asUintN(
+      64,
+      new DataView(configHashPrefixBytes.buffer).getBigUint64(0, true)
+    );
+    cursor += 8;
+    const [instructionsLength, newCursor2] = deserializeCompactU16(
       data,
       cursor
     );
@@ -7976,7 +9429,7 @@ var Message = class _Message {
         );
       }
       const programIdIndex = data[cursor++];
-      const [accountIndexesLength, newCursor3] = deserializeCompactU162(
+      const [accountIndexesLength, newCursor3] = deserializeCompactU16(
         data,
         cursor
       );
@@ -7991,7 +9444,7 @@ var Message = class _Message {
         }
         accountKeyIndexes.push(data[cursor++]);
       }
-      const [dataLength, newCursor4] = deserializeCompactU162(data, cursor);
+      const [dataLength, newCursor4] = deserializeCompactU16(data, cursor);
       cursor = newCursor4;
       if (data.length < cursor + dataLength) {
         throw new TransactionError(
@@ -8007,7 +9460,7 @@ var Message = class _Message {
         data: instructionData
       });
     }
-    return new _Message(header, accountKeys, validFrom, instructions);
+    return new _Message(header, accountKeys, validFrom, configHashPrefix, instructions);
   }
   serializeInternal() {
     const buffer = [];
@@ -8024,6 +9477,13 @@ var Message = class _Message {
       true
     );
     buffer.push(...new Uint8Array(validFromBuffer));
+    const configHashPrefixBuffer = new ArrayBuffer(8);
+    new DataView(configHashPrefixBuffer).setBigUint64(
+      0,
+      this.configHashPrefix,
+      true
+    );
+    buffer.push(...new Uint8Array(configHashPrefixBuffer));
     this.serializeCompactArray(buffer, this.instructions, (buf, ix) => {
       buf.push(ix.programIdIndex);
       this.serializeCompactArray(buf, ix.accountKeyIndexes, (b, idx) => {
@@ -8078,7 +9538,7 @@ var Message = class _Message {
     return this.getSigners().findIndex((signer) => signer.equals(pubkey));
   }
 };
-function deserializeCompactU162(data, currentCursor) {
+function deserializeCompactU16(data, currentCursor) {
   let cursor = currentCursor;
   if (cursor >= data.length) {
     throw new TransactionError(
@@ -8160,7 +9620,7 @@ var Transaction = class _Transaction {
       );
     }
     let cursor = 0;
-    const [signaturesLength, newCursor] = deserializeCompactU16(data, cursor);
+    const [signaturesLength, newCursor] = deserializeCompactU162(data, cursor);
     cursor = newCursor;
     const signatures = [];
     for (let i = 0; i < signaturesLength; i++) {
@@ -8408,6 +9868,7 @@ var Transaction = class _Transaction {
 var TransactionBuilder = class _TransactionBuilder {
   payer;
   validFrom;
+  configHashPrefix;
   instructions = [];
   constructor() {
   }
@@ -8441,6 +9902,18 @@ var TransactionBuilder = class _TransactionBuilder {
     this.validFrom = validFrom;
     return this;
   }
+  /**
+   * Set the config hash prefix for replay protection.
+   *
+   * This is the first 64 bits of the config hash, used to ensure
+   * transactions cannot be replayed on different chains.
+   *
+   * @param configHashPrefix - config hash prefix as a u64
+   */
+  setConfigHashPrefix(configHashPrefix) {
+    this.configHashPrefix = configHashPrefix;
+    return this;
+  }
   /**
    * Add an instruction to the transaction.
    *
@@ -8486,6 +9959,12 @@ var TransactionBuilder = class _TransactionBuilder {
         "Transaction must have a valid from. Use setValidFrom() to set the valid from."
       );
     }
+    if (this.configHashPrefix === void 0) {
+      throw new TransactionError(
+        "INVALID_MESSAGE_FORMAT" /* INVALID_MESSAGE_FORMAT */,
+        "Transaction must have a config hash prefix. Use setConfigHashPrefix() to set the config hash prefix."
+      );
+    }
     if (this.instructions.length === 0) {
       throw TransactionError.noInstructions();
     }
@@ -8534,11 +10013,94 @@ var TransactionBuilder = class _TransactionBuilder {
       header,
       accountKeys,
       this.validFrom,
+      this.configHashPrefix,
       compiledInstructions
     );
     return Transaction.fromMessage(message);
   }
 };
+
+// src/serialization/compact-u16.ts
+function serializeCompactU16(buffer, value) {
+  if (value < 0 || value > 65535) {
+    throw new TransactionError(
+      "SERIALIZATION_FAILED" /* SERIALIZATION_FAILED */,
+      `Value out of range for compact-u16: ${value}`
+    );
+  }
+  if (value <= 127) {
+    buffer.push(value);
+    return;
+  }
+  if (value <= 16383) {
+    buffer.push(value & 127 | 128);
+    buffer.push(value >> 7 & 127);
+    return;
+  }
+  buffer.push(value & 127 | 128);
+  buffer.push(value >> 7 & 127 | 128);
+  buffer.push(value >> 14 & 255);
+}
+function deserializeCompactU162(data, currentCursor) {
+  let cursor = currentCursor;
+  if (cursor >= data.length) {
+    throw new TransactionError(
+      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+      "Insufficient data for compact-u16"
+    );
+  }
+  const firstByte = data[cursor++];
+  if ((firstByte & 128) === 0) {
+    return [firstByte, cursor];
+  }
+  if (cursor >= data.length) {
+    throw new TransactionError(
+      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+      "Incomplete compact-u16 encoding"
+    );
+  }
+  const secondByte = data[cursor++];
+  if ((secondByte & 128) === 0) {
+    return [firstByte & 127 | secondByte << 7, cursor];
+  }
+  if (cursor >= data.length) {
+    throw new TransactionError(
+      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+      "Incomplete compact-u16 encoding"
+    );
+  }
+  const thirdByte = data[cursor++];
+  const value = firstByte & 127 | (secondByte & 127) << 7 | thirdByte << 14;
+  return [value, cursor];
+}
+function writeCompactU16(buffer, offset, value) {
+  if (value < 128) {
+    buffer[offset] = value;
+    return offset + 1;
+  }
+  buffer[offset] = value & 127 | 128;
+  buffer[offset + 1] = value >> 7;
+  return offset + 2;
+}
+
+// src/signer/keypair-signer.ts
+var KeypairSigner = class {
+  constructor(keypair) {
+    this.keypair = keypair;
+  }
+  /**
+   * Returns the keypair's public key.
+   */
+  async getPublicKey() {
+    return this.keypair.publicKey;
+  }
+  /**
+   * Signs a message using the keypair's private key.
+   */
+  async signMessage(message) {
+    return this.keypair.sign(message);
+  }
+};
 /*! Bundled license information:
 
 @noble/ed25519/index.js:
@@ -8555,6 +10117,6 @@ var TransactionBuilder = class _TransactionBuilder {
   (*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
 
-export { AccountMetaTable, BASE_DERIVATION_PATH, BaseRpcClient, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, HttpTransport, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, Mnemonic, PUBLIC_KEY_LENGTH, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_SHITNET_CHAIN, RIALO_TESTNET_CHAIN, RialoClient, RialoError, RialoErrorType, RpcError, RpcErrorCode, SECRET_KEY_LENGTH, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, Signature, SystemInstruction, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, TransactionRpcClient, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_SHITNET, URL_TESTNET, allocateInstruction, assignInstruction, calculateBackoff, concatBytes2 as concatBytes, createAccount, createBorshInstruction, createRialoClient, encodeBorshData, fromBase64, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, isOnCurve, seedToBytes, sleep, toBase64, transferInstruction };
+export { AccountMetaTable, BASE_DERIVATION_PATH, BaseRpcClient, BincodeReader, BincodeWriter, CHACHA20_POLY1305_TAG_LENGTH, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, ED25519_PUBLIC_KEY_LENGTH, HPKE_ENC_LENGTH, HPKE_OVERHEAD_LENGTH, HpkeError, HpkeErrorCode, HttpTransport, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, Mnemonic, PUBLIC_KEY_LENGTH, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_SHITNET_CHAIN, RIALO_TESTNET_CHAIN, RexValue, RexValueVariant, RialoClient, RialoError, RialoErrorType, RpcError, RpcErrorCode, SECRET_KEY_LENGTH, SECRET_SHARING_HPKE_INFO, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, Schema, Signature, SystemInstruction, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, TransactionRpcClient, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_SHITNET, URL_TESTNET, USER_SECRET_AAD, X25519_PUBLIC_KEY_LENGTH, allocateInstruction, assignInstruction, calculateBackoff, concatBytes2 as concatBytes, createAccount, createBorshInstruction, createRialoClient, deserialize, deserializeBorsh, deserializeCompactU162 as deserializeCompactU16, deserializeStrict, encodeBorshData, encryptForRex, field, fixedArray, fromBase64, getCiphertextLength, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, hpkeEncrypt, isOnCurve, isValidCiphertextLength, option, seedToBytes, serialize, serializeBorsh, serializeCompactU16, sleep, toBase64, transferInstruction, vec, writeCompactU16 };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map