@opeqlabs/sdk 0.0.0-stage → 0.1.0

package/src/lib/protocol.js

@@ -0,0 +1,129 @@
+import { Sha256, sha256 } from "./sha256.js";
+import { N, LEAVES, verifyCost } from "./wots.js";
+import { concat, findPda, u32, u64 } from "./solana.js";
+
+const enc = new TextEncoder();
+
+export const IX_INIT = 0, IX_EXEC = 1, IX_REKEY = 2;
+export const STATE_MAGIC = "OPEQST01";
+export const STATE_LEN = 88;
+export const F_SIGNER = 1, F_WRITABLE = 2;
+export const R_LEN = 16;
+export const REKEY_RESERVE = 16;
+export const EXEC_LEAF_LIMIT = LEAVES - REKEY_RESERVE;
+export const GRIND_TRIES = 1 << 17;
+export const SALT_OFF = 13, R_OFF = 17, SIG_OFF = 33;
+export const TAG_EXEC = enc.encode("opeq/exec/v1");
+export const TAG_REKEY = enc.encode("opeq/rekey/v1");
+
+export const ERRORS = {
+  1: "bad instruction", 2: "too many accounts", 3: "state not owned by program", 4: "bad state account",
+  5: "wallet/state address mismatch", 6: "signature expired", 7: "leaf already used", 8: "leaf out of range",
+  9: "self cpi", 10: "bad meta flags", 11: "signer escalation", 12: "malformed inner instructions",
+  13: "bad signature", 14: "state not writable", 15: "init address mismatch", 16: "too many slices",
+  17: "account index out of range", 18: "payer must sign", 19: "already initialized", 20: "bad system program",
+  21: "too many metas", 22: "rekey to the current root", 23: "expiry too far in the future",
+};
+
+export function accountId(pubSeed, root) {
+  return sha256(enc.encode("opeq/id/v1"), pubSeed, root);
+}
+
+export const statePda = (aid, program) => findPda([enc.encode("s"), aid], program);
+export const walletPda = (aid, program) => findPda([enc.encode("w"), aid], program);
+
+function leafEpochExpiry(epoch, leaf, expiry) {
+  return concat(u32(epoch), u32(leaf), u64(expiry));
+}
+
+export function execHasher(program, aid, epoch, leaf, expiry, inner, r) {
+  checkInner(inner);
+  if (r.length !== N) throw new Error("randomizer must be 16 bytes");
+  const h = new Sha256();
+  h.update(r).update(TAG_EXEC).update(program).update(aid).update(leafEpochExpiry(epoch, leaf, expiry));
+  h.update(new Uint8Array([inner.length]));
+  for (const [prog, metas, data] of inner) {
+    h.update(prog).update(new Uint8Array([metas.length]));
+    for (const [key, signer, writable] of metas) {
+      h.update(key).update(new Uint8Array([(signer ? F_SIGNER : 0) | (writable ? F_WRITABLE : 0)]));
+    }
+    h.update(new Uint8Array([data.length & 0xff, data.length >> 8])).update(data);
+  }
+  return h;
+}
+
+export function rekeyHasher(program, aid, epoch, leaf, expiry, newPubSeed, newRoot, r) {
+  if (r.length !== N) throw new Error("randomizer must be 16 bytes");
+  return new Sha256().update(r).update(TAG_REKEY).update(program).update(aid)
+    .update(leafEpochExpiry(epoch, leaf, expiry)).update(newPubSeed).update(newRoot);
+}
+
+export function salted(hasher, salt) {
+  return hasher.clone().update(u32(salt)).digest().slice(0, N);
+}
+
+export function grind(hasher, tries = GRIND_TRIES, progress) {
+  let best = null;
+  const sb = new Uint8Array(4);
+  for (let salt = 0; salt < tries; salt++) {
+    sb[0] = salt & 0xff; sb[1] = (salt >>> 8) & 0xff; sb[2] = (salt >>> 16) & 0xff; sb[3] = salt >>> 24;
+    const d = hasher.clone().update(sb).digest().slice(0, N);
+    const c = verifyCost(d);
+    if (!best || c < best.cost) best = { salt, digest: d, cost: c };
+    if (progress && (salt & 8191) === 8191) progress((salt + 1) / tries);
+  }
+  return best;
+}
+
+function header(tag, leaf, expiry, salt, r) {
+  return concat(new Uint8Array([tag]), u32(leaf), u64(expiry), u32(salt), r);
+}
+
+function checkInner(inner) {
+  if (inner.length > 255) throw new Error("too many inner instructions");
+  for (const [, metas, data] of inner) {
+    if (metas.length > 64) throw new Error("too many accounts in an inner instruction");
+    if (data.length > 0xffff) throw new Error("inner instruction data too long");
+  }
+}
+
+export function buildExec(leaf, expiry, salt, r, sig, path, inner, outerKeys) {
+  checkInner(inner);
+  const pos = new Map(outerKeys.map((k, i) => [k.join(","), i]));
+  const at = (k) => { const i = pos.get(k.join(",")); if (i === undefined || i > 255) throw new Error("inner instruction key missing from the transaction"); return i; };
+  const parts = [header(IX_EXEC, leaf, expiry, salt, r), sig, path, new Uint8Array([inner.length])];
+  for (const [prog, metas, data] of inner) {
+    parts.push(new Uint8Array([at(prog), metas.length]));
+    for (const [key, signer, writable] of metas) {
+      parts.push(new Uint8Array([at(key), (signer ? F_SIGNER : 0) | (writable ? F_WRITABLE : 0)]));
+    }
+    parts.push(new Uint8Array([data.length & 0xff, data.length >> 8]), data);
+  }
+  return concat(...parts);
+}
+
+export function buildRekey(leaf, expiry, salt, r, sig, path, newPubSeed, newRoot) {
+  return concat(header(IX_REKEY, leaf, expiry, salt, r), sig, path, newPubSeed, newRoot);
+}
+
+export function buildInit(pubSeed, root, lamports) {
+  return concat(new Uint8Array([IX_INIT]), pubSeed, root, u64(lamports));
+}
+
+export function unpackState(data) {
+  if (data.length < STATE_LEN || new TextDecoder().decode(data.slice(0, 8)) !== STATE_MAGIC) throw new Error("not an opeq state account");
+  const dv = new DataView(data.buffer, data.byteOffset);
+  return {
+    id: data.slice(8, 40), pubSeed: data.slice(40, 56), root: data.slice(56, 72),
+    next: dv.getUint32(72, true), epoch: dv.getUint32(76, true), sbump: data[80], wbump: data[81],
+  };
+}
+
+export function outerLayout(state, wallet, inner) {
+  const outer = [state, wallet];
+  const has = (k) => outer.some((o) => o.join(",") === k.join(","));
+  for (const [prog, metas] of inner) for (const k of [prog, ...metas.map((m) => m[0])]) if (!has(k)) outer.push(k);
+  const writable = new Set([state.join(","), wallet.join(",")]);
+  for (const [, metas] of inner) for (const [k, , w] of metas) if (w) writable.add(k.join(","));
+  return { outer, metas: outer.map((k) => [k, false, writable.has(k.join(","))]) };
+}

