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

package/dist/index.js

@@ -5738,9 +5738,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 +6026,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 {
@@ -6798,189 +6795,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;
   }
-  /**
-   * 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;
-    });
+  readF64() {
+    this.ensureAvailable(8);
+    const value = this.view.getFloat64(this.offset, true);
+    this.offset += 8;
+    return value;
   }
-  /**
-   * 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++;
-      }
+  readBool() {
+    const value = this.readU8();
+    if (value > 1) {
+      throw new Error(`Invalid boolean value: ${value}`);
     }
-    return {
-      numRequiredSignatures,
-      numReadonlySignedAccounts,
-      numReadonlyUnsignedAccounts
-    };
+    return value === 1;
   }
-  /**
-   * Get sorted public keys.
-   */
-  getPublicKeys() {
-    return this.getSortedAccounts().map((entry) => entry.pubkey);
+  // ========== Compound Types ==========
+  readBytes(length) {
+    this.ensureAvailable(length);
+    const bytes = this.bytes.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return bytes;
   }
-  /**
-   * Get number of accounts in table.
-   */
-  size() {
-    return this.accounts.size;
+  readFixedArray(length) {
+    return this.readBytes(length);
   }
-};
-
-// 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";
+  readVecBytes() {
+    const length = this.readLength();
+    return this.readBytes(length);
   }
-  static noInstructions() {
-    return new _TransactionError(
-      "NO_INSTRUCTIONS" /* NO_INSTRUCTIONS */,
-      "Transaction must contain at least one instruction. Use addInstruction() to add instructions."
-    );
+  readString() {
+    const bytes = this.readVecBytes();
+    return new TextDecoder().decode(bytes);
   }
-  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 }
-    );
+  readVariant() {
+    return this.readU32();
   }
-  static missingSignature(index, pubkey) {
-    return new _TransactionError(
-      "MISSING_SIGNATURE" /* MISSING_SIGNATURE */,
-      `Missing signature for signer ${index} (${pubkey}). Transaction requires ${index + 1} signatures.`,
-      { index, pubkey }
-    );
+  readOption(readValue2) {
+    const hasValue = this.readU8();
+    if (hasValue === 0) {
+      return null;
+    }
+    if (hasValue !== 1) {
+      throw new Error(`Invalid option discriminant: ${hasValue}`);
+    }
+    return readValue2();
   }
-  static simulationFailed(logs, error) {
-    return new _TransactionError(
-      "SIMULATION_FAILED" /* SIMULATION_FAILED */,
-      `Transaction simulation failed: ${error}`,
-      { logs, error }
-    );
+  readVec(readElement) {
+    const length = this.readLength();
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      result.push(readElement());
+    }
+    return result;
   }
-  static insufficientFunds(required, available) {
-    return new _TransactionError(
-      "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */,
-      `Insufficient funds: need ${required}, have ${available}`,
-      { required: required.toString(), available: available.toString() }
-    );
+  /**
+   * Read a tuple of fixed size with heterogeneous types
+   */
+  readTuple(readers) {
+    return readers.map((read) => read());
   }
-  toJSON() {
-    return {
-      code: this.code,
-      message: this.message,
-      details: this.details
-    };
+  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 ==========
+  /**
+   * Read length as u64 but validate it's within safe integer range
+   */
+  readLength() {
+    const length = this.readU64();
+    if (length > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`Length ${length} exceeds maximum safe integer`);
+    }
+    const numLength = Number(length);
+    if (numLength > this.remaining()) {
+      throw new Error(
+        `Length ${numLength} exceeds remaining bytes ${this.remaining()}`
+      );
+    }
+    return numLength;
+  }
+  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 +7169,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 +7197,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,41 +7254,396 @@ var BincodeWriter = class {
   }
 };
 
-// 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 writeBufferLEBigInt(num, width, buffer, offset) {
-  const hex = num.toString(16);
-  const padded = hex.padStart(width * 2, "0").slice(0, width * 2);
-  for (const [ix, value] of padded.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)).entries()) {
-    buffer[offset + width - 1 - ix] = value;
-  }
+// 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 writeUInt32LE(value, buf, offset) {
-  checkInt(value, 0, 4294967295, 3);
-  buf[offset] = value;
-  buf[offset + 1] = value >>> 8;
-  buf[offset + 2] = value >>> 16;
-  buf[offset + 3] = value >>> 24;
+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 writeUInt16LE(value, buf, offset) {
-  checkInt(value, 0, 65535, 1);
-  buf[offset] = value;
-  buf[offset + 1] = value >>> 8;
+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;
 }
