@rialo/ts-cdk 0.1.2 → 0.1.4

package/dist/index.js

@@ -451,17 +451,36 @@ var RialoError = class _RialoError extends Error {
 
 // src/constants.ts
 var DEFAULT_NUM_ACCOUNTS = 1;
-var URL_MAINNET = "https://mainnet.rialo.io:4100";
-var URL_TESTNET = "https://testnet.rialo.io:4100";
+var URL_MAINNET = "https://mainnet.rialo.io:4101";
+var URL_TESTNET = "https://testnet.rialo.io:4101";
 var URL_DEVNET = "https://devnet.rialo.io:4101";
 var URL_LOCALNET = "http://localhost:4100";
+var RIALO_MAINNET_CHAIN = {
+  id: "rialo:mainnet",
+  name: "Mainnet",
+  rpcUrl: URL_MAINNET
+};
+var RIALO_TESTNET_CHAIN = {
+  id: "rialo:testnet",
+  name: "Testnet",
+  rpcUrl: URL_TESTNET
+};
+var RIALO_DEVNET_CHAIN = {
+  id: "rialo:devnet",
+  name: "Devnet",
+  rpcUrl: URL_DEVNET
+};
+var RIALO_LOCALNET_CHAIN = {
+  id: "rialo:localnet",
+  name: "Localhost",
+  rpcUrl: URL_LOCALNET
+};
 var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
 var BASE_DERIVATION_PATH = "m/44'/756'/";
 var KELVIN_PER_RLO = 1e9;
 var PUBLIC_KEY_LENGTH = 32;
 var SECRET_KEY_LENGTH = 32;
 var SIGNATURE_LENGTH = 64;
-var BLOCKHASH_LENGTH = 32;
 
 // src/transaction/account-meta-table.ts
 var AccountMetaTable = class {
@@ -1223,395 +1242,43 @@ function encodeBorshData(_schema) {
   throw new Error("Use class-based Borsh serialization with decorators");
 }
 
-// node_modules/@scure/base/index.js
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function isArrayOf(isString, arr) {
-  if (!Array.isArray(arr))
-    return false;
-  if (arr.length === 0)
-    return true;
-  if (isString) {
-    return arr.every((item) => typeof item === "string");
-  } else {
-    return arr.every((item) => Number.isSafeInteger(item));
+// src/crypto/errors.ts
+var CryptoErrorCode = /* @__PURE__ */ ((CryptoErrorCode2) => {
+  CryptoErrorCode2["INVALID_KEY_LENGTH"] = "INVALID_KEY_LENGTH";
+  CryptoErrorCode2["INVALID_SIGNATURE"] = "INVALID_SIGNATURE";
+  CryptoErrorCode2["INVALID_PUBLIC_KEY"] = "INVALID_PUBLIC_KEY";
+  CryptoErrorCode2["INVALID_BLOCKHASH"] = "INVALID_BLOCKHASH";
+  CryptoErrorCode2["INVALID_MNEMONIC"] = "INVALID_MNEMONIC";
+  CryptoErrorCode2["KEY_DERIVATION_FAILED"] = "KEY_DERIVATION_FAILED";
+  CryptoErrorCode2["KEYPAIR_DISPOSED"] = "KEYPAIR_DISPOSED";
+  return CryptoErrorCode2;
+})(CryptoErrorCode || {});
+var CryptoError = class _CryptoError extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "CryptoError";
+    this.code = code;
+    this.details = details;
   }
-}
-function afn(input) {
-  if (typeof input !== "function")
-    throw new Error("function expected");
-  return true;
-}
-function astr(label, input) {
-  if (typeof input !== "string")
-    throw new Error(`${label}: string expected`);
-  return true;
-}
-function anumber(n) {
-  if (!Number.isSafeInteger(n))
-    throw new Error(`invalid integer: ${n}`);
-}
-function aArr(input) {
-  if (!Array.isArray(input))
-    throw new Error("array expected");
-}
-function astrArr(label, input) {
-  if (!isArrayOf(true, input))
-    throw new Error(`${label}: array of strings expected`);
-}
-function anumArr(label, input) {
-  if (!isArrayOf(false, input))
-    throw new Error(`${label}: array of numbers expected`);
-}
-// @__NO_SIDE_EFFECTS__
-function chain(...args) {
-  const id = (a) => a;
-  const wrap = (a, b) => (c) => a(b(c));
-  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
-  const decode = args.map((x) => x.decode).reduce(wrap, id);
-  return { encode, decode };
-}
-// @__NO_SIDE_EFFECTS__
-function alphabet(letters) {
-  const lettersA = typeof letters === "string" ? letters.split("") : letters;
-  const len = lettersA.length;
-  astrArr("alphabet", lettersA);
-  const indexes = new Map(lettersA.map((l, i) => [l, i]));
-  return {
-    encode: (digits) => {
-      aArr(digits);
-      return digits.map((i) => {
-        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
-          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
-        return lettersA[i];
-      });
-    },
-    decode: (input) => {
-      aArr(input);
-      return input.map((letter) => {
-        astr("alphabet.decode", letter);
-        const i = indexes.get(letter);
-        if (i === void 0)
-          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
-        return i;
-      });
-    }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function join(separator = "") {
-  astr("join", separator);
-  return {
-    encode: (from) => {
-      astrArr("join.decode", from);
-      return from.join(separator);
-    },
-    decode: (to) => {
-      astr("join.decode", to);
-      return to.split(separator);
-    }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function padding(bits, chr = "=") {
-  anumber(bits);
-  astr("padding", chr);
-  return {
-    encode(data) {
-      astrArr("padding.encode", data);
-      while (data.length * bits % 8)
-        data.push(chr);
-      return data;
-    },
-    decode(input) {
-      astrArr("padding.decode", input);
-      let end = input.length;
-      if (end * bits % 8)
-        throw new Error("padding: invalid, string should have whole number of bytes");
-      for (; end > 0 && input[end - 1] === chr; end--) {
-        const last = end - 1;
-        const byte = last * bits;
-        if (byte % 8 === 0)
-          throw new Error("padding: invalid, string has too much padding");
-      }
-      return input.slice(0, end);
-    }
-  };
-}
-function convertRadix(data, from, to) {
-  if (from < 2)
-    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
-  if (to < 2)
-    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
-  aArr(data);
-  if (!data.length)
-    return [];
-  let pos = 0;
-  const res = [];
-  const digits = Array.from(data, (d) => {
-    anumber(d);
-    if (d < 0 || d >= from)
-      throw new Error(`invalid integer: ${d}`);
-    return d;
-  });
-  const dlen = digits.length;
-  while (true) {
-    let carry = 0;
-    let done = true;
-    for (let i = pos; i < dlen; i++) {
-      const digit = digits[i];
-      const fromCarry = from * carry;
-      const digitBase = fromCarry + digit;
-      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
-        throw new Error("convertRadix: carry overflow");
-      }
-      const div = digitBase / to;
-      carry = digitBase % to;
-      const rounded = Math.floor(div);
-      digits[i] = rounded;
-      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
-        throw new Error("convertRadix: carry overflow");
-      if (!done)
-        continue;
-      else if (!rounded)
-        pos = i;
-      else
-        done = false;
-    }
-    res.push(carry);
-    if (done)
-      break;
+  static invalidKeyLength(expected, actual) {
+    return new _CryptoError(
+      "INVALID_KEY_LENGTH" /* INVALID_KEY_LENGTH */,
+      `Invalid key length: expected ${expected} bytes, got ${actual} bytes`,
+      { expected, actual }
+    );
   }
-  for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
-    res.push(0);
-  return res.reverse();
-}
-var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
-var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
-var powers = /* @__PURE__ */ (() => {
-  let res = [];
-  for (let i = 0; i < 40; i++)
-    res.push(2 ** i);
-  return res;
-})();
-function convertRadix2(data, from, to, padding2) {
-  aArr(data);
-  if (from <= 0 || from > 32)
-    throw new Error(`convertRadix2: wrong from=${from}`);
-  if (to <= 0 || to > 32)
-    throw new Error(`convertRadix2: wrong to=${to}`);
-  if (/* @__PURE__ */ radix2carry(from, to) > 32) {
-    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+  static invalidMnemonic(reason) {
+    const message = reason ? `Invalid mnemonic: ${reason}` : "Invalid mnemonic phrase. Check that all words are valid and in the correct order.";
+    return new _CryptoError("INVALID_MNEMONIC" /* INVALID_MNEMONIC */, message);
   }
-  let carry = 0;
-  let pos = 0;
-  const max = powers[from];
-  const mask = powers[to] - 1;
-  const res = [];
-  for (const n of data) {
-    anumber(n);
-    if (n >= max)
-      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
-    carry = carry << from | n;
-    if (pos + from > 32)
-      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
-    pos += from;
-    for (; pos >= to; pos -= to)
-      res.push((carry >> pos - to & mask) >>> 0);
-    const pow = powers[pos];
-    if (pow === void 0)
-      throw new Error("invalid carry");
-    carry &= pow - 1;
-  }
-  carry = carry << to - pos & mask;
-  if (!padding2 && pos >= from)
-    throw new Error("Excess padding");
-  if (!padding2 && carry > 0)
-    throw new Error(`Non-zero padding: ${carry}`);
-  if (padding2 && pos > 0)
-    res.push(carry >>> 0);
-  return res;
-}
-// @__NO_SIDE_EFFECTS__
-function radix(num) {
-  anumber(num);
-  const _256 = 2 ** 8;
-  return {
-    encode: (bytes) => {
-      if (!isBytes(bytes))
-        throw new Error("radix.encode input should be Uint8Array");
-      return convertRadix(Array.from(bytes), _256, num);
-    },
-    decode: (digits) => {
-      anumArr("radix.decode", digits);
-      return Uint8Array.from(convertRadix(digits, num, _256));
-    }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function radix2(bits, revPadding = false) {
-  anumber(bits);
-  if (bits <= 0 || bits > 32)
-    throw new Error("radix2: bits should be in (0..32]");
-  if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
-    throw new Error("radix2: carry overflow");
-  return {
-    encode: (bytes) => {
-      if (!isBytes(bytes))
-        throw new Error("radix2.encode input should be Uint8Array");
-      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
-    },
-    decode: (digits) => {
-      anumArr("radix2.decode", digits);
-      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
-    }
-  };
-}
-function checksum(len, fn) {
-  anumber(len);
-  afn(fn);
-  return {
-    encode(data) {
-      if (!isBytes(data))
-        throw new Error("checksum.encode: input should be Uint8Array");
-      const sum = fn(data).slice(0, len);
-      const res = new Uint8Array(data.length + len);
-      res.set(data);
-      res.set(sum, data.length);
-      return res;
-    },
-    decode(data) {
-      if (!isBytes(data))
-        throw new Error("checksum.decode: input should be Uint8Array");
-      const payload = data.slice(0, -len);
-      const oldChecksum = data.slice(-len);
-      const newChecksum = fn(payload).slice(0, len);
-      for (let i = 0; i < len; i++)
-        if (newChecksum[i] !== oldChecksum[i])
-          throw new Error("Invalid checksum");
-      return payload;
-    }
-  };
-}
-var utils = {
-  alphabet,
-  chain,
-  checksum,
-  convertRadix,
-  convertRadix2,
-  radix,
-  radix2,
-  join,
-  padding
-};
-var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join(""));
-var base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
-
-// src/crypto/blockhash.ts
-var Blockhash = class _Blockhash {
-  bytes;
-  constructor(bytes) {
-    if (bytes.length !== BLOCKHASH_LENGTH) {
-      throw CryptoError.invalidKeyLength(BLOCKHASH_LENGTH, bytes.length);
-    }
-    this.bytes = new Uint8Array(bytes);
-  }
-  /**
-   * Creates a Blockhash from raw bytes.
-   *
-   * @param bytes - 32-byte blockhash
-   * @throws {CryptoError} If bytes length is not 32
-   */
-  static fromBytes(bytes) {
-    return new _Blockhash(bytes);
-  }
-  /**
-   * Creates a Blockhash from a base58-encoded string.
-   *
-   * @param str - Base58-encoded blockhash
-   * @throws {CryptoError} If string is invalid or decodes to wrong length
-   */
-  static fromString(str) {
-    try {
-      const bytes = base58.decode(str);
-      return new _Blockhash(bytes);
-    } catch (error) {
-      throw new CryptoError(
-        "INVALID_BLOCKHASH" /* INVALID_BLOCKHASH */,
-        `Invalid base58 blockhash: ${error instanceof Error ? error.message : "unknown error"}`,
-        { input: str }
-      );
-    }
-  }
-  /**
-   * Returns a copy of the raw bytes.
-   */
-  toBytes() {
-    return new Uint8Array(this.bytes);
-  }
-  /**
-   * Returns the base58-encoded string representation.
-   */
-  toString() {
-    return base58.encode(this.bytes);
-  }
-  /**
-   * Checks equality with another blockhash using constant-time comparison.
-   */
-  equals(other) {
-    if (!other) return false;
-    if (this.bytes.length !== other.bytes.length) return false;
-    for (let i = 0; i < this.bytes.length; i++) {
-      if (this.bytes[i] !== other.bytes[i]) return false;
-    }
-    return true;
-  }
-  /**
-   * JSON serialization (returns base58 string).
-   */
-  toJSON() {
-    return this.toString();
-  }
-};
-
-// src/crypto/errors.ts
-var CryptoErrorCode = /* @__PURE__ */ ((CryptoErrorCode2) => {
-  CryptoErrorCode2["INVALID_KEY_LENGTH"] = "INVALID_KEY_LENGTH";
-  CryptoErrorCode2["INVALID_SIGNATURE"] = "INVALID_SIGNATURE";
-  CryptoErrorCode2["INVALID_PUBLIC_KEY"] = "INVALID_PUBLIC_KEY";
-  CryptoErrorCode2["INVALID_BLOCKHASH"] = "INVALID_BLOCKHASH";
-  CryptoErrorCode2["INVALID_MNEMONIC"] = "INVALID_MNEMONIC";
-  CryptoErrorCode2["KEY_DERIVATION_FAILED"] = "KEY_DERIVATION_FAILED";
-  CryptoErrorCode2["KEYPAIR_DISPOSED"] = "KEYPAIR_DISPOSED";
-  return CryptoErrorCode2;
-})(CryptoErrorCode || {});
-var CryptoError = class _CryptoError extends Error {
-  code;
-  details;
-  constructor(code, message, details) {
-    super(message);
-    this.name = "CryptoError";
-    this.code = code;
-    this.details = details;
-  }
-  static invalidKeyLength(expected, actual) {
-    return new _CryptoError(
-      "INVALID_KEY_LENGTH" /* INVALID_KEY_LENGTH */,
-      `Invalid key length: expected ${expected} bytes, got ${actual} bytes`,
-      { expected, actual }
-    );
-  }
-  static invalidMnemonic(reason) {
-    const message = reason ? `Invalid mnemonic: ${reason}` : "Invalid mnemonic phrase. Check that all words are valid and in the correct order.";
-    return new _CryptoError("INVALID_MNEMONIC" /* INVALID_MNEMONIC */, message);
-  }
-  static keyDerivationFailed(path, cause) {
-    return new _CryptoError(
-      "KEY_DERIVATION_FAILED" /* KEY_DERIVATION_FAILED */,
-      `Failed to derive key at path: ${path}`,
-      { path, cause: cause?.message }
-    );
+  static keyDerivationFailed(path, cause) {
+    return new _CryptoError(
+      "KEY_DERIVATION_FAILED" /* KEY_DERIVATION_FAILED */,
+      `Failed to derive key at path: ${path}`,
+      { path, cause: cause?.message }
+    );
   }
   static keypairDisposed() {
     return new _CryptoError(
@@ -1646,9 +1313,9 @@ var err = (message = "") => {
 };
 var isBig = (n) => typeof n === "bigint";
 var isStr = (s) => typeof s === "string";
-var isBytes2 = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+var isBytes = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 var abytes = (value, length, title = "") => {
-  const bytes = isBytes2(value);
+  const bytes = isBytes(value);
   const len = value?.length;
   const needsLen = length !== void 0;
   if (!bytes || needsLen && len !== length) {
@@ -2102,17 +1769,17 @@ var wNAF = (n) => {
 };
 
 // node_modules/@noble/hashes/utils.js
-function isBytes3(a) {
+function isBytes2(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
-function anumber2(n, title = "") {
+function anumber(n, title = "") {
   if (!Number.isSafeInteger(n) || n < 0) {
     const prefix = title && `"${title}" `;
     throw new Error(`${prefix}expected integer >0, got ${n}`);
   }
 }
 function abytes2(value, length, title = "") {
-  const bytes = isBytes3(value);
+  const bytes = isBytes2(value);
   const len = value?.length;
   const needsLen = length !== void 0;
   if (!bytes || needsLen && len !== length) {
@@ -2126,8 +1793,8 @@ function abytes2(value, length, title = "") {
 function ahash(h2) {
   if (typeof h2 !== "function" || typeof h2.create !== "function")
     throw new Error("Hash must wrapped by utils.createHasher");
-  anumber2(h2.outputLen);
-  anumber2(h2.blockLen);
+  anumber(h2.outputLen);
+  anumber(h2.blockLen);
 }
 function aexists(instance, checkFinished = true) {
   if (instance.destroyed)
@@ -2527,106 +2194,391 @@ var sha512 = /* @__PURE__ */ createHasher(
   /* @__PURE__ */ oidNist(3)
 );
 
-// src/crypto/public-key.ts
-var PublicKey = class _PublicKey {
-  bytes;
-  constructor(bytes) {
-    if (bytes.length !== PUBLIC_KEY_LENGTH) {
-      throw CryptoError.invalidKeyLength(PUBLIC_KEY_LENGTH, bytes.length);
-    }
-    this.bytes = new Uint8Array(bytes);
-  }
-  /**
-   * Creates a PublicKey from raw bytes.
-   *
-   * @param bytes - 32-byte Ed25519 public key
-   * @throws {CryptoError} If bytes length is not 32
-   */
-  static fromBytes(bytes) {
-    return new _PublicKey(bytes);
-  }
-  /**
-   * Creates a PublicKey from a base58-encoded string.
-   *
-   * @param str - Base58-encoded public key
-   * @throws {CryptoError} If string is invalid or decodes to wrong length
-   */
-  static fromString(str) {
-    try {
-      const bytes = base58.decode(str);
-      return new _PublicKey(bytes);
-    } catch (error) {
-      throw new CryptoError(
-        "INVALID_PUBLIC_KEY" /* INVALID_PUBLIC_KEY */,
-        `Invalid base58 public key: ${error instanceof Error ? error.message : "unknown error"}`,
-        { input: str }
-      );
-    }
-  }
-  /**
-   * Returns a copy of the raw bytes.
-   */
-  toBytes() {
-    return new Uint8Array(this.bytes);
-  }
-  /**
-   * Returns the base58-encoded string representation.
-   */
-  toString() {
-    return base58.encode(this.bytes);
-  }
-  /**
-   * Checks equality with another public key using constant-time comparison.
-   */
-  equals(other) {
-    if (!other) return false;
-    if (this.bytes.length !== other.bytes.length) return false;
-    for (let i = 0; i < this.bytes.length; i++) {
-      if (this.bytes[i] !== other.bytes[i]) return false;
-    }
+// node_modules/@scure/base/index.js
+function isBytes3(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
     return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
   }
-  /**
-   * Verifies an Ed25519 signature over a message.
-   *
-   * @param message - Message bytes that were signed
-   * @param signature - Signature to verify
-   * @returns True if signature is valid, false otherwise
-   *
-   * @example
-   * ```typescript
-   * const message = new Uint8Array([1, 2, 3]);
-   * const signature = keypair.sign(message);
-   * const isValid = keypair.publicKey.verify(message, signature);
-   * ```
-   */
-  verify(message, signature) {
-    return verify(
-      signature.toBytes(),
-      message,
-      this.bytes
-    );
-  }
-  /**
-   * JSON serialization (returns base58 string).
-   */
-  toJSON() {
-    return this.toString();
-  }
-};
-
-// src/crypto/signature.ts
-var Signature = class _Signature {
-  bytes;
-  constructor(bytes) {
-    if (bytes.length !== SIGNATURE_LENGTH) {
-      throw CryptoError.invalidKeyLength(SIGNATURE_LENGTH, bytes.length);
-    }
-    this.bytes = new Uint8Array(bytes);
-  }
-  /**
-   * Creates a Signature from raw bytes.
-   *
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber2(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode };
+}
+// @__NO_SIDE_EFFECTS__
+function alphabet(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === void 0)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function padding(bits, chr = "=") {
+  anumber2(bits);
+  astr("padding", chr);
+  return {
+    encode(data) {
+      astrArr("padding.encode", data);
+      while (data.length * bits % 8)
+        data.push(chr);
+      return data;
+    },
+    decode(input) {
+      astrArr("padding.decode", input);
+      let end = input.length;
+      if (end * bits % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (; end > 0 && input[end - 1] === chr; end--) {
+        const last = end - 1;
+        const byte = last * bits;
+        if (byte % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      }
+      return input.slice(0, end);
+    }
+  };
+}
+function convertRadix(data, from, to) {
+  if (from < 2)
+    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d) => {
+    anumber2(d);
+    if (d < 0 || d >= from)
+      throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i = pos; i < dlen; i++) {
+      const digit = digits[i];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
+    res.push(0);
+  return res.reverse();
+}
+var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i = 0; i < 40; i++)
+    res.push(2 ** i);
+  return res;
+})();
+function convertRadix2(data, from, to, padding2) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (/* @__PURE__ */ radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber2(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (; pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === void 0)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding2 && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding2 && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding2 && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+// @__NO_SIDE_EFFECTS__
+function radix(num) {
+  anumber2(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes) => {
+      if (!isBytes3(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function radix2(bits, revPadding = false) {
+  anumber2(bits);
+  if (bits <= 0 || bits > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes3(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function checksum(len, fn) {
+  anumber2(len);
+  afn(fn);
+  return {
+    encode(data) {
+      if (!isBytes3(data))
+        throw new Error("checksum.encode: input should be Uint8Array");
+      const sum = fn(data).slice(0, len);
+      const res = new Uint8Array(data.length + len);
+      res.set(data);
+      res.set(sum, data.length);
+      return res;
+    },
+    decode(data) {
+      if (!isBytes3(data))
+        throw new Error("checksum.decode: input should be Uint8Array");
+      const payload = data.slice(0, -len);
+      const oldChecksum = data.slice(-len);
+      const newChecksum = fn(payload).slice(0, len);
+      for (let i = 0; i < len; i++)
+        if (newChecksum[i] !== oldChecksum[i])
+          throw new Error("Invalid checksum");
+      return payload;
+    }
+  };
+}
+var utils = {
+  alphabet,
+  chain,
+  checksum,
+  convertRadix,
+  convertRadix2,
+  radix,
+  radix2,
+  join,
+  padding
+};
+var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join(""));
+var base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+
+// src/crypto/public-key.ts
+var PublicKey = class _PublicKey {
+  bytes;
+  constructor(bytes) {
+    if (bytes.length !== PUBLIC_KEY_LENGTH) {
+      throw CryptoError.invalidKeyLength(PUBLIC_KEY_LENGTH, bytes.length);
+    }
+    this.bytes = new Uint8Array(bytes);
+  }
+  /**
+   * Creates a PublicKey from raw bytes.
+   *
+   * @param bytes - 32-byte Ed25519 public key
+   * @throws {CryptoError} If bytes length is not 32
+   */
+  static fromBytes(bytes) {
+    return new _PublicKey(bytes);
+  }
+  /**
+   * Creates a PublicKey from a base58-encoded string.
+   *
+   * @param str - Base58-encoded public key
+   * @throws {CryptoError} If string is invalid or decodes to wrong length
+   */
+  static fromString(str) {
+    try {
+      const bytes = base58.decode(str);
+      return new _PublicKey(bytes);
+    } catch (error) {
+      throw new CryptoError(
+        "INVALID_PUBLIC_KEY" /* INVALID_PUBLIC_KEY */,
+        `Invalid base58 public key: ${error instanceof Error ? error.message : "unknown error"}`,
+        { input: str }
+      );
+    }
+  }
+  /**
+   * Returns a copy of the raw bytes.
+   */
+  toBytes() {
+    return new Uint8Array(this.bytes);
+  }
+  /**
+   * Returns the base58-encoded string representation.
+   */
+  toString() {
+    return base58.encode(this.bytes);
+  }
+  /**
+   * Checks equality with another public key using constant-time comparison.
+   */
+  equals(other) {
+    if (!other) return false;
+    if (this.bytes.length !== other.bytes.length) return false;
+    for (let i = 0; i < this.bytes.length; i++) {
+      if (this.bytes[i] !== other.bytes[i]) return false;
+    }
+    return true;
+  }
+  /**
+   * Verifies an Ed25519 signature over a message.
+   *
+   * @param message - Message bytes that were signed
+   * @param signature - Signature to verify
+   * @returns True if signature is valid, false otherwise
+   *
+   * @example
+   * ```typescript
+   * const message = new Uint8Array([1, 2, 3]);
+   * const signature = keypair.sign(message);
+   * const isValid = keypair.publicKey.verify(message, signature);
+   * ```
+   */
+  verify(message, signature) {
+    return verify(
+      signature.toBytes(),
+      message,
+      this.bytes
+    );
+  }
+  /**
+   * JSON serialization (returns base58 string).
+   */
+  toJSON() {
+    return this.toString();
+  }
+};
+
+// src/crypto/signature.ts
+var Signature = class _Signature {
+  bytes;
+  constructor(bytes) {
+    if (bytes.length !== SIGNATURE_LENGTH) {
+      throw CryptoError.invalidKeyLength(SIGNATURE_LENGTH, bytes.length);
+    }
+    this.bytes = new Uint8Array(bytes);
+  }
+  /**
+   * Creates a Signature from raw bytes.
+   *
    * @param bytes - 64-byte Ed25519 signature
    * @throws {CryptoError} If bytes length is not 64
    */
@@ -5991,1286 +5943,1619 @@ function createAccount(from, newAccount, lamports, space, owner) {
   };
 }
 
-// src/rpc/errors.ts
-var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
-  RpcErrorCode2["REQUEST_TIMEOUT"] = "REQUEST_TIMEOUT";
-  RpcErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
-  RpcErrorCode2["CONNECTION_REFUSED"] = "CONNECTION_REFUSED";
-  RpcErrorCode2["INVALID_RESPONSE"] = "INVALID_RESPONSE";
-  RpcErrorCode2["PARSE_ERROR"] = "PARSE_ERROR";
-  RpcErrorCode2["INVALID_REQUEST"] = "INVALID_REQUEST";
-  RpcErrorCode2["METHOD_NOT_FOUND"] = "METHOD_NOT_FOUND";
-  RpcErrorCode2["INVALID_PARAMS"] = "INVALID_PARAMS";
-  RpcErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
-  RpcErrorCode2["TRANSACTION_REJECTED"] = "TRANSACTION_REJECTED";
-  RpcErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-  RpcErrorCode2["ACCOUNT_NOT_FOUND"] = "ACCOUNT_NOT_FOUND";
-  RpcErrorCode2["BLOCKHASH_NOT_FOUND"] = "BLOCKHASH_NOT_FOUND";
-  RpcErrorCode2["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
-  RpcErrorCode2["NODE_UNHEALTHY"] = "NODE_UNHEALTHY";
-  return RpcErrorCode2;
-})(RpcErrorCode || {});
-var RpcError = class _RpcError extends Error {
-  code;
-  details;
-  retryable;
-  constructor(code, message, details = {}, retryable = false) {
-    super(message);
-    this.name = "RpcError";
-    this.code = code;
-    this.details = details;
-    this.retryable = retryable;
-  }
-  static requestTimeout(timeoutMs, details) {
-    return new _RpcError(
-      "REQUEST_TIMEOUT" /* REQUEST_TIMEOUT */,
-      `RPC request timed out after ${timeoutMs}ms. The node may be slow or unreachable.`,
-      { ...details, timeout: timeoutMs },
-      true
-      // Retryable
-    );
-  }
-  static networkError(message, details) {
-    return new _RpcError(
-      "NETWORK_ERROR" /* NETWORK_ERROR */,
-      `Network error: ${message}. Check your internet connection and node URL.`,
-      details,
-      true
-      // Retryable
-    );
-  }
-  static invalidResponse(details) {
-    return new _RpcError(
-      "INVALID_RESPONSE" /* INVALID_RESPONSE */,
-      "Received invalid response from RPC node. The response format is unexpected.",
-      details,
-      false
-    );
-  }
-  static accountNotFound(pubkey) {
-    return new _RpcError(
-      "ACCOUNT_NOT_FOUND" /* ACCOUNT_NOT_FOUND */,
-      `Account ${pubkey} not found on chain. It may not exist or has zero balance.`,
-      { pubkey },
-      false
+// src/transaction/message.ts
+var Message = class _Message {
+  /** Message header with signature requirements */
+  header;
+  /** All account public keys referenced in the transaction */
+  accountKeys;
+  /** Transaction valid from (milliseconds since Unix epoch) */
+  validFrom;
+  /** Compiled instructions with account indices */
+  instructions;
+  /** Cached serialized bytes */
+  serializedCache;
+  constructor(header, accountKeys, validFrom, instructions) {
+    this.header = Object.freeze({ ...header });
+    this.accountKeys = Object.freeze([...accountKeys]);
+    this.validFrom = validFrom;
+    this.instructions = Object.freeze(
+      instructions.map((ix) => Object.freeze({ ...ix }))
     );
   }
-  static rateLimitExceeded(details) {
-    return new _RpcError(
-      "RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */,
-      "Rate limit exceeded. Too many requests to the RPC endpoint. Try again later or use a different endpoint.",
-      details,
-      true
-      // Can retry after delay
-    );
+  /**
+   * Serialize message to bytes for signing.
+   * Result is cached for performance.
+   */
+  serialize() {
+    if (!this.serializedCache) {
+      this.serializedCache = this.serializeInternal();
+    }
+    return new Uint8Array(this.serializedCache);
   }
-  static fromRpcCode(rpcCode, message, details) {
-    const codeMap = {
-      [-32700]: "PARSE_ERROR" /* PARSE_ERROR */,
-      [-32600]: "INVALID_REQUEST" /* INVALID_REQUEST */,
-      [-32601]: "METHOD_NOT_FOUND" /* METHOD_NOT_FOUND */,
-      [-32602]: "INVALID_PARAMS" /* INVALID_PARAMS */,
-      [-32603]: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
-      [429]: "RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */
+  /**
+   * Deserialize a message from wire format.
+   *
+   * @param data - Serialized message bytes
+   * @returns Deserialized Message
+   */
+  static deserialize(data) {
+    if (data.length < 3) {
+      throw new TransactionError(
+        "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+        "Insufficient data for message header"
+      );
+    }
+    let cursor = 0;
+    const header = {
+      numRequiredSignatures: data[cursor++],
+      numReadonlySignedAccounts: data[cursor++],
+      numReadonlyUnsignedAccounts: data[cursor++]
     };
-    const code = codeMap[rpcCode] || "INTERNAL_ERROR" /* INTERNAL_ERROR */;
-    const retryable = rpcCode === 429 || rpcCode === -32603;
-    return new _RpcError(code, message, { ...details, rpcCode }, retryable);
+    const [accountKeysLength, newCursor1] = deserializeCompactU162(data, cursor);
+    cursor = newCursor1;
+    const accountKeys = [];
+    for (let i = 0; i < accountKeysLength; i++) {
+      if (data.length < cursor + 32) {
+        throw new TransactionError(
+          "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+          `Insufficient data for account key ${i}`
+        );
+      }
+      const keyBytes = data.slice(cursor, cursor + 32);
+      accountKeys.push(PublicKey.fromBytes(keyBytes));
+      cursor += 32;
+    }
+    if (data.length < cursor + 8) {
+      throw new TransactionError(
+        "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+        "Insufficient data for validFrom"
+      );
+    }
+    const validFromBytes = data.slice(cursor, cursor + 8);
+    const validFrom = BigInt.asUintN(64, new DataView(validFromBytes.buffer).getBigUint64(0));
+    cursor += 8;
+    const [instructionsLength, newCursor2] = deserializeCompactU162(
+      data,
+      cursor
+    );
+    cursor = newCursor2;
+    const instructions = [];
+    for (let i = 0; i < instructionsLength; i++) {
+      if (data.length < cursor + 1) {
+        throw new TransactionError(
+          "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+          `Insufficient data for instruction ${i} program index`
+        );
+      }
+      const programIdIndex = data[cursor++];
+      const [accountIndexesLength, newCursor3] = deserializeCompactU162(
+        data,
+        cursor
+      );
+      cursor = newCursor3;
+      const accountKeyIndexes = [];
+      for (let j = 0; j < accountIndexesLength; j++) {
+        if (data.length < cursor + 1) {
+          throw new TransactionError(
+            "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+            `Insufficient data for instruction ${i} account index ${j}`
+          );
+        }
+        accountKeyIndexes.push(data[cursor++]);
+      }
+      const [dataLength, newCursor4] = deserializeCompactU162(data, cursor);
+      cursor = newCursor4;
+      if (data.length < cursor + dataLength) {
+        throw new TransactionError(
+          "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+          `Insufficient data for instruction ${i} data`
+        );
+      }
+      const instructionData = data.slice(cursor, cursor + dataLength);
+      cursor += dataLength;
+      instructions.push({
+        programIdIndex,
+        accountKeyIndexes: Object.freeze(accountKeyIndexes),
+        data: instructionData
+      });
+    }
+    return new _Message(header, accountKeys, validFrom, instructions);
   }
-  toJSON() {
-    return {
-      code: this.code,
-      message: this.message,
-      details: this.details,
-      retryable: this.retryable
-    };
+  serializeInternal() {
+    const buffer = [];
+    buffer.push(this.header.numRequiredSignatures);
+    buffer.push(this.header.numReadonlySignedAccounts);
+    buffer.push(this.header.numReadonlyUnsignedAccounts);
+    this.serializeCompactArray(buffer, this.accountKeys, (buf, key) => {
+      buf.push(...key.toBytes());
+    });
+    const validFromBuffer = new ArrayBuffer(8);
+    new DataView(validFromBuffer).setBigUint64(0, this.validFrom ?? BigInt(0));
+    buffer.push(...new Uint8Array(validFromBuffer));
+    this.serializeCompactArray(buffer, this.instructions, (buf, ix) => {
+      buf.push(ix.programIdIndex);
+      this.serializeCompactArray(buf, ix.accountKeyIndexes, (b, idx) => {
+        b.push(idx);
+      });
+      this.serializeCompactArray(buf, Array.from(ix.data), (b, byte) => {
+        b.push(byte);
+      });
+    });
+    return new Uint8Array(buffer);
   }
-};
-
-// src/rpc/clients/base-client.ts
-var BaseRpcClient = class {
-  transport;
-  requestId = 1;
-  constructor(transport) {
-    this.transport = transport;
+  serializeCompactArray(buffer, items, serializeItem) {
+    this.serializeCompactU16(buffer, items.length);
+    for (const item of items) {
+      serializeItem(buffer, item);
+    }
   }
-  /**
-   * Makes a JSON-RPC 2.0 method call with type safety.
-   *
-   * Handles request serialization, response validation, and error mapping.
-   */
-  async call(method, params = []) {
-    const requestId = this.requestId++;
-    const request = {
-      jsonrpc: "2.0",
-      id: requestId,
-      method,
-      params
-    };
-    const requestBody = JSON.stringify(request);
-    const requestDetails = { method, params, requestId };
-    const data = await this.transport.request(requestBody, requestDetails);
-    if (!this.isValidJsonRpcResponse(data)) {
-      throw RpcError.invalidResponse({
-        ...requestDetails,
-        response: data
-      });
+  serializeCompactU16(buffer, value) {
+    if (value < 0 || value > 65535) {
+      throw new Error(`Value out of range for compact-u16: ${value}`);
     }
-    const response = data;
-    if (response.error) {
-      throw RpcError.fromRpcCode(response.error.code, response.error.message, {
-        ...requestDetails,
-        rpcData: response.error.data
-      });
+    if (value <= 127) {
+      buffer.push(value);
+      return;
     }
-    if (!("result" in response)) {
-      throw RpcError.invalidResponse({
-        ...requestDetails,
-        response
-      });
+    if (value <= 16383) {
+      buffer.push(value & 127 | 128);
+      buffer.push(value >> 7 & 127);
+      return;
     }
-    return response.result;
+    buffer.push(value & 127 | 128);
+    buffer.push(value >> 7 & 127 | 128);
+    buffer.push(value >> 14 & 255);
   }
   /**
-   * Validate JSON-RPC response structure
+   * Get all signers required for this message.
    */
-  isValidJsonRpcResponse(data) {
-    if (typeof data !== "object" || data === null) {
-      return false;
-    }
-    const response = data;
-    return response.jsonrpc === "2.0" && typeof response.id === "number" && ("result" in response || "error" in response);
+  getSigners() {
+    return this.accountKeys.slice(0, this.header.numRequiredSignatures);
   }
   /**
-   * Returns the configured RPC endpoint URL.
+   * Check if a public key is a required signer.
    */
-  getUrl() {
-    return this.transport.getUrl();
+  isSignerRequired(pubkey) {
+    return this.getSigners().some((signer) => signer.equals(pubkey));
+  }
+  /**
+   * Get the index of a signer in the signers array.
+   * Returns -1 if not a signer.
+   */
+  getSignerIndex(pubkey) {
+    return this.getSigners().findIndex((signer) => signer.equals(pubkey));
   }
 };
-
-// src/utils.ts
-function toBase64(bytes) {
-  if (typeof btoa !== "undefined") {
-    const chunkSize = 8192;
-    let result = "";
-    for (let i = 0; i < bytes.length; i += chunkSize) {
-      const chunk = bytes.slice(i, i + chunkSize);
-      result += String.fromCharCode(...chunk);
-    }
-    return btoa(result);
+function deserializeCompactU162(data, currentCursor) {
+  let cursor = currentCursor;
+  if (cursor >= data.length) {
+    throw new TransactionError(
+      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+      "Insufficient data for compact-u16"
+    );
   }
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(bytes).toString("base64");
+  const firstByte = data[cursor++];
+  if ((firstByte & 128) === 0) {
+    return [firstByte, cursor];
   }
-  throw new Error("No base64 encoding available in this environment");
-}
-function fromBase64(base64) {
-  if (typeof atob !== "undefined") {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
+  if (cursor >= data.length) {
+    throw new TransactionError(
+      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+      "Incomplete compact-u16 encoding"
+    );
   }
-  if (typeof Buffer !== "undefined") {
-    return new Uint8Array(Buffer.from(base64, "base64"));
+  const secondByte = data[cursor++];
+  if ((secondByte & 128) === 0) {
+    return [firstByte & 127 | secondByte << 7, cursor];
   }
-  throw new Error("No base64 decoding available in this environment");
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function calculateBackoff(attempt, baseMs = 1e3, maxMs = 3e4) {
-  const exponentialDelay = baseMs * 2 ** attempt;
-  const jitter = Math.random() * 0.3 * exponentialDelay;
-  return Math.min(exponentialDelay + jitter, maxMs);
-}
-function getDevnetUrl() {
-  return URL_DEVNET;
-}
-function getTestnetUrl() {
-  return URL_TESTNET;
-}
-function getMainnetUrl() {
-  return URL_MAINNET;
-}
-function getLocalnetUrl() {
-  return URL_LOCALNET;
+  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];
 }
 
-// src/rpc/clients/query-client.ts
-var QueryRpcClient = class extends BaseRpcClient {
+// src/transaction/transaction.ts
+var Transaction = class _Transaction {
+  /** The unsigned message */
+  message;
+  /** Signatures (64 bytes each), aligned with message.header.numRequiredSignatures */
+  signatures;
+  // Private constructor - use static factories
+  constructor(message, signatures) {
+    this.message = message;
+    this.signatures = signatures.map((sig) => new Uint8Array(sig));
+    if (signatures.length !== message.header.numRequiredSignatures) {
+      throw new TransactionError(
+        "INVALID_SIGNATURE" /* INVALID_SIGNATURE */,
+        `Signature count (${signatures.length}) doesn't match required signers (${message.header.numRequiredSignatures})`
+      );
+    }
+  }
   /**
-   * Get the latest blockhash from the blockchain
+   * Create an unsigned transaction from a message.
+   * All signature slots are initialized to zero.
+   *
+   * @internal - Users should use TransactionBuilder instead
    */
-  async getLatestBlockhash() {
-    const result = await this.call(
-      "getLatestBlockhash",
-      []
+  static fromMessage(message) {
+    const numSignatures = message.header.numRequiredSignatures;
+    const signatures = Array.from(
+      { length: numSignatures },
+      () => new Uint8Array(SIGNATURE_LENGTH)
     );
-    return Blockhash.fromString(result.value.blockhash);
+    return new _Transaction(message, signatures);
   }
   /**
-   * Get the balance of an account
+   * Create transaction from message and existing signatures.
+   * @internal
    */
-  async getBalance(pubkey) {
-    const result = await this.call("getBalance", [
-      { address: pubkey.toString() }
-    ]);
-    return BigInt(result.value);
+  static fromMessageAndSignatures(message, signatures) {
+    return new _Transaction(message, signatures);
   }
   /**
-   * Get detailed information about an account
+   * Deserialize a transaction from wire format.
    */
-  async getAccountInfo(pubkey) {
-    const result = await this.call("getAccountInfo", [{ address: pubkey.toString(), encoding: "base64" }]);
-    if (!result.value) {
-      return null;
+  static deserialize(data) {
+    if (data.length === 0) {
+      throw new TransactionError(
+        "SERIALIZATION_FAILED" /* SERIALIZATION_FAILED */,
+        "Cannot deserialize empty transaction data"
+      );
     }
-    return {
-      balance: BigInt(result.value.balance),
-      owner: PublicKey.fromString(result.value.owner),
-      data: fromBase64(result.value.data),
-      executable: result.value.executable,
-      rentEpoch: BigInt(result.value.rentEpoch)
-    };
-  }
-  /**
-   * Get the current block height
-   */
-  async getBlockHeight() {
-    const result = await this.call("getBlockHeight", []);
-    return BigInt(result);
-  }
-  /**
-   * Get detailed information about a transaction
-   */
-  async getTransaction(signature) {
-    const result = await this.call("getTransaction", [signature]);
-    if (!result) {
-      return null;
+    let cursor = 0;
+    const [signaturesLength, newCursor] = deserializeCompactU16(data, cursor);
+    cursor = newCursor;
+    const signatures = [];
+    for (let i = 0; i < signaturesLength; i++) {
+      if (data.length < cursor + SIGNATURE_LENGTH) {
+        throw new TransactionError(
+          "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+          `Insufficient data for signature ${i}: need ${SIGNATURE_LENGTH} bytes at offset ${cursor}`
+        );
+      }
+      const signature = data.slice(cursor, cursor + SIGNATURE_LENGTH);
+      signatures.push(signature);
+      cursor += SIGNATURE_LENGTH;
     }
-    return {
-      signature,
-      slot: BigInt(result.slot),
-      blockTime: result.blockTime ? BigInt(result.blockTime) : void 0,
-      err: result.err
-    };
+    if (cursor >= data.length) {
+      throw new TransactionError(
+        "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
+        "No message data found after signatures"
+      );
+    }
+    const messageBytes = data.slice(cursor);
+    const message = Message.deserialize(messageBytes);
+    return new _Transaction(message, signatures);
+  }
+  getMessage() {
+    return this.message;
   }
   /**
-   * Get the total number of transactions processed since genesis
+   * Sign the transaction with a keypair.
+   * Returns a NEW Transaction instance.
+   *
+   * @param keypair - Keypair to sign with
+   * @returns New Transaction instance with signature added
+   *
+   * @example
+   * ```typescript
+   * const signedTx = tx.sign(keypair);
+   * await client.sendTransaction(signedTx.serialize());
+   * ```
    */
-  async getTransactionCount() {
-    const result = await this.call("getTransactionCount", []);
-    return BigInt(result);
+  sign(keypair) {
+    const messageBytes = this.message.serialize();
+    const signature = keypair.sign(messageBytes);
+    return this.addSignatureForPubkey(keypair.publicKey, signature);
   }
   /**
-   * Get the status of multiple transaction signatures
+   * Sign with multiple keypairs at once.
+   * Returns a NEW Transaction instance.
+   *
+   * @example
+   * ```typescript
+   * const signed = tx.signAll([keypair1, keypair2, keypair3]);
+   * ```
    */
-  async getSignatureStatuses(signatures) {
-    const result = await this.call("getSignatureStatuses", [signatures]);
-    return result.value.map((status) => {
-      if (!status) {
-        return null;
-      }
-      return {
-        slot: BigInt(status.slot),
-        confirmations: status.confirmations,
-        err: status.err
-      };
-    });
+  signAll(keypairs) {
+    let result = this;
+    for (const keypair of keypairs) {
+      result = result.sign(keypair);
+    }
+    return result;
   }
   /**
-   * Get epoch information
+   * Sign the transaction with a Signer interface (async).
+   * Returns a NEW Transaction instance.
+   *
+   * @example
+   * ```typescript
+   * const signedTx = await tx.signWith(browserWallet);
+   * ```
    */
-  async getEpochInfo() {
-    const result = await this.call("getEpochInfo", []);
-    return {
-      epoch: BigInt(result.epoch),
-      slotIndex: BigInt(result.slotIndex),
-      slotsInEpoch: BigInt(result.slotsInEpoch),
-      absoluteSlot: BigInt(result.absoluteSlot),
-      blockHeight: BigInt(result.blockHeight),
-      transactionCount: result.transactionCount ? BigInt(result.transactionCount) : void 0
-    };
+  async signWith(signer) {
+    const pubkey = await signer.getPublicKey();
+    const messageBytes = this.message.serialize();
+    const signature = await signer.signMessage(messageBytes);
+    return this.addSignatureForPubkey(pubkey, signature);
   }
   /**
-   * Get the health status of the node
+   * Sign with multiple signers.
+   * Returns a NEW Transaction instance.
    */
-  async getHealth() {
-    const result = await this.call("getHealth", []);
+  async signAllWith(signers) {
+    let result = this;
+    for (const signer of signers) {
+      result = await result.signWith(signer);
+    }
     return result;
   }
-};
-
-// src/rpc/clients/transaction-client.ts
-var TransactionRpcClient = class extends BaseRpcClient {
   /**
-   * Submit a signed transaction to the blockchain
+   * Partially sign the transaction (for multi-sig transactions).
+   * Returns a NEW Transaction instance.
+   *
+   * @example
+   * ```typescript
+   * const signedTx = tx
+   *   .partialSign(signer1)
+   *   .partialSign(signer2);
+   * ```
    */
-  async sendTransaction(transaction, options) {
-    const base64Tx = toBase64(transaction);
-    const config = {
-      encoding: "base64",
-      skipPreflight: options?.skipPreflight ?? false,
-      maxRetries: options?.maxRetries ?? 5
-    };
-    const signature = await this.call("sendTransaction", [
-      base64Tx,
-      config
-    ]);
-    return signature;
+  partialSign(keypair) {
+    return this.sign(keypair);
   }
   /**
-   * Request an airdrop of tokens to an account (devnet/testnet only)
+   * Partially sign with a Signer interface (async).
+   * Returns a NEW Transaction instance.
    */
-  async requestAirdrop(pubkey, amount) {
-    const signature = await this.call("requestAirdrop", [
-      pubkey.toString(),
-      Number(amount)
-    ]);
-    return signature;
-  }
-};
-
-// src/rpc/clients/client.ts
-var RialoClient = class {
-  queryClient;
-  transactionClient;
-  transport;
-  constructor(transport) {
-    this.transport = transport;
-    this.queryClient = new QueryRpcClient(transport);
-    this.transactionClient = new TransactionRpcClient(transport);
+  async partialSignWith(signer) {
+    return this.signWith(signer);
   }
   /**
-   * Returns the configured RPC endpoint URL.
+   * Add a signature at a specific index.
+   * Returns a NEW Transaction instance.
+   *
+   * Most users should use sign() or signAll() instead.
    */
-  getUrl() {
-    return this.transport.getUrl();
+  addSignature(index, signature) {
+    if (index < 0 || index >= this.signatures.length) {
+      throw new TransactionError(
+        "SIGNATURE_OUT_OF_BOUNDS" /* SIGNATURE_OUT_OF_BOUNDS */,
+        `Signature index ${index} out of bounds (must be 0-${this.signatures.length - 1})`
+      );
+    }
+    const sigBytes = signature instanceof Uint8Array ? signature : signature.toBytes();
+    if (sigBytes.length !== SIGNATURE_LENGTH) {
+      throw new TransactionError(
+        "INVALID_SIGNATURE" /* INVALID_SIGNATURE */,
+        `Signature must be ${SIGNATURE_LENGTH} bytes, got ${sigBytes.length}`
+      );
+    }
+    const newSignatures = this.signatures.map(
+      (sig, i) => i === index ? new Uint8Array(sigBytes) : new Uint8Array(sig)
+    );
+    return new _Transaction(this.message, newSignatures);
   }
   /**
-   * Retrieves the latest blockhash from the blockchain.
+   * Add a signature for a specific public key.
+   * Returns a NEW Transaction instance.
    *
-   * Required for transaction creation and replay protection.
+   * Most users should use sign() or signAll() instead.
    */
-  async getLatestBlockhash() {
-    return await this.queryClient.getLatestBlockhash();
+  addSignatureForPubkey(pubkey, signature) {
+    const signerIndex = this.message.getSignerIndex(pubkey);
+    if (signerIndex === -1) {
+      throw TransactionError.signerNotFound(pubkey.toString());
+    }
+    return this.addSignature(signerIndex, signature);
   }
   /**
-   * Retrieves the balance of an account in kelvins (smallest unit).
+   * Check if transaction is fully signed (all signatures present).
    */
-  async getBalance(pubkey) {
-    return await this.queryClient.getBalance(pubkey);
+  isSigned() {
+    return this.signatures.every((sig) => sig.some((byte) => byte !== 0));
   }
   /**
-   * Retrieves detailed information about an account.
-   *
-   * @returns Account info or null if account doesn't exist
+   * Check if a specific signature slot is filled.
    */
-  async getAccountInfo(pubkey) {
-    return await this.queryClient.getAccountInfo(pubkey);
+  isSignaturePresent(index) {
+    if (index < 0 || index >= this.signatures.length) {
+      return false;
+    }
+    return this.signatures[index].some((byte) => byte !== 0);
   }
   /**
-   * Retrieves the current block height.
+   * Get all signatures (returns copies to prevent mutation).
    */
-  async getBlockHeight() {
-    return await this.queryClient.getBlockHeight();
+  getSignatures() {
+    return this.signatures.map((sig) => new Uint8Array(sig));
   }
   /**
-   * Retrieves detailed information about a transaction.
-   *
-   * @returns Transaction info or null if transaction not found
+   * Get a specific signature (returns copy).
    */
-  async getTransaction(signature) {
-    return await this.queryClient.getTransaction(signature);
+  getSignature(index) {
+    if (index < 0 || index >= this.signatures.length) {
+      throw new TransactionError(
+        "SIGNATURE_OUT_OF_BOUNDS" /* SIGNATURE_OUT_OF_BOUNDS */,
+        `Signature index ${index} out of bounds`
+      );
+    }
+    return new Uint8Array(this.signatures[index]);
   }
   /**
-   * Retrieves the total number of transactions processed since genesis.
+   * Get a specific signature for a public key.
    */
-  async getTransactionCount() {
-    return await this.queryClient.getTransactionCount();
+  getSignatureForPubkey(pubkey) {
+    const signerIndex = this.message.getSignerIndex(pubkey);
+    if (signerIndex === -1) {
+      throw TransactionError.signerNotFound(pubkey.toString());
+    }
+    return this.getSignature(signerIndex);
   }
   /**
-   * Retrieves the status of multiple transaction signatures.
+   * Get required signers for this transaction.
    */
-  async getSignatureStatuses(signatures) {
-    return await this.queryClient.getSignatureStatuses(signatures);
+  getSigners() {
+    return this.message.getSigners();
   }
   /**
-   * Retrieves current epoch information.
+   * Get the number of required signatures.
    */
-  async getEpochInfo() {
-    return await this.queryClient.getEpochInfo();
+  getRequiredSignatureCount() {
+    return this.message.header.numRequiredSignatures;
   }
   /**
-   * Checks the health status of the RPC node.
+   * Throw an error if the transaction is not fully signed.
    *
-   * @returns "ok" if healthy, error message otherwise
-   */
-  async getHealth() {
-    return await this.queryClient.getHealth();
-  }
-  /**
-   * Submits a signed transaction to the blockchain.
+   * @throws {TransactionError} If transaction is not fully signed
    *
-   * @param transaction - Serialized signed transaction bytes
-   * @param options - Transaction submission options
-   * @returns Transaction signature
+   * @example
+   * ```typescript
+   * signedTx.ensureSigned(); // Throws if not signed
+   * await client.sendTransaction(signedTx.serialize());
+   * ```
    */
-  async sendTransaction(transaction, options) {
-    return await this.transactionClient.sendTransaction(transaction, options);
+  ensureSigned() {
+    if (!this.isSigned()) {
+      const missingIndices = this.signatures.map((sig, i) => ({ sig, i })).filter(({ sig }) => !sig.some((byte) => byte !== 0)).map(({ i }) => i);
+      const signers = this.getSigners();
+      const missingSigners = missingIndices.map((i) => signers[i].toString());
+      throw new TransactionError(
+        "MISSING_SIGNATURE" /* MISSING_SIGNATURE */,
+        `Transaction is not fully signed. Missing signatures for: ${missingSigners.join(", ")}`,
+        { missingIndices, missingSigners }
+      );
+    }
   }
   /**
-   * Requests an airdrop of tokens to an account.
-   *
-   * **Note**: Only available on devnet and testnet.
-   *
-   * @param pubkey - Account to receive the airdrop
-   * @param amount - Amount in kelvins (smallest unit)
-   * @returns Transaction signature
+   * Serialize transaction to wire format.
    */
-  async requestAirdrop(pubkey, amount) {
-    return await this.transactionClient.requestAirdrop(pubkey, amount);
+  serialize() {
+    const compactU16Size = this.signatures.length < 128 ? 1 : 2;
+    const sigsSize = compactU16Size + this.signatures.length * SIGNATURE_LENGTH;
+    const messageBytes = this.message.serialize();
+    const totalSize = sigsSize + messageBytes.length;
+    const buffer = new Uint8Array(totalSize);
+    let offset = 0;
+    offset = writeCompactU16(buffer, offset, this.signatures.length);
+    for (const sig of this.signatures) {
+      buffer.set(sig, offset);
+      offset += SIGNATURE_LENGTH;
+    }
+    buffer.set(messageBytes, offset);
+    return buffer;
   }
 };
 
-// src/rpc/http-transport.ts
-var DEFAULT_CONFIG = {
-  timeout: 3e4,
-  // 30 seconds
-  maxRetries: 3,
-  retryBaseDelay: 1e3,
-  // 1 second
-  retryMaxDelay: 3e4,
-  // 30 seconds
-  headers: {}
-};
-var HttpTransport = class {
-  url;
-  config;
-  constructor(url, config = {}) {
-    this.url = url;
-    this.config = { ...DEFAULT_CONFIG, ...config };
+// src/transaction/transaction-builder.ts
+var TransactionBuilder = class _TransactionBuilder {
+  payer;
+  validFrom;
+  instructions = [];
+  constructor() {
   }
   /**
-   * Makes an HTTP request with automatic retry logic.
-   *
-   * Retries are attempted for network errors and server errors (5xx).
-   * Uses exponential backoff between retry attempts.
+   * Create a new transaction builder.
    */
-  async request(body, requestDetails = {}) {
-    let lastError;
-    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
-      try {
-        return await this.makeRequest(body, requestDetails, attempt);
-      } catch (error) {
-        lastError = error;
-        if (error instanceof RpcError && !error.retryable) {
-          throw error;
-        }
-        if (attempt === this.config.maxRetries) {
-          throw error;
-        }
-        const delay = calculateBackoff(
-          attempt,
-          this.config.retryBaseDelay,
-          this.config.retryMaxDelay
-        );
-        await sleep(delay);
-      }
-    }
-    throw lastError;
+  static create() {
+    return new _TransactionBuilder();
   }
   /**
-   * Make a single HTTP request with timeout
+   * Set the fee payer for this transaction.
+   *
+   * The payer will be the first account and must sign the transaction.
+   * The payer pays for transaction fees.
+   *
+   * @param payer - Public key of the fee payer
    */
-  async makeRequest(body, requestDetails, attempt) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-    try {
-      const options = {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...this.config.headers
-        },
-        body,
-        signal: controller.signal
-      };
-      const response = await fetch(this.url, options);
-      if (!response.ok) {
-        throw await this.handleHttpError(response, requestDetails, attempt);
-      }
-      const data = await response.json();
-      return data;
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw RpcError.requestTimeout(this.config.timeout, {
-          ...requestDetails,
-          url: this.url,
-          attempts: attempt + 1
-        });
-      }
-      if (error instanceof TypeError) {
-        throw RpcError.networkError(error.message, {
-          ...requestDetails,
-          url: this.url,
-          attempts: attempt + 1,
-          cause: error.message
-        });
-      }
-      if (error instanceof RpcError) {
-        throw error;
-      }
-      throw RpcError.networkError("Unknown network error", {
-        ...requestDetails,
-        url: this.url,
-        attempts: attempt + 1,
-        cause: error instanceof Error ? error.message : String(error)
-      });
-    } finally {
-      clearTimeout(timeoutId);
-    }
+  setPayer(payer) {
+    this.payer = payer;
+    return this;
   }
   /**
-   * Handle HTTP error responses
+   * Set the Transaction valid from.
+   *
+   * This is the time the transaction is valid from, in milliseconds since Unix epoch.
+   * It can be used for additional replay protection or auditing.
+   *
+   * @param validFrom - Transaction valid from in milliseconds since Unix epoch
    */
-  async handleHttpError(response, requestDetails, attempt) {
-    const status = response.status;
-    if (status === 429) {
-      return RpcError.rateLimitExceeded({
-        ...requestDetails,
-        httpStatus: status,
-        url: this.url,
-        attempts: attempt + 1
-      });
-    }
-    if (status >= 500) {
-      return RpcError.networkError(`Server error: ${status}`, {
-        ...requestDetails,
-        httpStatus: status,
-        url: this.url,
-        attempts: attempt + 1
-      });
-    }
-    let message = `HTTP ${status}: ${response.statusText}`;
-    try {
-      const errorData = await response.json();
-      if (errorData && typeof errorData === "object" && "message" in errorData) {
-        message = String(errorData.message);
-      }
-    } catch {
-    }
-    return new RpcError(
-      "NETWORK_ERROR" /* NETWORK_ERROR */,
-      message,
-      {
-        ...requestDetails,
-        httpStatus: status,
-        url: this.url,
-        attempts: attempt + 1
-      },
-      false
-      // 4xx errors are not retryable
-    );
+  setValidFrom(validFrom) {
+    this.validFrom = validFrom;
+    return this;
   }
   /**
-   * Returns the configured RPC endpoint URL.
+   * Add an instruction to the transaction.
+   *
+   * @param instruction - Instruction to add
    */
-  getUrl() {
-    return this.url;
-  }
-};
-
-// src/rpc/index.ts
-function createRialoClient(url, config) {
-  const transport = new HttpTransport(url, config);
-  return new RialoClient(transport);
-}
-
-// src/transaction/message.ts
-var Message = class _Message {
-  /** Message header with signature requirements */
-  header;
-  /** All account public keys referenced in the transaction */
-  accountKeys;
-  /** Recent blockhash for replay protection */
-  recentBlockhash;
-  /** Transaction creation timestamp (milliseconds since Unix epoch) */
-  txCreationTime;
-  /** Compiled instructions with account indices */
-  instructions;
-  /** Cached serialized bytes */
-  serializedCache;
-  constructor(header, accountKeys, recentBlockhash, txCreationTime, instructions) {
-    this.header = Object.freeze({ ...header });
-    this.accountKeys = Object.freeze([...accountKeys]);
-    this.recentBlockhash = recentBlockhash;
-    this.txCreationTime = txCreationTime;
-    this.instructions = Object.freeze(
-      instructions.map((ix) => Object.freeze({ ...ix }))
-    );
+  addInstruction(instruction) {
+    this.instructions.push(instruction);
+    return this;
   }
   /**
-   * Serialize message to bytes for signing.
-   * Result is cached for performance.
+   * Add multiple instructions at once.
+   *
+   * @param instructions - Array of instructions to add
    */
-  serialize() {
-    if (!this.serializedCache) {
-      this.serializedCache = this.serializeInternal();
-    }
-    return new Uint8Array(this.serializedCache);
+  addInstructions(instructions) {
+    this.instructions.push(...instructions);
+    return this;
   }
   /**
-   * Deserialize a message from wire format.
+   * Build the transaction (unsigned).
    *
-   * @param data - Serialized message bytes
-   * @returns Deserialized Message
-   */
-  static deserialize(data) {
-    if (data.length < 3) {
-      throw new TransactionError(
-        "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-        "Insufficient data for message header"
-      );
-    }
-    let cursor = 0;
-    const header = {
-      numRequiredSignatures: data[cursor++],
-      numReadonlySignedAccounts: data[cursor++],
-      numReadonlyUnsignedAccounts: data[cursor++]
-    };
-    const [accountKeysLength, newCursor1] = deserializeCompactU162(data, cursor);
-    cursor = newCursor1;
-    const accountKeys = [];
-    for (let i = 0; i < accountKeysLength; i++) {
-      if (data.length < cursor + 32) {
-        throw new TransactionError(
-          "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-          `Insufficient data for account key ${i}`
-        );
-      }
-      const keyBytes = data.slice(cursor, cursor + 32);
-      accountKeys.push(PublicKey.fromBytes(keyBytes));
-      cursor += 32;
-    }
-    if (data.length < cursor + 32) {
+   * Returns an unsigned Transaction that's ready to be signed.
+   *
+   * @returns Unsigned Transaction
+   * @throws {TransactionError} If payer, valid_from, or instructions are missing
+   *
+   * @example
+   * ```typescript
+   * const tx = builder.build();
+   * const signedTx = tx.sign(keypair);
+   * ```
+   */
+  build() {
+    if (!this.payer) {
       throw new TransactionError(
-        "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-        "Insufficient data for blockhash"
+        "INVALID_ACCOUNT_META" /* INVALID_ACCOUNT_META */,
+        "Transaction must have a fee payer. Use setPayer() to set the fee payer."
       );
     }
-    const recentBlockhash = Blockhash.fromBytes(
-      data.slice(cursor, cursor + 32)
-    );
-    cursor += 32;
-    if (data.length < cursor + 8) {
+    if (!this.validFrom) {
       throw new TransactionError(
-        "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-        "Insufficient data for TxCreationTime"
+        "INVALID_MESSAGE_FORMAT" /* INVALID_MESSAGE_FORMAT */,
+        "Transaction must have a valid from. Use setValidFrom() to set the valid from."
       );
     }
-    const txCreationTimeBytes = data.slice(cursor, cursor + 8);
-    const txCreationTime = BigInt.asUintN(64, new DataView(txCreationTimeBytes.buffer).getBigUint64(0));
-    cursor += 8;
-    const [instructionsLength, newCursor2] = deserializeCompactU162(
-      data,
-      cursor
-    );
-    cursor = newCursor2;
-    const instructions = [];
-    for (let i = 0; i < instructionsLength; i++) {
-      if (data.length < cursor + 1) {
+    if (this.instructions.length === 0) {
+      throw TransactionError.noInstructions();
+    }
+    const accountTable = new AccountMetaTable();
+    accountTable.add({
+      pubkey: this.payer,
+      isSigner: true,
+      isWritable: true
+    });
+    for (const instruction of this.instructions) {
+      accountTable.addAll(instruction.accounts);
+      accountTable.add({
+        pubkey: instruction.programId,
+        isSigner: false,
+        isWritable: false
+      });
+    }
+    const accountKeys = accountTable.getPublicKeys();
+    const header = accountTable.getHeader();
+    const compiledInstructions = this.instructions.map((instruction) => {
+      const programIdIndex = accountTable.getIndex(instruction.programId);
+      if (programIdIndex === -1) {
         throw new TransactionError(
-          "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-          `Insufficient data for instruction ${i} program index`
+          "INVALID_INSTRUCTION" /* INVALID_INSTRUCTION */,
+          `Program ID ${instruction.programId.toString()} not found in account table`
         );
       }
-      const programIdIndex = data[cursor++];
-      const [accountIndexesLength, newCursor3] = deserializeCompactU162(
-        data,
-        cursor
-      );
-      cursor = newCursor3;
-      const accountKeyIndexes = [];
-      for (let j = 0; j < accountIndexesLength; j++) {
-        if (data.length < cursor + 1) {
+      const accountKeyIndexes = instruction.accounts.map((meta) => {
+        const index = accountTable.getIndex(meta.pubkey);
+        if (index === -1) {
           throw new TransactionError(
-            "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-            `Insufficient data for instruction ${i} account index ${j}`
+            "INVALID_INSTRUCTION" /* INVALID_INSTRUCTION */,
+            `Account ${meta.pubkey.toString()} not found in account table`
           );
         }
-        accountKeyIndexes.push(data[cursor++]);
-      }
-      const [dataLength, newCursor4] = deserializeCompactU162(data, cursor);
-      cursor = newCursor4;
-      if (data.length < cursor + dataLength) {
-        throw new TransactionError(
-          "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-          `Insufficient data for instruction ${i} data`
-        );
-      }
-      const instructionData = data.slice(cursor, cursor + dataLength);
-      cursor += dataLength;
-      instructions.push({
+        return index;
+      });
+      const compiled = {
         programIdIndex,
         accountKeyIndexes: Object.freeze(accountKeyIndexes),
-        data: instructionData
-      });
-    }
-    return new _Message(header, accountKeys, recentBlockhash, txCreationTime, instructions);
-  }
-  serializeInternal() {
-    const buffer = [];
-    buffer.push(this.header.numRequiredSignatures);
-    buffer.push(this.header.numReadonlySignedAccounts);
-    buffer.push(this.header.numReadonlyUnsignedAccounts);
-    this.serializeCompactArray(buffer, this.accountKeys, (buf, key) => {
-      buf.push(...key.toBytes());
-    });
-    buffer.push(...this.recentBlockhash.toBytes());
-    const txCreationTimeBuffer = new ArrayBuffer(8);
-    new DataView(txCreationTimeBuffer).setBigUint64(0, this.txCreationTime ?? BigInt(0));
-    buffer.push(...new Uint8Array(txCreationTimeBuffer));
-    this.serializeCompactArray(buffer, this.instructions, (buf, ix) => {
-      buf.push(ix.programIdIndex);
-      this.serializeCompactArray(buf, ix.accountKeyIndexes, (b, idx) => {
-        b.push(idx);
-      });
-      this.serializeCompactArray(buf, Array.from(ix.data), (b, byte) => {
-        b.push(byte);
-      });
+        data: instruction.data
+      };
+      return compiled;
     });
-    return new Uint8Array(buffer);
+    const message = new Message(
+      header,
+      accountKeys,
+      this.validFrom,
+      compiledInstructions
+    );
+    return Transaction.fromMessage(message);
   }
-  serializeCompactArray(buffer, items, serializeItem) {
-    this.serializeCompactU16(buffer, items.length);
-    for (const item of items) {
-      serializeItem(buffer, item);
-    }
+};
+
+// src/rpc/errors.ts
+var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
+  RpcErrorCode2["REQUEST_TIMEOUT"] = "REQUEST_TIMEOUT";
+  RpcErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  RpcErrorCode2["CONNECTION_REFUSED"] = "CONNECTION_REFUSED";
+  RpcErrorCode2["INVALID_NETWORK"] = "INVALID_NETWORK";
+  RpcErrorCode2["INVALID_RESPONSE"] = "INVALID_RESPONSE";
+  RpcErrorCode2["PARSE_ERROR"] = "PARSE_ERROR";
+  RpcErrorCode2["INVALID_REQUEST"] = "INVALID_REQUEST";
+  RpcErrorCode2["METHOD_NOT_FOUND"] = "METHOD_NOT_FOUND";
+  RpcErrorCode2["INVALID_PARAMS"] = "INVALID_PARAMS";
+  RpcErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  RpcErrorCode2["TRANSACTION_REJECTED"] = "TRANSACTION_REJECTED";
+  RpcErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+  RpcErrorCode2["TRANSACTION_CONFIRMATION_TIMEOUT"] = "TRANSACTION_CONFIRMATION_TIMEOUT";
+  RpcErrorCode2["ACCOUNT_NOT_FOUND"] = "ACCOUNT_NOT_FOUND";
+  RpcErrorCode2["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+  RpcErrorCode2["NODE_UNHEALTHY"] = "NODE_UNHEALTHY";
+  return RpcErrorCode2;
+})(RpcErrorCode || {});
+var RpcError = class _RpcError extends Error {
+  code;
+  details;
+  retryable;
+  constructor(code, message, details = {}, retryable = false) {
+    super(message);
+    this.name = "RpcError";
+    this.code = code;
+    this.details = details;
+    this.retryable = retryable;
   }
-  serializeCompactU16(buffer, value) {
-    if (value < 0 || value > 65535) {
-      throw new Error(`Value out of range for compact-u16: ${value}`);
+  static requestTimeout(timeoutMs, details) {
+    return new _RpcError(
+      "REQUEST_TIMEOUT" /* REQUEST_TIMEOUT */,
+      `RPC request timed out after ${timeoutMs}ms. The node may be slow or unreachable.`,
+      { ...details, timeout: timeoutMs },
+      true
+      // Retryable
+    );
+  }
+  static networkError(message, details) {
+    return new _RpcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      `Network error: ${message}. Check your internet connection and node URL.`,
+      details,
+      true
+      // Retryable
+    );
+  }
+  static invalidResponse(details) {
+    return new _RpcError(
+      "INVALID_RESPONSE" /* INVALID_RESPONSE */,
+      "Received invalid response from RPC node. The response format is unexpected.",
+      details,
+      false
+    );
+  }
+  static accountNotFound(pubkey) {
+    return new _RpcError(
+      "ACCOUNT_NOT_FOUND" /* ACCOUNT_NOT_FOUND */,
+      `Account ${pubkey} not found on chain. It may not exist or has zero balance.`,
+      { pubkey },
+      false
+    );
+  }
+  static rateLimitExceeded(details) {
+    return new _RpcError(
+      "RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */,
+      "Rate limit exceeded. Too many requests to the RPC endpoint. Try again later or use a different endpoint.",
+      details,
+      true
+      // Can retry after delay
+    );
+  }
+  static fromRpcCode(rpcCode, message, details) {
+    const codeMap = {
+      [-32700]: "PARSE_ERROR" /* PARSE_ERROR */,
+      [-32600]: "INVALID_REQUEST" /* INVALID_REQUEST */,
+      [-32601]: "METHOD_NOT_FOUND" /* METHOD_NOT_FOUND */,
+      [-32602]: "INVALID_PARAMS" /* INVALID_PARAMS */,
+      [-32603]: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+      [429]: "RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */
+    };
+    const code = codeMap[rpcCode] || "INTERNAL_ERROR" /* INTERNAL_ERROR */;
+    const retryable = rpcCode === 429 || rpcCode === -32603;
+    return new _RpcError(code, message, { ...details, rpcCode }, retryable);
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      retryable: this.retryable
+    };
+  }
+};
+
+// src/rpc/clients/base-client.ts
+var BaseRpcClient = class {
+  transport;
+  requestId = 0;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /**
+   * Makes a JSON-RPC 2.0 method call with type safety.
+   *
+   * Handles request serialization, response validation, and error mapping.
+   */
+  async call(method, params = []) {
+    const requestId = this.nextRequestId();
+    const request = {
+      jsonrpc: "2.0",
+      id: requestId,
+      method,
+      params
+    };
+    const requestBody = JSON.stringify(request);
+    const requestDetails = { method, params, requestId };
+    const data = await this.transport.request(requestBody, requestDetails);
+    if (!this.isValidJsonRpcResponse(data)) {
+      throw RpcError.invalidResponse({
+        ...requestDetails,
+        response: data
+      });
     }
-    if (value <= 127) {
-      buffer.push(value);
-      return;
+    const response = data;
+    if (response.error) {
+      throw RpcError.fromRpcCode(response.error.code, response.error.message, {
+        ...requestDetails,
+        rpcData: response.error.data
+      });
     }
-    if (value <= 16383) {
-      buffer.push(value & 127 | 128);
-      buffer.push(value >> 7 & 127);
-      return;
+    if (!("result" in response)) {
+      throw RpcError.invalidResponse({
+        ...requestDetails,
+        response
+      });
     }
-    buffer.push(value & 127 | 128);
-    buffer.push(value >> 7 & 127 | 128);
-    buffer.push(value >> 14 & 255);
+    return response.result;
   }
   /**
-   * Get all signers required for this message.
+   * Validate JSON-RPC response structure
    */
-  getSigners() {
-    return this.accountKeys.slice(0, this.header.numRequiredSignatures);
+  isValidJsonRpcResponse(data) {
+    if (typeof data !== "object" || data === null) {
+      return false;
+    }
+    const response = data;
+    return response.jsonrpc === "2.0" && typeof response.id === "number" && ("result" in response || "error" in response);
   }
   /**
-   * Check if a public key is a required signer.
+   * Generates the next request ID with Overflow Protection.
+   * @returns The next request ID.
    */
-  isSignerRequired(pubkey) {
-    return this.getSigners().some((signer) => signer.equals(pubkey));
+  nextRequestId() {
+    this.requestId = (this.requestId + 1) % Number.MAX_SAFE_INTEGER;
+    return this.requestId;
   }
   /**
-   * Get the index of a signer in the signers array.
-   * Returns -1 if not a signer.
+   * Returns the configured RPC endpoint URL.
    */
-  getSignerIndex(pubkey) {
-    return this.getSigners().findIndex((signer) => signer.equals(pubkey));
+  getUrl() {
+    return this.transport.getUrl();
   }
 };
-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];
+
+// src/utils.ts
+function toBase64(bytes) {
+  if (typeof btoa !== "undefined") {
+    const chunkSize = 8192;
+    let result = "";
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      const chunk = bytes.slice(i, i + chunkSize);
+      result += String.fromCharCode(...chunk);
+    }
+    return btoa(result);
   }
-  if (cursor >= data.length) {
-    throw new TransactionError(
-      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-      "Incomplete compact-u16 encoding"
-    );
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
   }
-  const secondByte = data[cursor++];
-  if ((secondByte & 128) === 0) {
-    return [firstByte & 127 | secondByte << 7, cursor];
+  throw new Error("No base64 encoding available in this environment");
+}
+function fromBase64(base64) {
+  if (typeof atob !== "undefined") {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
   }
-  if (cursor >= data.length) {
-    throw new TransactionError(
-      "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-      "Incomplete compact-u16 encoding"
-    );
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(base64, "base64"));
   }
-  const thirdByte = data[cursor++];
-  const value = firstByte & 127 | (secondByte & 127) << 7 | thirdByte << 14;
-  return [value, cursor];
+  throw new Error("No base64 decoding available in this environment");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateBackoff(attempt, baseMs = 1e3, maxMs = 3e4) {
+  const exponentialDelay = baseMs * 2 ** attempt;
+  const jitter = Math.random() * 0.3 * exponentialDelay;
+  return Math.min(exponentialDelay + jitter, maxMs);
+}
+function getDevnetUrl() {
+  return URL_DEVNET;
+}
+function getTestnetUrl() {
+  return URL_TESTNET;
+}
+function getMainnetUrl() {
+  return URL_MAINNET;
+}
+function getLocalnetUrl() {
+  return URL_LOCALNET;
 }
 
-// src/transaction/transaction.ts
-var Transaction = class _Transaction {
-  /** The unsigned message */
-  message;
-  /** Signatures (64 bytes each), aligned with message.header.numRequiredSignatures */
-  signatures;
-  // Private constructor - use static factories
-  constructor(message, signatures) {
-    this.message = message;
-    this.signatures = signatures.map((sig) => new Uint8Array(sig));
-    if (signatures.length !== message.header.numRequiredSignatures) {
-      throw new TransactionError(
-        "INVALID_SIGNATURE" /* INVALID_SIGNATURE */,
-        `Signature count (${signatures.length}) doesn't match required signers (${message.header.numRequiredSignatures})`
-      );
-    }
+// src/rpc/clients/query-client.ts
+var QueryRpcClient = class extends BaseRpcClient {
+  /**
+   * Retrieve the balance of an account in kelvins (smallest unit).
+   *
+   * @param pubkey - The public key of the account to query
+   * @returns The account balance in kelvins
+   *
+   * @example
+   * ```typescript
+   * const balance = await client.getBalance(publicKey);
+   * console.log(`Balance: ${balance} kelvins`);
+   * ```
+   */
+  async getBalance(pubkey) {
+    const result = await this.call("getBalance", [
+      { address: pubkey.toString() }
+    ]);
+    return BigInt(result.value);
   }
   /**
-   * Create an unsigned transaction from a message.
-   * All signature slots are initialized to zero.
+   * Retrieve detailed information about an account.
    *
-   * @internal - Users should use TransactionBuilder instead
+   * Returns account data including balance, owner program, stored data,
+   * executable status, and rent epoch.
+   *
+   * @param pubkey - The public key of the account to query
+   * @returns Account information, or null if the account does not exist
+   *
+   * @example
+   * ```typescript
+   * const info = await client.getAccountInfo(publicKey);
+   * if (info) {
+   *   console.log(`Owner: ${info.owner}`);
+   *   console.log(`Balance: ${info.balance} kelvins`);
+   *   console.log(`Data length: ${info.data.length} bytes`);
+   * }
+   * ```
    */
-  static fromMessage(message) {
-    const numSignatures = message.header.numRequiredSignatures;
-    const signatures = Array.from(
-      { length: numSignatures },
-      () => new Uint8Array(SIGNATURE_LENGTH)
-    );
-    return new _Transaction(message, signatures);
+  async getAccountInfo(pubkey) {
+    const result = await this.call("getAccountInfo", [{ address: pubkey.toString(), encoding: "base64" }]);
+    if (!result.value) {
+      return null;
+    }
+    return {
+      balance: BigInt(result.value.balance),
+      owner: PublicKey.fromString(result.value.owner),
+      data: fromBase64(result.value.data),
+      executable: result.value.executable,
+      rentEpoch: BigInt(result.value.rentEpoch)
+    };
   }
   /**
-   * Create transaction from message and existing signatures.
-   * @internal
+   * Retrieve the current block height of the blockchain.
+   *
+   * The block height represents the number of blocks that have been
+   * confirmed on the chain since genesis.
+   *
+   * @returns The current block height
+   *
+   * @example
+   * ```typescript
+   * const height = await client.getBlockHeight();
+   * console.log(`Current block height: ${height}`);
+   * ```
    */
-  static fromMessageAndSignatures(message, signatures) {
-    return new _Transaction(message, signatures);
+  async getBlockHeight() {
+    const result = await this.call("getBlockHeight", []);
+    return BigInt(result);
   }
   /**
-   * Deserialize a transaction from wire format.
+   * Retrieve detailed information about a confirmed transaction.
+   *
+   * Returns transaction metadata including the block height it was
+   * confirmed in and any execution errors.
+   *
+   * @param signature - The transaction signature to query
+   * @returns Transaction information, or null if the transaction is not found
+   *
+   * @example
+   * ```typescript
+   * const tx = await client.getTransaction(signature);
+   * if (tx) {
+   *   console.log(`Confirmed in block: ${tx.blockHeight}`);
+   *   if (tx.err) {
+   *     console.log(`Transaction failed: ${tx.err}`);
+   *   }
+   * }
+   * ```
    */
-  static deserialize(data) {
-    if (data.length === 0) {
-      throw new TransactionError(
-        "SERIALIZATION_FAILED" /* SERIALIZATION_FAILED */,
-        "Cannot deserialize empty transaction data"
-      );
-    }
-    let cursor = 0;
-    const [signaturesLength, newCursor] = deserializeCompactU16(data, cursor);
-    cursor = newCursor;
-    const signatures = [];
-    for (let i = 0; i < signaturesLength; i++) {
-      if (data.length < cursor + SIGNATURE_LENGTH) {
-        throw new TransactionError(
-          "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-          `Insufficient data for signature ${i}: need ${SIGNATURE_LENGTH} bytes at offset ${cursor}`
-        );
-      }
-      const signature = data.slice(cursor, cursor + SIGNATURE_LENGTH);
-      signatures.push(signature);
-      cursor += SIGNATURE_LENGTH;
-    }
-    if (cursor >= data.length) {
-      throw new TransactionError(
-        "INSUFFICIENT_DATA" /* INSUFFICIENT_DATA */,
-        "No message data found after signatures"
-      );
+  async getTransaction(signature) {
+    const result = await this.call("getTransaction", [signature]);
+    if (!result) {
+      return null;
     }
-    const messageBytes = data.slice(cursor);
-    const message = Message.deserialize(messageBytes);
-    return new _Transaction(message, signatures);
+    return {
+      signature,
+      blockHeight: BigInt(result.block_height ?? 0),
+      err: result.err ?? result.meta?.err ?? void 0
+    };
   }
-  getMessage() {
-    return this.message;
+  /**
+   * Retrieve the total number of transactions processed since genesis.
+   *
+   * @returns The total transaction count
+   *
+   * @example
+   * ```typescript
+   * const count = await client.getTransactionCount();
+   * console.log(`Total transactions: ${count}`);
+   * ```
+   */
+  async getTransactionCount() {
+    const result = await this.call("getTransactionCount", []);
+    return BigInt(result);
   }
   /**
-   * Sign the transaction with a keypair.
-   * Returns a NEW Transaction instance.
+   * Retrieve the status of multiple transaction signatures in a single request.
    *
-   * @param keypair - Keypair to sign with
-   * @returns New Transaction instance with signature added
+   * Useful for batch-checking transaction confirmations. Returns null for
+   * signatures that are not found or have expired from the status cache.
+   *
+   * @param signatures - Array of transaction signatures to query
+   * @returns Array of signature statuses (null if signature not found)
    *
    * @example
    * ```typescript
-   * const signedTx = tx.sign(keypair);
-   * await client.sendTransaction(signedTx.serialize());
+   * const statuses = await client.getSignatureStatuses([sig1, sig2, sig3]);
+   * statuses.forEach((status, i) => {
+   *   if (status) {
+   *     console.log(`${signatures[i]}: slot ${status.slot}, executed: ${status.executed}`);
+   *   } else {
+   *     console.log(`${signatures[i]}: not found`);
+   *   }
+   * });
    * ```
    */
-  sign(keypair) {
-    const messageBytes = this.message.serialize();
-    const signature = keypair.sign(messageBytes);
-    return this.addSignatureForPubkey(keypair.publicKey, signature);
+  async getSignatureStatuses(signatures) {
+    const result = await this.call("getSignatureStatuses", [signatures]);
+    return result.value.map((status) => {
+      if (!status) {
+        return null;
+      }
+      return {
+        slot: BigInt(status.slot),
+        executed: status.executed,
+        err: status.err
+      };
+    });
+  }
+  /**
+   * Retrieve information about the current epoch.
+   *
+   * Returns epoch metadata including the current epoch number, slot position
+   * within the epoch, total slots per epoch, and current block height.
+   *
+   * @returns Current epoch information
+   *
+   * @example
+   * ```typescript
+   * const info = await client.getEpochInfo();
+   * console.log(`Epoch: ${info.epoch}`);
+   * console.log(`Slot ${info.slotIndex} of ${info.slotsInEpoch}`);
+   * console.log(`Block height: ${info.blockHeight}`);
+   * ```
+   */
+  async getEpochInfo() {
+    const result = await this.call("getEpochInfo", []);
+    return {
+      epoch: BigInt(result.epoch),
+      slotIndex: BigInt(result.slotIndex),
+      slotsInEpoch: BigInt(result.slotsInEpoch),
+      absoluteSlot: BigInt(result.absoluteSlot),
+      blockHeight: BigInt(result.blockHeight),
+      transactionCount: result.transactionCount ? BigInt(result.transactionCount) : void 0
+    };
   }
   /**
-   * Sign with multiple keypairs at once.
-   * Returns a NEW Transaction instance.
+   * Check the health status of the RPC node.
+   *
+   * Returns "ok" if the node is healthy. If the node is unhealthy,
+   * returns an error message describing the issue.
+   *
+   * @returns "ok" if healthy, otherwise an error message
    *
    * @example
    * ```typescript
-   * const signed = tx.signAll([keypair1, keypair2, keypair3]);
+   * const health = await client.getHealth();
+   * if (health === "ok") {
+   *   console.log("Node is healthy");
+   * } else {
+   *   console.log(`Node unhealthy: ${health}`);
+   * }
    * ```
    */
-  signAll(keypairs) {
-    let result = this;
-    for (const keypair of keypairs) {
-      result = result.sign(keypair);
-    }
+  async getHealth() {
+    const result = await this.call("getHealth", []);
     return result;
   }
+};
+
+// src/rpc/clients/transaction-client.ts
+var DEFAULT_MAX_RETRIES = 10;
+var DEFAULT_RETRY_DELAY_MS = 200;
+var TransactionRpcClient = class extends BaseRpcClient {
   /**
-   * Sign the transaction with a Signer interface (async).
-   * Returns a NEW Transaction instance.
+   * Submit a signed transaction to the blockchain.
+   *
+   * Sends the transaction to the network for processing. The transaction
+   * must be fully signed before submission. Returns immediately with the
+   * transaction signature - use {@link confirmTransaction} or
+   * {@link sendAndConfirmTransaction} to wait for confirmation.
+   *
+   * @param transaction - Serialized signed transaction bytes
+   * @param options - Transaction submission options
+   * @returns Transaction signature (base58 encoded)
    *
    * @example
    * ```typescript
-   * const signedTx = await tx.signWith(browserWallet);
+   * const signature = await client.sendTransaction(signedTx);
+   * console.log(`Submitted: ${signature}`);
+   *
+   * // With options
+   * const signature = await client.sendTransaction(signedTx, {
+   *   skipPreflight: true,
+   *   maxRetries: 3,
+   * });
    * ```
    */
-  async signWith(signer) {
-    const pubkey = await signer.getPublicKey();
-    const messageBytes = this.message.serialize();
-    const signature = await signer.signMessage(messageBytes);
-    return this.addSignatureForPubkey(pubkey, signature);
+  async sendTransaction(transaction, options) {
+    const base64Tx = toBase64(transaction);
+    const config = {
+      encoding: "base64",
+      skipPreflight: options?.skipPreflight ?? false,
+      maxRetries: options?.maxRetries ?? 5
+    };
+    const signature = await this.call("sendTransaction", [
+      base64Tx,
+      config
+    ]);
+    return signature;
   }
   /**
-   * Sign with multiple signers.
-   * Returns a NEW Transaction instance.
+   * Wait for a transaction to be confirmed.
+   *
+   * A transaction is considered confirmed when:
+   * - It has been processed in a block (`blockHeight > 0`)
+   *
+   * @param signature - Transaction signature to monitor
+   * @param options - Confirmation options
+   * @returns Confirmed transaction details
+   * @throws {TransactionFailedError} If the transaction fails on-chain
+   * @throws {TransactionConfirmationTimeoutError} If confirmation times out
    */
-  async signAllWith(signers) {
-    let result = this;
-    for (const signer of signers) {
-      result = await result.signWith(signer);
+  async confirmTransaction(signature, options) {
+    const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const retryDelay = options?.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      if (attempt > 0) {
+        await this.sleep(retryDelay);
+      }
+      try {
+        const txInfo = await this.getTransaction(signature);
+        if (!txInfo) {
+          continue;
+        }
+        if (txInfo.err) {
+          return {
+            signature,
+            executed: false,
+            err: txInfo.err
+          };
+        }
+        if (txInfo.blockHeight && txInfo.blockHeight > 0n) {
+          return {
+            signature,
+            executed: true,
+            err: void 0
+          };
+        }
+      } catch (error) {
+        if (error instanceof RpcError && error.code === "TRANSACTION_REJECTED" /* TRANSACTION_REJECTED */) {
+          throw error;
+        }
+      }
     }
-    return result;
+    throw new RpcError(
+      "TRANSACTION_CONFIRMATION_TIMEOUT" /* TRANSACTION_CONFIRMATION_TIMEOUT */,
+      "Transaction confirmation timed out",
+      {
+        signature,
+        maxRetries
+      }
+    );
   }
   /**
-   * Partially sign the transaction (for multi-sig transactions).
-   * Returns a NEW Transaction instance.
+   * Submit a signed transaction and wait for confirmation.
+   *
+   * Polls the transaction status until it is confirmed (blockHeight > 0),
+   * or until the maximum number of retries is reached.
+   *
+   * @param transaction - Serialized signed transaction bytes
+   * @param options - Transaction submission and confirmation options
+   * @returns Confirmed transaction details
+   * @throws {TransactionFailedError} If the transaction fails on-chain
+   * @throws {TransactionConfirmationTimeoutError} If confirmation times out
    *
    * @example
    * ```typescript
-   * const signedTx = tx
-   *   .partialSign(signer1)
-   *   .partialSign(signer2);
+   * const result = await client.sendAndConfirmTransaction(signedTx);
+   * console.log(`Confirmed in block ${result.blockHeight}, executed: ${result.executed}`);
+   *
+   * // With custom retry settings
+   * const result = await client.sendAndConfirmTransaction(signedTx, {
+   *   maxRetries: 3,
+   *   retryDelay: 500,
+   * });
    * ```
    */
-  partialSign(keypair) {
-    return this.sign(keypair);
-  }
-  /**
-   * Partially sign with a Signer interface (async).
-   * Returns a NEW Transaction instance.
-   */
-  async partialSignWith(signer) {
-    return this.signWith(signer);
+  async sendAndConfirmTransaction(transaction, options) {
+    const signature = await this.sendTransaction(transaction, options);
+    return await this.confirmTransaction(signature, options);
   }
   /**
-   * Add a signature at a specific index.
-   * Returns a NEW Transaction instance.
+   * Request an airdrop of tokens to an account.
    *
-   * Most users should use sign() or signAll() instead.
+   * **Note**: Only available on devnet and testnet networks.
+   *
+   * Returns immediately with the airdrop transaction signature.
+   * Use {@link requestAirdropAndConfirm} to wait for the airdrop to complete.
+   *
+   * @param pubkey - The public key of the account to receive tokens
+   * @param amount - Amount to airdrop in kelvins (smallest unit)
+   * @returns Airdrop transaction signature
+   *
+   * @example
+   * ```typescript
+   * const signature = await client.requestAirdrop(publicKey, 1_000_000_000n);
+   * console.log(`Airdrop requested: ${signature}`);
+   * ```
    */
-  addSignature(index, signature) {
-    if (index < 0 || index >= this.signatures.length) {
-      throw new TransactionError(
-        "SIGNATURE_OUT_OF_BOUNDS" /* SIGNATURE_OUT_OF_BOUNDS */,
-        `Signature index ${index} out of bounds (must be 0-${this.signatures.length - 1})`
-      );
-    }
-    const sigBytes = signature instanceof Uint8Array ? signature : signature.toBytes();
-    if (sigBytes.length !== SIGNATURE_LENGTH) {
-      throw new TransactionError(
-        "INVALID_SIGNATURE" /* INVALID_SIGNATURE */,
-        `Signature must be ${SIGNATURE_LENGTH} bytes, got ${sigBytes.length}`
+  async requestAirdrop(pubkey, amount) {
+    if (amount > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new RpcError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        `Airdrop amount ${amount} exceeds maximum safe value`
       );
     }
-    const newSignatures = this.signatures.map(
-      (sig, i) => i === index ? new Uint8Array(sigBytes) : new Uint8Array(sig)
-    );
-    return new _Transaction(this.message, newSignatures);
+    const signature = await this.call("requestAirdrop", [
+      pubkey.toString(),
+      Number(amount)
+    ]);
+    return signature;
   }
   /**
-   * Add a signature for a specific public key.
-   * Returns a NEW Transaction instance.
+   * Request an airdrop of tokens and wait for confirmation.
    *
-   * Most users should use sign() or signAll() instead.
+   * **Note**: Only available on devnet and testnet networks.
+   *
+   * Combines {@link requestAirdrop} and {@link confirmTransaction} into
+   * a single call for convenience.
+   *
+   * @param pubkey - The public key of the account to receive tokens
+   * @param amount - Amount to airdrop in kelvins (smallest unit)
+   * @param options - Confirmation options (max retries, retry delay)
+   * @returns Confirmed transaction details
+   * @throws {RpcError} If the airdrop transaction fails or confirmation times out
+   *
+   * @example
+   * ```typescript
+   * const result = await client.requestAirdropAndConfirm(publicKey, 1_000_000_000n);
+   * if (result.executed) {
+   *   console.log("Airdrop confirmed!");
+   * }
+   * ```
    */
-  addSignatureForPubkey(pubkey, signature) {
-    const signerIndex = this.message.getSignerIndex(pubkey);
-    if (signerIndex === -1) {
-      throw TransactionError.signerNotFound(pubkey.toString());
+  async requestAirdropAndConfirm(pubkey, amount, options) {
+    const signature = await this.requestAirdrop(pubkey, amount);
+    return await this.confirmTransaction(signature, options);
+  }
+  async getTransaction(signature) {
+    const result = await this.call("getTransaction", [signature]);
+    if (!result) {
+      return null;
     }
-    return this.addSignature(signerIndex, signature);
+    return {
+      signature,
+      blockHeight: BigInt(result.block_height ?? 0),
+      err: result.err ?? result.meta?.err ?? void 0
+    };
   }
   /**
-   * Check if transaction is fully signed (all signatures present).
+   * Sleeps for a given number of milliseconds.
+   * @param ms - The number of milliseconds to sleep.
+   * @returns A promise that resolves when the sleep is complete.
    */
-  isSigned() {
-    return this.signatures.every((sig) => sig.some((byte) => byte !== 0));
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/rpc/clients/client.ts
+var RialoClient = class {
+  queryClient;
+  transactionClient;
+  transport;
+  chain;
+  constructor(transport, chain2) {
+    this.chain = chain2;
+    this.transport = transport;
+    this.queryClient = new QueryRpcClient(transport);
+    this.transactionClient = new TransactionRpcClient(transport);
   }
   /**
-   * Check if a specific signature slot is filled.
+   * Returns the configured RPC endpoint URL.
    */
-  isSignaturePresent(index) {
-    if (index < 0 || index >= this.signatures.length) {
-      return false;
-    }
-    return this.signatures[index].some((byte) => byte !== 0);
+  getUrl() {
+    return this.transport.getUrl();
   }
   /**
-   * Get all signatures (returns copies to prevent mutation).
+   * Returns the chain identifier.
    */
-  getSignatures() {
-    return this.signatures.map((sig) => new Uint8Array(sig));
+  getChainIdentifier() {
+    return this.chain.id;
   }
   /**
-   * Get a specific signature (returns copy).
+   * Returns the chain configuration.
    */
-  getSignature(index) {
-    if (index < 0 || index >= this.signatures.length) {
-      throw new TransactionError(
-        "SIGNATURE_OUT_OF_BOUNDS" /* SIGNATURE_OUT_OF_BOUNDS */,
-        `Signature index ${index} out of bounds`
-      );
-    }
-    return new Uint8Array(this.signatures[index]);
+  getChainConfig() {
+    return this.chain;
   }
   /**
-   * Get a specific signature for a public key.
+   * Retrieves the balance of an account in kelvins (smallest unit).
    */
-  getSignatureForPubkey(pubkey) {
-    const signerIndex = this.message.getSignerIndex(pubkey);
-    if (signerIndex === -1) {
-      throw TransactionError.signerNotFound(pubkey.toString());
-    }
-    return this.getSignature(signerIndex);
+  async getBalance(pubkey) {
+    return await this.queryClient.getBalance(pubkey);
   }
   /**
-   * Get required signers for this transaction.
+   * Retrieves detailed information about an account.
+   *
+   * @returns Account info or null if account doesn't exist
    */
-  getSigners() {
-    return this.message.getSigners();
+  async getAccountInfo(pubkey) {
+    return await this.queryClient.getAccountInfo(pubkey);
   }
   /**
-   * Get the number of required signatures.
+   * Retrieves the current block height.
    */
-  getRequiredSignatureCount() {
-    return this.message.header.numRequiredSignatures;
+  async getBlockHeight() {
+    return await this.queryClient.getBlockHeight();
   }
   /**
-   * Throw an error if the transaction is not fully signed.
-   *
-   * @throws {TransactionError} If transaction is not fully signed
+   * Retrieves detailed information about a transaction.
    *
-   * @example
-   * ```typescript
-   * signedTx.ensureSigned(); // Throws if not signed
-   * await client.sendTransaction(signedTx.serialize());
-   * ```
+   * @returns Transaction info or null if transaction not found
    */
-  ensureSigned() {
-    if (!this.isSigned()) {
-      const missingIndices = this.signatures.map((sig, i) => ({ sig, i })).filter(({ sig }) => !sig.some((byte) => byte !== 0)).map(({ i }) => i);
-      const signers = this.getSigners();
-      const missingSigners = missingIndices.map((i) => signers[i].toString());
-      throw new TransactionError(
-        "MISSING_SIGNATURE" /* MISSING_SIGNATURE */,
-        `Transaction is not fully signed. Missing signatures for: ${missingSigners.join(", ")}`,
-        { missingIndices, missingSigners }
-      );
-    }
+  async getTransaction(signature) {
+    return await this.queryClient.getTransaction(signature);
   }
   /**
-   * Serialize transaction to wire format.
+   * Retrieves the total number of transactions processed since genesis.
    */
-  serialize() {
-    const compactU16Size = this.signatures.length < 128 ? 1 : 2;
-    const sigsSize = compactU16Size + this.signatures.length * SIGNATURE_LENGTH;
-    const messageBytes = this.message.serialize();
-    const totalSize = sigsSize + messageBytes.length;
-    const buffer = new Uint8Array(totalSize);
-    let offset = 0;
-    offset = writeCompactU16(buffer, offset, this.signatures.length);
-    for (const sig of this.signatures) {
-      buffer.set(sig, offset);
-      offset += SIGNATURE_LENGTH;
-    }
-    buffer.set(messageBytes, offset);
-    return buffer;
+  async getTransactionCount() {
+    return await this.queryClient.getTransactionCount();
   }
-};
-
-// src/transaction/transaction-builder.ts
-var TransactionBuilder = class _TransactionBuilder {
-  payer;
-  recentBlockhash;
-  txCreationTime;
-  instructions = [];
-  constructor() {
+  /**
+   * Retrieves the status of multiple transaction signatures.
+   */
+  async getSignatureStatuses(signatures) {
+    return await this.queryClient.getSignatureStatuses(signatures);
   }
   /**
-   * Create a new transaction builder.
+   * Retrieves current epoch information.
    */
-  static create() {
-    return new _TransactionBuilder();
+  async getEpochInfo() {
+    return await this.queryClient.getEpochInfo();
   }
   /**
-   * Set the fee payer for this transaction.
+   * Checks the health status of the RPC node.
    *
-   * The payer will be the first account and must sign the transaction.
-   * The payer pays for transaction fees.
+   * @returns "ok" if healthy, error message otherwise
+   */
+  async getHealth() {
+    return await this.queryClient.getHealth();
+  }
+  /**
+   * Submits a signed transaction to the blockchain.
    *
-   * @param payer - Public key of the fee payer
+   * @param transaction - Serialized signed transaction bytes
+   * @param options - Transaction submission options
+   * @returns Transaction signature
    */
-  setPayer(payer) {
-    this.payer = payer;
-    return this;
+  async sendTransaction(transaction, options) {
+    return await this.transactionClient.sendTransaction(transaction, options);
   }
   /**
-   * Set the recent blockhash for replay protection.
+   * Requests an airdrop of tokens to an account.
    *
-   * Get this from client.getLatestBlockhash().
-   * Transactions are only valid for ~60 seconds after the blockhash.
+   * **Note**: Only available on devnet and testnet.
    *
-   * @param blockhash - Recent blockhash from the network
+   * @param pubkey - Account to receive the airdrop
+   * @param amount - Amount in kelvins (smallest unit)
+   * @returns Transaction signature
    */
-  setRecentBlockhash(blockhash) {
-    this.recentBlockhash = blockhash;
-    return this;
+  async requestAirdrop(pubkey, amount) {
+    return await this.transactionClient.requestAirdrop(pubkey, amount);
   }
   /**
-   * Set the transaction creation timestamp.
+   * Submits a signed transaction and waits for confirmation.
    *
-   * This is the time the transaction was created, in milliseconds since Unix epoch.
-   * It can be used for additional replay protection or auditing.
+   * @param transaction - Serialized signed transaction bytes
+   * @param options - Transaction submission and confirmation options
+   * @returns Confirmed transaction details
+   * @throws {TransactionFailedError} If the transaction fails on-chain
+   * @throws {TransactionConfirmationTimeoutError} If confirmation times out
    *
-   * @param txCreationTime - Transaction creation time in milliseconds since Unix epoch
+   * @example
+   * ```typescript
+   * const result = await client.sendAndConfirmTransaction(signedTx);
+   * console.log(`Confirmed in slot ${result.slot}`);
+   * ```
    */
-  setTxCreationTime(txCreationTime) {
-    this.txCreationTime = txCreationTime;
-    return this;
+  async sendAndConfirmTransaction(transaction, options) {
+    return await this.transactionClient.sendAndConfirmTransaction(
+      transaction,
+      options
+    );
   }
   /**
-   * Add an instruction to the transaction.
+   * Waits for a transaction to be confirmed.
    *
-   * @param instruction - Instruction to add
+   * @param signature - Transaction signature to monitor
+   * @param options - Confirmation options
+   * @returns Confirmed transaction details
    */
-  addInstruction(instruction) {
-    this.instructions.push(instruction);
-    return this;
+  async confirmTransaction(signature, options) {
+    return await this.transactionClient.confirmTransaction(signature, options);
   }
   /**
-   * Add multiple instructions at once.
+   * Requests an airdrop and waits for confirmation.
    *
-   * @param instructions - Array of instructions to add
+   * **Note**: Only available on devnet and testnet.
    */
-  addInstructions(instructions) {
-    this.instructions.push(...instructions);
-    return this;
+  async requestAirdropAndConfirm(pubkey, amount, options) {
+    return await this.transactionClient.requestAirdropAndConfirm(
+      pubkey,
+      amount,
+      options
+    );
+  }
+};
+
+// src/rpc/http-transport.ts
+var DEFAULT_CONFIG = {
+  timeout: 3e4,
+  // 30 seconds
+  maxRetries: 3,
+  retryBaseDelay: 1e3,
+  // 1 second
+  retryMaxDelay: 3e4,
+  // 30 seconds
+  headers: {}
+};
+var HttpTransport = class {
+  url;
+  config;
+  constructor(url, config = {}) {
+    this.url = url;
+    this.config = { ...DEFAULT_CONFIG, ...config };
   }
   /**
-   * Build the transaction (unsigned).
-   *
-   * Returns an unsigned Transaction that's ready to be signed.
-   *
-   * @returns Unsigned Transaction
-   * @throws {TransactionError} If payer, blockhash, or instructions are missing
+   * Makes an HTTP request with automatic retry logic.
    *
-   * @example
-   * ```typescript
-   * const tx = builder.build();
-   * const signedTx = tx.sign(keypair);
-   * ```
+   * Retries are attempted for network errors and server errors (5xx).
+   * Uses exponential backoff between retry attempts.
    */
-  build() {
-    if (!this.payer) {
-      throw new TransactionError(
-        "INVALID_ACCOUNT_META" /* INVALID_ACCOUNT_META */,
-        "Transaction must have a fee payer. Use setPayer() to set the fee payer."
-      );
+  async request(body, requestDetails = {}) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+      try {
+        return await this.makeRequest(body, requestDetails, attempt);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof RpcError && !error.retryable) {
+          throw error;
+        }
+        if (attempt === this.config.maxRetries) {
+          throw error;
+        }
+        const delay = calculateBackoff(
+          attempt,
+          this.config.retryBaseDelay,
+          this.config.retryMaxDelay
+        );
+        await sleep(delay);
+      }
     }
-    if (!this.recentBlockhash) {
-      throw new TransactionError(
-        "INVALID_MESSAGE_FORMAT" /* INVALID_MESSAGE_FORMAT */,
-        "Transaction must have a recent blockhash. Use setRecentBlockhash() to set the blockhash."
-      );
+    throw lastError;
+  }
+  /**
+   * Make a single HTTP request with timeout
+   */
+  async makeRequest(body, requestDetails, attempt) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const options = {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        },
+        body,
+        signal: controller.signal
+      };
+      const response = await fetch(this.url, options);
+      if (!response.ok) {
+        throw await this.handleHttpError(response, requestDetails, attempt);
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw RpcError.requestTimeout(this.config.timeout, {
+          ...requestDetails,
+          url: this.url,
+          attempts: attempt + 1
+        });
+      }
+      if (error instanceof TypeError) {
+        throw RpcError.networkError(error.message, {
+          ...requestDetails,
+          url: this.url,
+          attempts: attempt + 1,
+          cause: error.message
+        });
+      }
+      if (error instanceof RpcError) {
+        throw error;
+      }
+      throw RpcError.networkError("Unknown network error", {
+        ...requestDetails,
+        url: this.url,
+        attempts: attempt + 1,
+        cause: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      clearTimeout(timeoutId);
     }
-    if (!this.txCreationTime) {
-      throw new TransactionError(
-        "INVALID_MESSAGE_FORMAT" /* INVALID_MESSAGE_FORMAT */,
-        "Transaction must have a creation timestamp. Use setTxCreationTime() to set the creation time."
-      );
+  }
+  /**
+   * Handle HTTP error responses.
+   *
+   * Parses the response body to extract JSON-RPC error details when available,
+   * regardless of HTTP status code. Falls back to HTTP status-based error handling.
+   */
+  async handleHttpError(response, requestDetails, attempt) {
+    const status = response.status;
+    const isRetryable = status >= 500 || status === 429;
+    const baseDetails = {
+      ...requestDetails,
+      httpStatus: status,
+      url: this.url,
+      attempts: attempt + 1
+    };
+    const { message, rpcCode, errorData } = await this.parseErrorResponse(
+      response,
+      status
+    );
+    if (status === 429) {
+      return RpcError.rateLimitExceeded({
+        ...baseDetails,
+        serverError: errorData
+      });
     }
-    if (this.instructions.length === 0) {
-      throw TransactionError.noInstructions();
+    if (rpcCode !== void 0) {
+      return RpcError.fromRpcCode(rpcCode, message, {
+        ...baseDetails,
+        serverError: errorData
+      });
     }
-    const accountTable = new AccountMetaTable();
-    accountTable.add({
-      pubkey: this.payer,
-      isSigner: true,
-      isWritable: true
-    });
-    for (const instruction of this.instructions) {
-      accountTable.addAll(instruction.accounts);
-      accountTable.add({
-        pubkey: instruction.programId,
-        isSigner: false,
-        isWritable: false
+    if (status >= 500) {
+      return RpcError.networkError(message, {
+        ...baseDetails,
+        serverError: errorData
       });
     }
-    const accountKeys = accountTable.getPublicKeys();
-    const header = accountTable.getHeader();
-    const compiledInstructions = this.instructions.map((instruction) => {
-      const programIdIndex = accountTable.getIndex(instruction.programId);
-      if (programIdIndex === -1) {
-        throw new TransactionError(
-          "INVALID_INSTRUCTION" /* INVALID_INSTRUCTION */,
-          `Program ID ${instruction.programId.toString()} not found in account table`
-        );
-      }
-      const accountKeyIndexes = instruction.accounts.map((meta) => {
-        const index = accountTable.getIndex(meta.pubkey);
-        if (index === -1) {
-          throw new TransactionError(
-            "INVALID_INSTRUCTION" /* INVALID_INSTRUCTION */,
-            `Account ${meta.pubkey.toString()} not found in account table`
-          );
+    return new RpcError("NETWORK_ERROR" /* NETWORK_ERROR */, message, baseDetails, isRetryable);
+  }
+  /**
+   * Parse error response body to extract message and RPC error code.
+   *
+   * Handles multiple formats:
+   * - JSON-RPC error: { error: { code, message, data? } }
+   * - Simple JSON: { message: "..." }
+   * - Non-JSON responses
+   */
+  async parseErrorResponse(response, status) {
+    let message = `HTTP ${status}: ${response.statusText}`;
+    let rpcCode;
+    let errorData;
+    try {
+      errorData = await response.json();
+      if (errorData && typeof errorData === "object") {
+        const data = errorData;
+        if (data.error && typeof data.error === "object" && "message" in data.error) {
+          const rpcError = data.error;
+          message = String(rpcError.message);
+          rpcCode = typeof rpcError.code === "number" ? rpcError.code : void 0;
+        } else if ("message" in data) {
+          message = String(data.message);
         }
-        return index;
-      });
-      const compiled = {
-        programIdIndex,
-        accountKeyIndexes: Object.freeze(accountKeyIndexes),
-        data: instruction.data
-      };
-      return compiled;
-    });
-    const message = new Message(
-      header,
-      accountKeys,
-      this.recentBlockhash,
-      this.txCreationTime,
-      compiledInstructions
-    );
-    return Transaction.fromMessage(message);
+      }
+    } catch {
+    }
+    return { message, rpcCode, errorData };
+  }
+  /**
+   * Returns the configured RPC endpoint URL.
+   */
+  getUrl() {
+    return this.url;
   }
 };
 
+// src/rpc/index.ts
+function createRialoClient(config) {
+  const { chain: chain2, transport } = config;
+  const httpTransport = new HttpTransport(chain2.rpcUrl, transport);
+  return new RialoClient(httpTransport, chain2);
+}
+function getDefaultRialoClientConfig(network) {
+  switch (network) {
+    case "mainnet":
+      return { chain: RIALO_MAINNET_CHAIN };
+    case "devnet":
+      return { chain: RIALO_DEVNET_CHAIN };
+    case "testnet":
+      return { chain: RIALO_TESTNET_CHAIN };
+    case "localnet":
+      return { chain: RIALO_LOCALNET_CHAIN };
+    default:
+      throw new RpcError(
+        "INVALID_NETWORK" /* INVALID_NETWORK */,
+        `Unknown network: ${network}`
+      );
+  }
+}
+
 // src/signer/keypair-signer.ts
 var KeypairSigner = class {
   constructor(keypair) {
@@ -7291,9 +7576,6 @@ var KeypairSigner = class {
 };
 /*! Bundled license information:
 
-@scure/base/index.js:
-  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
 @noble/ed25519/index.js:
   (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
 
@@ -7301,15 +7583,16 @@ var KeypairSigner = class {
 @noble/hashes/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
+@scure/base/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
 @scure/bip39/index.js:
   (*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
 
 exports.AccountMetaTable = AccountMetaTable;
 exports.BASE_DERIVATION_PATH = BASE_DERIVATION_PATH;
-exports.BLOCKHASH_LENGTH = BLOCKHASH_LENGTH;
 exports.BaseRpcClient = BaseRpcClient;
-exports.Blockhash = Blockhash;
 exports.CryptoError = CryptoError;
 exports.CryptoErrorCode = CryptoErrorCode;
 exports.DEFAULT_NUM_ACCOUNTS = DEFAULT_NUM_ACCOUNTS;
@@ -7322,6 +7605,10 @@ exports.Mnemonic = Mnemonic;
 exports.PUBLIC_KEY_LENGTH = PUBLIC_KEY_LENGTH;
 exports.PublicKey = PublicKey;
 exports.QueryRpcClient = QueryRpcClient;
+exports.RIALO_DEVNET_CHAIN = RIALO_DEVNET_CHAIN;
+exports.RIALO_LOCALNET_CHAIN = RIALO_LOCALNET_CHAIN;
+exports.RIALO_MAINNET_CHAIN = RIALO_MAINNET_CHAIN;
+exports.RIALO_TESTNET_CHAIN = RIALO_TESTNET_CHAIN;
 exports.RialoClient = RialoClient;
 exports.RialoError = RialoError;
 exports.RialoErrorType = RialoErrorType;
@@ -7347,6 +7634,7 @@ exports.createBorshInstruction = createBorshInstruction;
 exports.createRialoClient = createRialoClient;
 exports.encodeBorshData = encodeBorshData;
 exports.fromBase64 = fromBase64;
+exports.getDefaultRialoClientConfig = getDefaultRialoClientConfig;
 exports.getDevnetUrl = getDevnetUrl;
 exports.getLocalnetUrl = getLocalnetUrl;
 exports.getMainnetUrl = getMainnetUrl;