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

package/dist/index.js

@@ -1,5 +1,8 @@
 'use strict';
 
+var chacha20poly1305 = require('@hpke/chacha20poly1305');
+var core = require('@hpke/core');
+
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -5480,6 +5483,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 core.CipherSuite({
+  kem: new core.DhkemX25519HkdfSha256(),
+  kdf: new core.HkdfSha256(),
+  aead: new chacha20poly1305.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";
@@ -5738,9 +6037,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;
     }
@@ -6028,10 +6325,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 {
@@ -6170,6 +6466,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
@@ -6798,189 +7152,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`
+      );
+    }
   }
 };
 
@@ -7142,12 +7526,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;
   }
@@ -7170,11 +7554,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;
   }
@@ -7227,11 +7611,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);
@@ -7284,6 +8023,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 = "";
@@ -7534,6 +8306,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) => {
@@ -7572,18 +8543,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;
@@ -7591,7 +8597,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();
 }
@@ -7599,6 +8605,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);
@@ -7719,94 +8734,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) {
@@ -7897,14 +9335,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 }))
     );
@@ -7938,7 +9379,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++) {
@@ -7964,7 +9405,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
     );
@@ -7978,7 +9431,7 @@ var Message = class _Message {
         );
       }
       const programIdIndex = data[cursor++];
-      const [accountIndexesLength, newCursor3] = deserializeCompactU162(
+      const [accountIndexesLength, newCursor3] = deserializeCompactU16(
         data,
         cursor
       );
@@ -7993,7 +9446,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(
@@ -8009,7 +9462,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 = [];
@@ -8026,6 +9479,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) => {
@@ -8080,7 +9540,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(
@@ -8162,7 +9622,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++) {
@@ -8410,6 +9870,7 @@ var Transaction = class _Transaction {
 var TransactionBuilder = class _TransactionBuilder {
   payer;
   validFrom;
+  configHashPrefix;
   instructions = [];
   constructor() {
   }
@@ -8443,6 +9904,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.
    *
@@ -8488,6 +9961,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();
     }
@@ -8536,11 +10015,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:
@@ -8560,9 +10122,17 @@ var TransactionBuilder = class _TransactionBuilder {
 exports.AccountMetaTable = AccountMetaTable;
 exports.BASE_DERIVATION_PATH = BASE_DERIVATION_PATH;
 exports.BaseRpcClient = BaseRpcClient;
+exports.BincodeReader = BincodeReader;
+exports.BincodeWriter = BincodeWriter;
+exports.CHACHA20_POLY1305_TAG_LENGTH = CHACHA20_POLY1305_TAG_LENGTH;
 exports.CryptoError = CryptoError;
 exports.CryptoErrorCode = CryptoErrorCode;
 exports.DEFAULT_NUM_ACCOUNTS = DEFAULT_NUM_ACCOUNTS;
+exports.ED25519_PUBLIC_KEY_LENGTH = ED25519_PUBLIC_KEY_LENGTH;
+exports.HPKE_ENC_LENGTH = HPKE_ENC_LENGTH;
+exports.HPKE_OVERHEAD_LENGTH = HPKE_OVERHEAD_LENGTH;
+exports.HpkeError = HpkeError;
+exports.HpkeErrorCode = HpkeErrorCode;
 exports.HttpTransport = HttpTransport;
 exports.KELVIN_PER_RLO = KELVIN_PER_RLO;
 exports.Keypair = Keypair;
@@ -8577,14 +10147,18 @@ exports.RIALO_LOCALNET_CHAIN = RIALO_LOCALNET_CHAIN;
 exports.RIALO_MAINNET_CHAIN = RIALO_MAINNET_CHAIN;
 exports.RIALO_SHITNET_CHAIN = RIALO_SHITNET_CHAIN;
 exports.RIALO_TESTNET_CHAIN = RIALO_TESTNET_CHAIN;
+exports.RexValue = RexValue;
+exports.RexValueVariant = RexValueVariant;
 exports.RialoClient = RialoClient;
 exports.RialoError = RialoError;
 exports.RialoErrorType = RialoErrorType;
 exports.RpcError = RpcError;
 exports.RpcErrorCode = RpcErrorCode;
 exports.SECRET_KEY_LENGTH = SECRET_KEY_LENGTH;
+exports.SECRET_SHARING_HPKE_INFO = SECRET_SHARING_HPKE_INFO;
 exports.SIGNATURE_LENGTH = SIGNATURE_LENGTH;
 exports.SYSTEM_PROGRAM_ID = SYSTEM_PROGRAM_ID;
+exports.Schema = Schema;
 exports.Signature = Signature;
 exports.SystemInstruction = SystemInstruction;
 exports.Transaction = Transaction;
@@ -8597,6 +10171,8 @@ exports.URL_LOCALNET = URL_LOCALNET;
 exports.URL_MAINNET = URL_MAINNET;
 exports.URL_SHITNET = URL_SHITNET;
 exports.URL_TESTNET = URL_TESTNET;
+exports.USER_SECRET_AAD = USER_SECRET_AAD;
+exports.X25519_PUBLIC_KEY_LENGTH = X25519_PUBLIC_KEY_LENGTH;
 exports.allocateInstruction = allocateInstruction;
 exports.assignInstruction = assignInstruction;
 exports.calculateBackoff = calculateBackoff;
@@ -8604,17 +10180,33 @@ exports.concatBytes = concatBytes2;
 exports.createAccount = createAccount;
 exports.createBorshInstruction = createBorshInstruction;
 exports.createRialoClient = createRialoClient;
+exports.deserialize = deserialize;
+exports.deserializeBorsh = deserializeBorsh;
+exports.deserializeCompactU16 = deserializeCompactU162;
+exports.deserializeStrict = deserializeStrict;
 exports.encodeBorshData = encodeBorshData;
+exports.encryptForRex = encryptForRex;
+exports.field = field;
+exports.fixedArray = fixedArray;
 exports.fromBase64 = fromBase64;
+exports.getCiphertextLength = getCiphertextLength;
 exports.getDefaultRialoClientConfig = getDefaultRialoClientConfig;
 exports.getDevnetUrl = getDevnetUrl;
 exports.getLocalnetUrl = getLocalnetUrl;
 exports.getMainnetUrl = getMainnetUrl;
 exports.getTestnetUrl = getTestnetUrl;
+exports.hpkeEncrypt = hpkeEncrypt;
 exports.isOnCurve = isOnCurve;
+exports.isValidCiphertextLength = isValidCiphertextLength;
+exports.option = option;
 exports.seedToBytes = seedToBytes;
+exports.serialize = serialize;
+exports.serializeBorsh = serializeBorsh;
+exports.serializeCompactU16 = serializeCompactU16;
 exports.sleep = sleep;
 exports.toBase64 = toBase64;
 exports.transferInstruction = transferInstruction;
+exports.vec = vec;
+exports.writeCompactU16 = writeCompactU16;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map