package/src/lib/secp256k1.js

@@ -0,0 +1,123 @@
+import { sha256 } from "./sha256.js";
+import { keccak256 } from "./keccak.js";
+
+const P = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
+const N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;
+const GX = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n;
+const GY = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n;
+const enc = new TextEncoder();
+
+const mod = (a, m = P) => { const r = a % m; return r < 0n ? r + m : r; };
+
+function inv(a, m = P) {
+  let [r0, r1, t0, t1] = [mod(a, m), m, 1n, 0n];
+  while (r1 !== 0n) {
+    const q = r0 / r1;
+    [r0, r1] = [r1, r0 - q * r1];
+    [t0, t1] = [t1, t0 - q * t1];
+  }
+  if (r0 !== 1n) throw new Error("no inverse");
+  return mod(t0, m);
+}
+
+function dbl([x, y, z]) {
+  if (y === 0n || z === 0n) return [0n, 1n, 0n];
+  const a = mod(x * x), b = mod(y * y), c = mod(b * b);
+  const d = mod(2n * (mod((x + b) * (x + b)) - a - c));
+  const e = mod(3n * a), f = mod(e * e);
+  const x3 = mod(f - 2n * d);
+  return [x3, mod(e * (d - x3) - 8n * c), mod(2n * y * z)];
+}
+
+function add(p1, p2) {
+  if (p1[2] === 0n) return p2;
+  if (p2[2] === 0n) return p1;
+  const [x1, y1, z1] = p1, [x2, y2, z2] = p2;
+  const z1z1 = mod(z1 * z1), z2z2 = mod(z2 * z2);
+  const u1 = mod(x1 * z2z2), u2 = mod(x2 * z1z1);
+  const s1 = mod(y1 * z2 * z2z2), s2 = mod(y2 * z1 * z1z1);
+  if (u1 === u2) return s1 === s2 ? dbl(p1) : [0n, 1n, 0n];
+  const h = mod(u2 - u1), i = mod(4n * h * h), j = mod(h * i), r = mod(2n * (s2 - s1)), v = mod(u1 * i);
+  const x3 = mod(r * r - j - 2n * v);
+  return [x3, mod(r * (v - x3) - 2n * s1 * j), mod((mod((z1 + z2) * (z1 + z2)) - z1z1 - z2z2) * h)];
+}
+
+function mul(k, pt = [GX, GY, 1n]) {
+  let acc = [0n, 1n, 0n];
+  for (let i = 255; i >= 0; i--) {
+    acc = dbl(acc);
+    if ((k >> BigInt(i)) & 1n) acc = add(acc, pt);
+  }
+  return acc;
+}
+
+function affine([x, y, z]) {
+  if (z === 0n) throw new Error("point at infinity");
+  const zi = inv(z), zi2 = mod(zi * zi);
+  return [mod(x * zi2), mod(y * zi2 * zi)];
+}
+
+export function toBig(bytes) {
+  let v = 0n;
+  for (const b of bytes) v = (v << 8n) | BigInt(b);
+  return v;
+}
+
+export function toBytes32(v) {
+  const out = new Uint8Array(32);
+  for (let i = 31; i >= 0; i--) { out[i] = Number(v & 0xffn); v >>= 8n; }
+  return out;
+}
+
+function hmac(key, ...parts) {
+  const k = new Uint8Array(64);
+  k.set(key.length > 64 ? sha256(key) : key);
+  const ipad = k.map((b) => b ^ 0x36), opad = k.map((b) => b ^ 0x5c);
+  return sha256(opad, sha256(ipad, ...parts));
+}
+
+function rfc6979(priv, h) {
+  const x = toBytes32(priv), m = toBytes32(mod(toBig(h), N));
+  let v = new Uint8Array(32).fill(1), k = new Uint8Array(32);
+  k = hmac(k, v, Uint8Array.of(0), x, m);
+  v = hmac(k, v);
+  k = hmac(k, v, Uint8Array.of(1), x, m);
+  v = hmac(k, v);
+  for (;;) {
+    v = hmac(k, v);
+    const t = toBig(v);
+    if (t > 0n && t < N) return t;
+    k = hmac(k, v, Uint8Array.of(0));
+    v = hmac(k, v);
+  }
+}
+
+export function feeKeyFromMaster(master) {
+  const h = toBig(sha256(enc.encode("opeq/evm/fee/v1"), master));
+  return mod(h, N - 1n) + 1n;
+}
+
+export function publicKey(priv) {
+  if (priv <= 0n || priv >= N) throw new Error("private key out of range");
+  return affine(mul(priv));
+}
+
+export function addressOf(priv) {
+  const [x, y] = publicKey(priv);
+  const a = keccak256(toBytes32(x), toBytes32(y)).slice(12);
+  return "0x" + Array.from(a, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+export function sign(hash32, priv) {
+  if (hash32.length !== 32) throw new Error("hash must be 32 bytes");
+  const z = mod(toBig(hash32), N);
+  const k = rfc6979(priv, hash32);
+  const [rx, ry] = affine(mul(k));
+  const r = mod(rx, N);
+  if (r === 0n) throw new Error("bad nonce");
+  let s = mod(inv(k, N) * (z + r * priv), N);
+  let recovery = Number(ry & 1n) | (rx >= N ? 2 : 0);
+  if (s > N / 2n) { s = N - s; recovery ^= 1; }
+  if (s === 0n || recovery > 1) throw new Error("bad signature");
+  return { r, s, recovery };
+}

package/src/lib/sha256.js

@@ -0,0 +1,120 @@
+const K = new Int32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+const IV = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+const Wbuf = new Int32Array(64);
+
+function compress(H, block, off) {
+  const W = Wbuf;
+  for (let i = 0; i < 16; i++) {
+    const j = off + 4 * i;
+    W[i] = (block[j] << 24) | (block[j + 1] << 16) | (block[j + 2] << 8) | block[j + 3];
+  }
+  for (let i = 16; i < 64; i++) {
+    const a = W[i - 15], b = W[i - 2];
+    const s0 = ((a >>> 7) | (a << 25)) ^ ((a >>> 18) | (a << 14)) ^ (a >>> 3);
+    const s1 = ((b >>> 17) | (b << 15)) ^ ((b >>> 19) | (b << 13)) ^ (b >>> 10);
+    W[i] = (W[i - 16] + s0 + W[i - 7] + s1) | 0;
+  }
+  let a = H[0], b = H[1], c = H[2], d = H[3], e = H[4], f = H[5], g = H[6], h = H[7];
+  for (let i = 0; i < 64; i++) {
+    const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+    const t1 = (h + S1 + ((e & f) ^ (~e & g)) + K[i] + W[i]) | 0;
+    const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+    const t2 = (S0 + ((a & b) ^ (a & c) ^ (b & c))) | 0;
+    h = g; g = f; f = e; e = (d + t1) | 0; d = c; c = b; b = a; a = (t1 + t2) | 0;
+  }
+  H[0] = (H[0] + a) | 0; H[1] = (H[1] + b) | 0; H[2] = (H[2] + c) | 0; H[3] = (H[3] + d) | 0;
+  H[4] = (H[4] + e) | 0; H[5] = (H[5] + f) | 0; H[6] = (H[6] + g) | 0; H[7] = (H[7] + h) | 0;
+}
+
+export class Sha256 {
+  constructor() {
+    this.H = new Int32Array(IV);
+    this.buf = new Uint8Array(64);
+    this.len = 0;
+    this.total = 0;
+  }
+
+  clone() {
+    const c = new Sha256();
+    c.H.set(this.H);
+    c.buf.set(this.buf);
+    c.len = this.len;
+    c.total = this.total;
+    return c;
+  }
+
+  update(data) {
+    let i = 0;
+    this.total += data.length;
+    if (this.len) {
+      const take = Math.min(64 - this.len, data.length);
+      this.buf.set(data.subarray(0, take), this.len);
+      this.len += take;
+      i = take;
+      if (this.len < 64) return this;
+      compress(this.H, this.buf, 0);
+      this.len = 0;
+    }
+    for (; i + 64 <= data.length; i += 64) compress(this.H, data, i);
+    if (i < data.length) {
+      this.buf.set(data.subarray(i), 0);
+      this.len = data.length - i;
+    }
+    return this;
+  }
+
+  digest() {
+    const c = this.clone();
+    const bits = c.total * 8;
+    const pad = new Uint8Array(((c.len < 56 ? 56 : 120) - c.len) + 8);
+    pad[0] = 0x80;
+    const hi = Math.floor(bits / 0x100000000), lo = bits >>> 0;
+    const n = pad.length;
+    pad[n - 8] = hi >>> 24; pad[n - 7] = hi >>> 16; pad[n - 6] = hi >>> 8; pad[n - 5] = hi;
+    pad[n - 4] = lo >>> 24; pad[n - 3] = lo >>> 16; pad[n - 2] = lo >>> 8; pad[n - 1] = lo;
+    const H = c.H, buf = c.buf;
+    let len = c.len;
+    for (let k = 0; k < pad.length; k++) {
+      buf[len++] = pad[k];
+      if (len === 64) { compress(H, buf, 0); len = 0; }
+    }
+    const out = new Uint8Array(32);
+    for (let k = 0; k < 8; k++) {
+      out[4 * k] = H[k] >>> 24; out[4 * k + 1] = H[k] >>> 16; out[4 * k + 2] = H[k] >>> 8; out[4 * k + 3] = H[k];
+    }
+    return out;
+  }
+}
+
+export function sha256(...parts) {
+  const h = new Sha256();
+  for (const p of parts) h.update(p);
+  return h.digest();
+}
+
+const oneH = new Int32Array(8);
+const oneBlock = new Uint8Array(64);
+
+export function sha256Short(msg, out, outLen = 32) {
+  const n = msg.length;
+  if (n > 55) throw new Error("sha256Short takes at most 55 bytes");
+  oneBlock.fill(0);
+  oneBlock.set(msg);
+  oneBlock[n] = 0x80;
+  const bits = n * 8;
+  oneBlock[62] = bits >>> 8;
+  oneBlock[63] = bits & 0xff;
+  oneH.set(IV);
+  compress(oneH, oneBlock, 0);
+  for (let k = 0; k < outLen; k++) out[k] = oneH[k >> 2] >>> (24 - 8 * (k & 3));
+  return out;
+}

package/src/lib/solana.js

@@ -0,0 +1,264 @@
+import { sha256 } from "./sha256.js";
+
+const B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const enc = new TextEncoder();
+
+export function b58encode(bytes) {
+  let n = 0n;
+  for (const b of bytes) n = (n << 8n) | BigInt(b);
+  let s = "";
+  while (n > 0n) { s = B58[Number(n % 58n)] + s; n /= 58n; }
+  for (const b of bytes) { if (b !== 0) break; s = "1" + s; }
+  return s;
+}
+
+export function b58decode(s) {
+  let n = 0n;
+  for (const c of s) {
+    const i = B58.indexOf(c);
+    if (i < 0) throw new Error("invalid base58");
+    n = n * 58n + BigInt(i);
+  }
+  const out = [];
+  while (n > 0n) { out.unshift(Number(n & 0xffn)); n >>= 8n; }
+  for (const c of s) { if (c !== "1") break; out.unshift(0); }
+  return new Uint8Array(out);
+}
+
+export function pubkey(s) {
+  const b = b58decode(s);
+  if (b.length !== 32) throw new Error(`not a 32 byte address: ${s}`);
+  return b;
+}
+
+export const eq = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+export const hex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+export const unhex = (h) => new Uint8Array(h.match(/../g).map((x) => parseInt(x, 16)));
+
+const P = (1n << 255n) - 19n;
+function modpow(b, e, m) {
+  let r = 1n;
+  b %= m;
+  while (e > 0n) { if (e & 1n) r = (r * b) % m; b = (b * b) % m; e >>= 1n; }
+  return r;
+}
+const D = ((-121665n * modpow(121666n, P - 2n, P)) % P + P) % P;
+
+export function isOnCurve(bytes) {
+  let y = 0n;
+  for (let i = 31; i >= 0; i--) y = (y << 8n) | BigInt(bytes[i]);
+  y = (y & ((1n << 255n) - 1n)) % P;
+  const y2 = (y * y) % P;
+  const u = (y2 - 1n + P) % P;
+  const v = (D * y2 + 1n) % P;
+  if (v === 0n) return false;
+  const x2 = (u * modpow(v, P - 2n, P)) % P;
+  return x2 === 0n || modpow(x2, (P - 1n) / 2n, P) === 1n;
+}
+
+export function findPda(seeds, program) {
+  for (let bump = 255; bump >= 0; bump--) {
+    const h = sha256(...seeds, new Uint8Array([bump]), program, enc.encode("ProgramDerivedAddress"));
+    if (!isOnCurve(h)) return { key: h, bump };
+  }
+  throw new Error("no program address found");
+}
+
+export function compact(n) {
+  const out = [];
+  for (;;) {
+    const b = n & 0x7f;
+    n >>= 7;
+    if (n) out.push(b | 0x80);
+    else { out.push(b); return out; }
+  }
+}
+
+export function concat(...parts) {
+  const n = parts.reduce((s, p) => s + p.length, 0);
+  const out = new Uint8Array(n);
+  let o = 0;
+  for (const p of parts) { out.set(p, o); o += p.length; }
+  return out;
+}
+
+export function u32(v) { const b = new Uint8Array(4); new DataView(b.buffer).setUint32(0, v, true); return b; }
+export function u64(v) {
+  const n = BigInt(v);
+  if (n < 0n || n >= 1n << 64n) throw new Error("value out of u64 range");
+  const b = new Uint8Array(8);
+  new DataView(b.buffer).setBigUint64(0, n, true);
+  return b;
+}
+
+export const SYSTEM = new Uint8Array(32);
+export const COMPUTE_BUDGET = pubkey("ComputeBudget111111111111111111111111111111");
+
+export function compileV0(payer, ixs, blockhash, tables = []) {
+  const key = (k) => b58encode(k);
+  const metas = new Map([[key(payer), { k: payer, s: true, w: true }]]);
+  const order = [key(payer)];
+  const programs = new Set();
+  for (const [prog, accs] of ixs) {
+    for (const [k, s, w] of accs) {
+      const id = key(k);
+      if (metas.has(id)) { const m = metas.get(id); m.s ||= s; m.w ||= w; }
+      else { metas.set(id, { k, s, w }); order.push(id); }
+    }
+    programs.add(key(prog));
+    if (!metas.has(key(prog))) { metas.set(key(prog), { k: prog, s: false, w: false }); order.push(key(prog)); }
+  }
+  const where = new Map();
+  tables.forEach((t, ti) => t.addresses.forEach((a, i) => { if (!where.has(key(a))) where.set(key(a), [ti, i]); }));
+  const isStatic = (id) => metas.get(id).s || programs.has(id) || !where.has(id);
+  const rank = (id) => (id === key(payer) ? 0 : 1) * 4 + (metas.get(id).s ? 0 : 2) + (metas.get(id).w ? 0 : 1);
+  const statics = order.filter(isStatic).sort((a, b) => rank(a) - rank(b) || order.indexOf(a) - order.indexOf(b));
+  const loaded = order.filter((id) => !isStatic(id));
+  const lookups = [], loadedW = [], loadedR = [];
+  tables.forEach((t, ti) => {
+    const wi = loaded.filter((id) => where.get(id)[0] === ti && metas.get(id).w);
+    const ri = loaded.filter((id) => where.get(id)[0] === ti && !metas.get(id).w);
+    if (wi.length || ri.length) {
+      lookups.push([t.key, wi.map((id) => where.get(id)[1]), ri.map((id) => where.get(id)[1])]);
+      loadedW.push(...wi);
+      loadedR.push(...ri);
+    }
+  });
+  const all = [...statics, ...loadedW, ...loadedR];
+  const idx = new Map(all.map((k, i) => [k, i]));
+  const nsig = statics.filter((k) => metas.get(k).s).length;
+  const roSigned = statics.filter((k) => metas.get(k).s && !metas.get(k).w).length;
+  const roUnsigned = statics.filter((k) => !metas.get(k).s && !metas.get(k).w).length;
+  const body = [new Uint8Array([0x80, nsig, roSigned, roUnsigned, ...compact(statics.length)]), ...statics.map((k) => metas.get(k).k), blockhash, new Uint8Array(compact(ixs.length))];
+  for (const [prog, accs, data] of ixs) {
+    body.push(new Uint8Array([idx.get(key(prog)), ...compact(accs.length), ...accs.map((a) => idx.get(key(a[0]))), ...compact(data.length)]));
+    body.push(data);
+  }
+  body.push(new Uint8Array(compact(lookups.length)));
+  for (const [t, wi, ri] of lookups) body.push(t, new Uint8Array([...compact(wi.length), ...wi, ...compact(ri.length), ...ri]));
+  return { message: concat(...body), signers: statics.slice(0, nsig) };
+}
+
+export function unsignedTx(message, nsig) {
+  return concat(new Uint8Array(compact(nsig)), new Uint8Array(64 * nsig), message);
+}
+
+export class Rpc {
+  constructor(url) { this.url = url; this.id = 0; }
+
+  async call(method, params = []) {
+    for (let attempt = 0; ; attempt++) {
+      const ctl = new AbortController();
+      const timer = setTimeout(() => ctl.abort(), 20000);
+      let res;
+      try {
+        res = await fetch(this.url, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ jsonrpc: "2.0", id: ++this.id, method, params }),
+          signal: ctl.signal,
+        });
+      } catch (e) {
+        if (method !== "sendTransaction" && attempt < 3) { await new Promise((r) => setTimeout(r, 1000 * (attempt + 1))); continue; }
+        throw new Error(`network error talking to the RPC (${method})`);
+      }
+      if ((res.status === 429 || res.status >= 500) && attempt < 4) {
+        clearTimeout(timer);
+        await new Promise((r) => setTimeout(r, 1500 * (attempt + 1)));
+        continue;
+      }
+      let j;
+      try { j = await res.json(); } catch { throw new Error(`the RPC sent an unreadable answer (${method})`); } finally { clearTimeout(timer); }
+      if (j.error) {
+        const e = new Error(String(j.error.message || "RPC error").slice(0, 200));
+        const logs = j.error.data && j.error.data.logs;
+        e.data = { logs: Array.isArray(logs) ? logs.filter((l) => typeof l === "string").slice(0, 60) : [] };
+        e.fromRpc = true;
+        throw e;
+      }
+      return j.result;
+    }
+  }
+
+  async account(k) {
+    const v = (await this.call("getAccountInfo", [b58encode(k), { encoding: "base64", commitment: "confirmed" }])).value;
+    if (!v) return null;
+    return { owner: pubkey(v.owner), lamports: v.lamports, executable: v.executable === true, data: Uint8Array.from(atob(v.data[0]), (c) => c.charCodeAt(0)) };
+  }
+
+  async simulate(tx, addresses, minContextSlot = 0) {
+    const b64 = btoa(String.fromCharCode(...tx));
+    const r = await this.call("simulateTransaction", [b64, { encoding: "base64", sigVerify: true, commitment: "processed", minContextSlot, accounts: { encoding: "base64", addresses: addresses.map(b58encode) } }]);
+    const v = r && r.value;
+    if (!r || !r.context || !(r.context.slot >= minContextSlot)) throw new Error("the RPC simulated on an older state than the balance snapshot");
+    if (!v || !Array.isArray(v.accounts) || v.accounts.length !== addresses.length) throw new Error("the RPC returned a malformed simulation");
+    return { err: v.err, logs: Array.isArray(v.logs) ? v.logs.filter((l) => typeof l === "string").slice(0, 80) : [],
+      accounts: v.accounts.map((a) => (a ? { lamports: BigInt(a.lamports), data: Uint8Array.from(atob(a.data[0]), (c) => c.charCodeAt(0)) } : null)) };
+  }
+
+  async snapshot(addresses) {
+    const r = await this.call("getMultipleAccounts", [addresses.map(b58encode), { encoding: "base64", commitment: "processed" }]);
+    if (!r || !Array.isArray(r.value) || r.value.length !== addresses.length) throw new Error("the RPC returned a malformed account list");
+    const out = r.value.map((a) => (a ? { lamports: BigInt(a.lamports), data: Uint8Array.from(atob(a.data[0]), (c) => c.charCodeAt(0)) } : null));
+    out.slot = r.context && r.context.slot ? r.context.slot : 0;
+    return out;
+  }
+
+  async executables(keys) {
+    const out = new Map();
+    for (let i = 0; i < keys.length; i += 100) {
+      const part = keys.slice(i, i + 100);
+      const r = await this.call("getMultipleAccounts", [part.map(b58encode), { encoding: "base64", dataSlice: { offset: 0, length: 0 }, commitment: "confirmed" }]);
+      if (!r || !Array.isArray(r.value) || r.value.length !== part.length) throw new Error("the RPC returned a malformed account list");
+      r.value.forEach((v, j) => out.set(b58encode(part[j]), !!(v && v.executable === true)));
+    }
+    return out;
+  }
+
+  async balance(k) { return (await this.call("getBalance", [b58encode(k), { commitment: "confirmed" }])).value; }
+  async slot() { return this.call("getSlot", [{ commitment: "confirmed" }]); }
+  async blockhash() { return b58decode((await this.call("getLatestBlockhash", [{ commitment: "confirmed" }])).value.blockhash); }
+  async rent(size) { return this.call("getMinimumBalanceForRentExemption", [size]); }
+
+  async lookupTable(addr) {
+    const acc = await this.account(addr);
+    if (!acc) throw new Error("lookup table not found");
+    if (b58encode(acc.owner) !== "AddressLookupTab1e1111111111111111111111111") throw new Error("account is not an address lookup table");
+    const addresses = [];
+    for (let o = 56; o + 32 <= acc.data.length; o += 32) addresses.push(acc.data.slice(o, o + 32));
+    return { key: addr, addresses };
+  }
+
+  async tokenAccounts(owner) {
+    const out = [];
+    for (const prog of ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"]) {
+      const r = await this.call("getTokenAccountsByOwner", [b58encode(owner), { programId: prog }, { encoding: "jsonParsed", commitment: "confirmed" }]);
+      for (const a of Array.isArray(r && r.value) ? r.value.slice(0, 200) : []) {
+        try {
+          const info = a.account.data.parsed.info;
+          const amt = info.tokenAmount.amount, dec = info.tokenAmount.decimals;
+          if (typeof amt !== "string" || !/^\d{1,20}$/.test(amt) || !Number.isInteger(dec) || dec < 0 || dec > 18) continue;
+          if (BigInt(amt) >= 1n << 64n) continue;
+          pubkey(a.pubkey); pubkey(info.mint);
+          out.push({ account: a.pubkey, program: prog, mint: info.mint, amount: BigInt(amt), decimals: dec });
+        } catch {}
+      }
+    }
+    return out;
+  }
+
+  async tokenAmount(acc) {
+    const amt = (await this.call("getTokenAccountBalance", [b58encode(acc), { commitment: "confirmed" }])).value.amount;
+    if (typeof amt !== "string" || !/^\d{1,20}$/.test(amt)) throw new Error("the RPC returned an invalid token amount");
+    return BigInt(amt);
+  }
+
+  async sendRaw(tx) {
+    const b64 = btoa(String.fromCharCode(...tx));
+    return this.call("sendTransaction", [b64, { encoding: "base64", preflightCommitment: "confirmed" }]);
+  }
+
+  async status(sig) {
+    return (await this.call("getSignatureStatuses", [[sig], { searchTransactionHistory: true }])).value[0];
+  }
+}