-var writeBigUint64Le = (bigIntOrNumber, buf, offset) => {
-  let lo, hi;
-  if (typeof bigIntOrNumber === "bigint") {
-    if (bigIntOrNumber <= Number.MAX_SAFE_INTEGER) {
-      if (bigIntOrNumber < 0) {
-        throw new Error("u64 value can not negative, got " + bigIntOrNumber);
-      }
-      bigIntOrNumber = Number(bigIntOrNumber);
-      lo = bigIntOrNumber >>> 0;
-      hi = (bigIntOrNumber - lo) / 4294967296;
-    } else {
+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);
+  for (const [ix, value] of padded.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)).entries()) {
+    buffer[offset + width - 1 - ix] = value;
+  }
+}
+function writeUInt32LE(value, buf, offset) {
+  checkInt(value, 0, 4294967295, 3);
+  buf[offset] = value;
+  buf[offset + 1] = value >>> 8;
+  buf[offset + 2] = value >>> 16;
+  buf[offset + 3] = value >>> 24;
+}
+function writeUInt16LE(value, buf, offset) {
+  checkInt(value, 0, 65535, 1);
+  buf[offset] = value;
+  buf[offset + 1] = value >>> 8;
+}
+var writeBigUint64Le = (bigIntOrNumber, buf, offset) => {
+  let lo, hi;
+  if (typeof bigIntOrNumber === "bigint") {
+    if (bigIntOrNumber <= Number.MAX_SAFE_INTEGER) {
+      if (bigIntOrNumber < 0) {
+        throw new Error("u64 value can not negative, got " + bigIntOrNumber);
+      }
+      bigIntOrNumber = Number(bigIntOrNumber);
+      lo = bigIntOrNumber >>> 0;
+      hi = (bigIntOrNumber - lo) / 4294967296;
+    } else {
       if (bigIntOrNumber > 18446744073709551615n) {
         throw new Error("u64 value can exceed mav value got " + bigIntOrNumber);
       }
@@ -7284,6 +7666,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 +7949,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 +8186,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 +8240,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 +8248,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 +8377,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) {
@@ -7938,7 +9019,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 +9045,7 @@ var Message = class _Message {
       new DataView(validFromBytes.buffer).getBigUint64(0, true)
     );
     cursor += 8;
-    const [instructionsLength, newCursor2] = deserializeCompactU162(
+    const [instructionsLength, newCursor2] = deserializeCompactU16(
       data,
       cursor
     );
@@ -7978,7 +9059,7 @@ var Message = class _Message {
         );
       }
       const programIdIndex = data[cursor++];
-      const [accountIndexesLength, newCursor3] = deserializeCompactU162(
+      const [accountIndexesLength, newCursor3] = deserializeCompactU16(
         data,
         cursor
       );
@@ -7993,7 +9074,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(
@@ -8080,7 +9161,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 +9243,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++) {
@@ -8541,6 +9622,88 @@ var TransactionBuilder = class _TransactionBuilder {
     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,6 +9723,8 @@ var TransactionBuilder = class _TransactionBuilder {
 exports.AccountMetaTable = AccountMetaTable;
 exports.BASE_DERIVATION_PATH = BASE_DERIVATION_PATH;
 exports.BaseRpcClient = BaseRpcClient;
+exports.BincodeReader = BincodeReader;
+exports.BincodeWriter = BincodeWriter;
 exports.CryptoError = CryptoError;
 exports.CryptoErrorCode = CryptoErrorCode;
 exports.DEFAULT_NUM_ACCOUNTS = DEFAULT_NUM_ACCOUNTS;
@@ -8585,6 +9750,7 @@ exports.RpcErrorCode = RpcErrorCode;
 exports.SECRET_KEY_LENGTH = SECRET_KEY_LENGTH;
 exports.SIGNATURE_LENGTH = SIGNATURE_LENGTH;
 exports.SYSTEM_PROGRAM_ID = SYSTEM_PROGRAM_ID;
+exports.Schema = Schema;
 exports.Signature = Signature;
 exports.SystemInstruction = SystemInstruction;
 exports.Transaction = Transaction;
@@ -8604,7 +9770,13 @@ 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.field = field;
+exports.fixedArray = fixedArray;
 exports.fromBase64 = fromBase64;
 exports.getDefaultRialoClientConfig = getDefaultRialoClientConfig;
 exports.getDevnetUrl = getDevnetUrl;
@@ -8612,9 +9784,15 @@ exports.getLocalnetUrl = getLocalnetUrl;
 exports.getMainnetUrl = getMainnetUrl;
 exports.getTestnetUrl = getTestnetUrl;
 exports.isOnCurve = isOnCurve;
+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