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

package/dist/index.mjs

@@ -5736,9 +5736,7 @@ var QueryRpcClient = class extends BaseRpcClient {
    * ```
    */
   async getAccountInfo(pubkey) {
-    const result = await this.call("getAccountInfo", [
-      { address: pubkey.toString(), config: { encoding: "base64" } }
-    ]);
+    const result = await this.call("getAccountInfo", [{ address: pubkey.toString() }]);
     if (!result.value) {
       return null;
     }
@@ -6026,10 +6024,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 {
@@ -6796,189 +6793,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`
+      );
+    }
   }
 };
 
@@ -7140,12 +7167,12 @@ var BincodeWriter = class {
   writeVariant(index) {
     return this.writeU32(index);
   }
-  writeOption(value, writeValue) {
+  writeOption(value, writeValue2) {
     if (value === null || value === void 0) {
       this.writeU8(0);
     } else {
       this.writeU8(1);
-      writeValue(this, value);
+      writeValue2(this, value);
     }
     return this;
   }
@@ -7168,11 +7195,11 @@ var BincodeWriter = class {
     }
     return this;
   }
-  writeMap(map, writeKey, writeValue) {
+  writeMap(map, writeKey, writeValue2) {
     this.writeU64(BigInt(map.size));
     for (const [key, value] of map) {
       writeKey(this, key);
-      writeValue(this, value);
+      writeValue2(this, value);
     }
     return this;
   }
@@ -7225,41 +7252,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);
       }
@@ -7282,6 +7664,39 @@ var writeBigUint64Le = (bigIntOrNumber, buf, offset) => {
   buf[offset + 6] = hi >>> 16;
   buf[offset + 7] = hi >>> 24;
 };
+var readBigUInt64LE = (buf, offset) => {
+  const first = buf[offset];
+  const last = buf[offset + 7];
+  if (first === void 0 || last === void 0)
+    throw new Error("Out of bounds");
+  let lo = (first | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24) >>> 0;
+  let hi = (buf[offset + 4] | buf[offset + 5] << 8 | buf[offset + 6] << 16 | last << 24) >>> 0;
+  if (hi > 0) {
+    return BigInt(lo) + (BigInt(hi) << 32n);
+  }
+  return BigInt(lo);
+};
+function readUIntLE(buf, offset, width) {
+  const hex = arrayToHex(buf.subarray(offset, offset + width), true);
+  if (hex.length === 0) {
+    return BigInt(0);
+  }
+  return BigInt(`0x${hex}`);
+}
+var readUInt32LE = (buffer, offset) => {
+  const first = buffer[offset];
+  const last = buffer[offset + 3];
+  if (first === void 0 || last === void 0)
+    throw new Error("Out of bounds");
+  return first + buffer[offset + 1] * 2 ** 8 + buffer[offset + 2] * 2 ** 16 + last * 2 ** 24;
+};
+var readUInt16LE = (buffer, offset) => {
+  const first = buffer[offset];
+  const last = buffer[offset + 1];
+  if (first === void 0 || last === void 0)
+    throw new Error("Out of bounds");
+  return first + last * 2 ** 8;
+};
 var checkInt = (value, min, max, byteLength) => {
   if (value > max || value < min) {
     const n = "";
@@ -7532,6 +7947,205 @@ var BinaryWriter = class _BinaryWriter {
     return this._buf;
   }
 };
+var BinaryReader = class _BinaryReader {
+  constructor(buf) {
+    this._buf = buf;
+    this._offset = 0;
+  }
+  bool() {
+    return _BinaryReader.bool(this);
+  }
+  static bool(reader) {
+    const value = reader._buf[reader._offset];
+    reader._offset += 1;
+    if (value !== 1 && value !== 0) {
+      throw new BorshError("Unexpected value for boolean: " + value + ". Expecting either 1 or 0 ");
+    }
+    return value ? true : false;
+  }
+  u8() {
+    return _BinaryReader.u8(this);
+  }
+  static u8(reader) {
+    if (reader._offset >= reader._buf.length) {
+      throw new BorshError("Reader out of bounds");
+    }
+    const value = reader._buf[reader._offset];
+    reader._offset += 1;
+    return value;
+  }
+  u16() {
+    return _BinaryReader.u16(this);
+  }
+  static u16(reader) {
+    const value = readUInt16LE(reader._buf, reader._offset);
+    reader._offset += 2;
+    return value;
+  }
+  u32() {
+    return _BinaryReader.u32(this);
+  }
+  static u32(reader) {
+    const value = readUInt32LE(reader._buf, reader._offset);
+    reader._offset += 4;
+    return value;
+  }
+  u64() {
+    return _BinaryReader.u64(this);
+  }
+  static u64(reader) {
+    const value = readBigUInt64LE(reader._buf, reader._offset);
+    reader._offset += 8;
+    return value;
+  }
+  u128() {
+    return _BinaryReader.u128(this);
+  }
+  static u128(reader) {
+    const value = readUIntLE(reader._buf, reader._offset, 16);
+    reader._offset += 16;
+    return value;
+  }
+  u256() {
+    return _BinaryReader.u256(this);
+  }
+  static u256(reader) {
+    const value = readUIntLE(reader._buf, reader._offset, 32);
+    reader._offset += 32;
+    return value;
+  }
+  u512() {
+    return _BinaryReader.u512(this);
+  }
+  static u512(reader) {
+    const buf = reader.buffer(64);
+    return toBigIntLE(buf);
+  }
+  f32() {
+    return _BinaryReader.f32(this);
+  }
+  static f32(reader) {
+    const value = (0, import_float.readFloatLE)(reader._buf, reader._offset);
+    reader._offset += 4;
+    if (Number.isNaN(value)) {
+      throw new BorshError("Recieved NaN reading f32");
+    }
+    return value;
+  }
+  f64() {
+    return _BinaryReader.f64(this);
+  }
+  static f64(reader) {
+    const value = (0, import_float.readDoubleLE)(reader._buf, reader._offset);
+    reader._offset += 8;
+    if (Number.isNaN(value)) {
+      throw new BorshError("Recieved NaN reading f64");
+    }
+    return value;
+  }
+  string() {
+    return _BinaryReader.string(this);
+  }
+  static string(reader) {
+    const len = reader.u32();
+    const end = reader._offset + len;
+    if (end > reader._buf.length) {
+      throw new BorshError("Error decoding UTF-8 string: Invalid length");
+    }
+    try {
+      const string = import_utf8.default.read(reader._buf, reader._offset, end);
+      reader._offset = end;
+      return string;
+    } catch (e) {
+      throw new BorshError(`Error decoding UTF-8 string: ${e}`);
+    }
+  }
+  static bufferString(reader) {
+    const len = reader.u32();
+    const end = reader._offset + len;
+    if (end > reader._buf.length) {
+      throw new BorshError("Error decoding UTF-8 string: Invalid length");
+    }
+    const string = reader._buf.toString(void 0, reader._offset, end);
+    reader._offset = end;
+    return string;
+  }
+  static bufferStringCustom(reader, length) {
+    const len = length(reader);
+    const end = reader._offset + len;
+    if (end > reader._buf.length) {
+      throw new BorshError("Error decoding UTF-8 string: Invalid length");
+    }
+    try {
+      const string = reader._buf.toString(void 0, reader._offset, end);
+      reader._offset = end;
+      return string;
+    } catch (e) {
+      throw new BorshError(`Error decoding UTF-8 string: ${e}`);
+    }
+  }
+  static stringCustom(reader, length) {
+    const len = length(reader);
+    const end = reader._offset + len;
+    if (end > reader._buf.length) {
+      throw new BorshError("Error decoding UTF-8 string: Invalid length");
+    }
+    try {
+      const string = import_utf8.default.read(reader._buf, reader._offset, end);
+      reader._offset = end;
+      return string;
+    } catch (e) {
+      throw new BorshError(`Error decoding UTF-8 string: ${e}`);
+    }
+  }
+  static read(encoding, fromBuffer) {
+    if (encoding === "u8") {
+      return _BinaryReader.u8;
+    } else if (encoding === "u16") {
+      return _BinaryReader.u16;
+    } else if (encoding === "u32") {
+      return _BinaryReader.u32;
+    } else if (encoding === "u64") {
+      return _BinaryReader.u64;
+    } else if (encoding === "u128") {
+      return _BinaryReader.u128;
+    } else if (encoding === "u256") {
+      return _BinaryReader.u256;
+    } else if (encoding === "u512") {
+      return _BinaryReader.u512;
+    } else if (encoding === "string") {
+      return fromBuffer ? _BinaryReader.bufferString : _BinaryReader.string;
+    } else if (encoding === "bool") {
+      return _BinaryReader.bool;
+    } else if (encoding === "f32") {
+      return _BinaryReader.f32;
+    } else if (encoding === "f64") {
+      return _BinaryReader.f64;
+    } else {
+      throw new Error("Unsupported encoding: " + encoding);
+    }
+  }
+  buffer(len) {
+    const end = this._offset + len;
+    const result = this._buf.subarray(this._offset, end);
+    this._offset = end;
+    return result;
+  }
+  uint8Array() {
+    return _BinaryReader.uint8Array(this);
+  }
+  static uint8Array(reader, size = reader.u32()) {
+    return reader.buffer(size);
+  }
+  readArray(fn) {
+    const len = this.u32();
+    const result = new Array(len);
+    for (let i = 0; i < len; ++i) {
+      result[i] = fn();
+    }
+    return result;
+  }
+};
 
 // node_modules/@dao-xyz/borsh/lib/esm/types.js
 var extendingClasses = (clazz) => {
@@ -7570,18 +8184,53 @@ var StringType = class {
 };
 var OptionKind = class extends WrappedType {
 };
+var option = (type) => {
+  return new OptionKind(type);
+};
 var VecKind = class extends WrappedType {
   constructor(elementType, sizeEncoding) {
     super(elementType);
     this.sizeEncoding = sizeEncoding;
   }
 };
+var vec = (type, sizeEncoding = "u32") => {
+  return new VecKind(type, sizeEncoding);
+};
 var FixedArrayKind = class extends WrappedType {
   constructor(type, length) {
     super(type);
     this.length = length;
   }
 };
+var fixedArray = (type, length) => {
+  return new FixedArrayKind(type, length);
+};
+var StructKind = class {
+  constructor(properties) {
+    if (properties) {
+      this.fields = properties.fields;
+      this.variant = properties.variant;
+    } else {
+      this.fields = [];
+    }
+  }
+  getDependencies() {
+    let ret = [];
+    this.fields.forEach((field2, ix) => {
+      if (!field2) {
+        throw new BorshError("Field: " + ix + " is missing specification");
+      }
+      if (field2.type instanceof WrappedType) {
+        let dependency = field2.type.getDependency();
+        if (dependency)
+          ret.push(dependency);
+      } else if (typeof field2.type === "function") {
+        ret.push(field2.type);
+      }
+    });
+    return ret;
+  }
+};
 
 // node_modules/@dao-xyz/borsh/lib/esm/index.js
 var MAX_PROTOTYPE_SEARCH = 250;
@@ -7589,7 +8238,7 @@ var PROTOTYPE_POLLUTION_CONTEXT_RANGE = 500;
 var PROTOTYPE_DESERIALIZATION_HANDLER_OFFSET = 500;
 var PROTOTYPE_DEPENDENCY_HANDLER_OFFSET = PROTOTYPE_DESERIALIZATION_HANDLER_OFFSET + PROTOTYPE_POLLUTION_CONTEXT_RANGE;
 var PROTOTYPE_SCHEMA_OFFSET = PROTOTYPE_DESERIALIZATION_HANDLER_OFFSET + PROTOTYPE_POLLUTION_CONTEXT_RANGE * 2;
-function serialize(obj, writer = new BinaryWriter()) {
+function serialize2(obj, writer = new BinaryWriter()) {
   (obj.constructor._borsh_serialize || (obj.constructor._borsh_serialize = serializeStruct(obj.constructor, true)))(obj, writer);
   return writer.finalize();
 }
@@ -7597,6 +8246,15 @@ function recursiveSerialize(obj, writer = new BinaryWriter()) {
   (obj.constructor._borsh_serialize_recursive || (obj.constructor._borsh_serialize_recursive = serializeStruct(obj.constructor, false)))(obj, writer);
   return writer.finalize();
 }
+function deserialize2(buffer, classType, options) {
+  const reader = new BinaryReader(buffer);
+  let fromBuffer = buffer.constructor !== Uint8Array;
+  const result = deserializeStruct(classType, fromBuffer)(reader, options);
+  if (reader._offset !== buffer.length) {
+    throw new BorshError(`Unexpected ${buffer.length - reader._offset} bytes after deserialized data. This is most likely due to that you are deserializing into the wrong class`);
+  }
+  return result;
+}
 function serializeField(fieldName, fieldType, options) {
   if (typeof fieldType.serialize == "function") {
     return (obj, writer) => fieldType.serialize(obj, writer);
@@ -7717,94 +8375,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) {
@@ -7936,7 +9017,7 @@ var Message = class _Message {
       numReadonlySignedAccounts: data[cursor++],
       numReadonlyUnsignedAccounts: data[cursor++]
     };
-    const [accountKeysLength, newCursor1] = deserializeCompactU162(data, cursor);
+    const [accountKeysLength, newCursor1] = deserializeCompactU16(data, cursor);
     cursor = newCursor1;
     const accountKeys = [];
     for (let i = 0; i < accountKeysLength; i++) {
@@ -7962,7 +9043,7 @@ var Message = class _Message {
       new DataView(validFromBytes.buffer).getBigUint64(0, true)
     );
     cursor += 8;
-    const [instructionsLength, newCursor2] = deserializeCompactU162(
+    const [instructionsLength, newCursor2] = deserializeCompactU16(
       data,
       cursor
     );
@@ -7976,7 +9057,7 @@ var Message = class _Message {
         );
       }
       const programIdIndex = data[cursor++];
-      const [accountIndexesLength, newCursor3] = deserializeCompactU162(
+      const [accountIndexesLength, newCursor3] = deserializeCompactU16(
         data,
         cursor
       );
@@ -7991,7 +9072,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(
@@ -8078,7 +9159,7 @@ var Message = class _Message {
     return this.getSigners().findIndex((signer) => signer.equals(pubkey));
   }
 };
-function deserializeCompactU162(data, currentCursor) {
+function deserializeCompactU16(data, currentCursor) {
   let cursor = currentCursor;
   if (cursor >= data.length) {
     throw new TransactionError(
@@ -8160,7 +9241,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++) {
@@ -8539,6 +9620,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:
@@ -8555,6 +9718,6 @@ var TransactionBuilder = class _TransactionBuilder {
   (*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
 
-export { AccountMetaTable, BASE_DERIVATION_PATH, BaseRpcClient, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, HttpTransport, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, Mnemonic, PUBLIC_KEY_LENGTH, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_SHITNET_CHAIN, RIALO_TESTNET_CHAIN, RialoClient, RialoError, RialoErrorType, RpcError, RpcErrorCode, SECRET_KEY_LENGTH, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, Signature, SystemInstruction, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, TransactionRpcClient, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_SHITNET, URL_TESTNET, allocateInstruction, assignInstruction, calculateBackoff, concatBytes2 as concatBytes, createAccount, createBorshInstruction, createRialoClient, encodeBorshData, fromBase64, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, isOnCurve, seedToBytes, sleep, toBase64, transferInstruction };
+export { AccountMetaTable, BASE_DERIVATION_PATH, BaseRpcClient, BincodeReader, BincodeWriter, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, HttpTransport, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, Mnemonic, PUBLIC_KEY_LENGTH, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_SHITNET_CHAIN, RIALO_TESTNET_CHAIN, RialoClient, RialoError, RialoErrorType, RpcError, RpcErrorCode, SECRET_KEY_LENGTH, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, Schema, Signature, SystemInstruction, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, TransactionRpcClient, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_SHITNET, URL_TESTNET, allocateInstruction, assignInstruction, calculateBackoff, concatBytes2 as concatBytes, createAccount, createBorshInstruction, createRialoClient, deserialize, deserializeBorsh, deserializeCompactU162 as deserializeCompactU16, deserializeStrict, encodeBorshData, field, fixedArray, fromBase64, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, isOnCurve, option, seedToBytes, serialize, serializeBorsh, serializeCompactU16, sleep, toBase64, transferInstruction, vec, writeCompactU16 };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map