@typesol/cli 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -5,6 +5,28 @@ until 1.0, a minor version may change the language, the IDL layout or error code
 
 ## Unreleased
 
+## 0.22.0 — 2026-10-28
+
+Generated clients fill in the accounts Anchor's client still asked you to pass (signers from a default signer, PDAs
+seeded from string, byte and argument fields, PDAs under a program given as an argument, a helper for PDAs seeded from
+their own fields), read Anchor zero-copy accounts and generic types, and run in tests over LiteSVM. Programs and their
+bytes are unchanged. Not externally audited (see SECURITY.md).
+
+### Added
+- Generated clients fill in the accounts Anchor's client still asks for:
+  - `resolve.<instruction>(rpc, accounts, args?, { signer })` fills signer accounts that were left out with a default
+    signer (the wallet), as Anchor's client uses the provider's wallet.
+  - PDAs seeded from another account's string, byte and `FixedString` fields are derived by `resolve`, as scalar fields
+    already were.
+  - A PDA seeded from its own fields gets a `pdas.<name>({ field values })` helper (its address is needed to read it).
+  - A PDA whose program is a `Pubkey` argument is derived by the instruction builder.
+- Clients generated from Anchor IDLs read and write zero-copy (`bytemuck`, `AccountLoader`) accounts at their
+  `#[repr(C)]` offsets on SBF (padding, `packed` and `align` included), checked byte for byte against an Anchor
+  program, and turn generic types into one concrete type per use (`Pair<u64, 2>` → `PairU64N2`).
+- PDAs seeded from fields of a struct argument (`seeds = [params.id]`) are derived by the instruction builder.
+- `typesol/testing`: `svmConnection(svm)` (and `t.connection`), a kit RPC and subscriptions pair answered by LiteSVM,
+  so a generated client sends, fetches, simulates, resolves and watches in tests as it does against a cluster.
+
 ## 0.21.0 — 2026-10-28
 
 Clients from a program's address alone, and the last pieces Anchor's client resolves for you: `has_one` accounts,

package/README.md

@@ -306,7 +306,7 @@ Details are in [docs/testing.md](docs/testing.md).
 
 ## Status
 
-**TypeSOL is pre-1.0 (0.21).** Releases follow the organization's
+**TypeSOL is pre-1.0 (0.22).** Releases follow the organization's
 [versioning policy](https://github.com/typesol/.github/blob/main/VERSIONING.md); [CHANGELOG.md](CHANGELOG.md) lists every
 change.
 - The compiler, runtime and tooling have been through internal security reviews and are covered by the tests above.

package/dist/clientgen.js

@@ -419,9 +419,123 @@ class Names {
         }
     }
 }
+/**
+ * Generic types (Anchor `struct Wrap<T, const N: usize>`) as concrete ones: each use with type and const arguments
+ * (`Wrap<u64, 4>`) becomes its own type definition (`WrapU64N4`), and the uses point at it. Generic definitions
+ * themselves are left as they are (and out of the client); uses whose arguments are still generic are kept.
+ */
+function monomorphize(idl) {
+    const defs = new Map((idl.types ?? []).map((t) => [t.name, t]));
+    if (![...defs.values()].some((d) => d.generics?.length))
+        return idl;
+    const taken = new Set(defs.keys());
+    const made = new Map(); // instantiation key → new type name
+    const extra = [];
+    const label = (t) => {
+        if (typeof t === "number")
+            return `N${t}`;
+        if (typeof t === "string")
+            return pascal(t.replace(/[^A-Za-z0-9_]/g, ""));
+        if (t.vec !== undefined)
+            return `Vec${label(t.vec)}`;
+        if (t.option !== undefined)
+            return `Option${label(t.option)}`;
+        if (t.coption !== undefined)
+            return `COption${label(t.coption)}`;
+        if (t.array)
+            return `Array${label(t.array[0])}N${String(t.array[1]).replace(/[^0-9]/g, "")}`;
+        return pascal((definedName(t) ?? "T").replace(/[^A-Za-z0-9_]/g, ""));
+    };
+    const hasGeneric = (t) => JSON.stringify(t ?? null).includes('"generic"');
+    const inst = (t, env) => {
+        if (typeof t === "string")
+            return t;
+        if (t.generic !== undefined) {
+            const v = env.get(t.generic);
+            return v === undefined || typeof v === "number" ? t : v;
+        }
+        if (t.vec !== undefined)
+            return { vec: inst(t.vec, env) };
+        if (t.option !== undefined)
+            return { option: inst(t.option, env) };
+        if (t.coption !== undefined)
+            return { coption: inst(t.coption, env) };
+        if (t.array) {
+            const len = t.array[1];
+            const g = typeof len === "object" && len !== null ? len.generic : undefined;
+            const n = g !== undefined ? env.get(g) : len;
+            return { array: [inst(t.array[0], env), typeof n === "number" ? n : len] };
+        }
+        const name = definedName(t);
+        const args = typeof t.defined === "object" ? (t.defined.generics ?? []) : [];
+        if (name === undefined || !args.length)
+            return t;
+        const values = args.map((a) => a?.kind === "const"
+            ? Number.isSafeInteger(Number(a.value)) && /^\d+$/.test(String(a.value))
+                ? Number(a.value)
+                : undefined
+            : a?.type === undefined
+                ? undefined
+                : inst(a.type, env));
+        const def = defs.get(name);
+        const params = (def?.generics ?? []);
+        if (!def ||
+            values.some((v) => v === undefined || hasGeneric(v)) ||
+            params.length !== values.length ||
+            params.some((p) => typeof p?.name !== "string" || !NAME.test(p.name)))
+            return { defined: { name, generics: args } };
+        const key = JSON.stringify([name, values]);
+        let made1 = made.get(key);
+        if (!made1) {
+            let base = `${name}${values.map((v) => label(v)).join("")}`;
+            if (!NAME.test(base))
+                base = `${name}Instance`;
+            made1 = base;
+            for (let i = 2; taken.has(made1); i++)
+                made1 = `${base}${i}`;
+            taken.add(made1);
+            made.set(key, made1);
+            const env2 = new Map(params.map((p, i) => [p.name, values[i]]));
+            const body = def.type;
+            const field = (f) => (isField(f) ? { ...f, type: inst(f.type, env2) } : inst(f, env2));
+            extra.push({
+                ...def,
+                name: made1,
+                generics: undefined,
+                type: {
+                    ...body,
+                    ...(body.fields ? { fields: body.fields.map(field) } : {}),
+                    ...(body.variants ? { variants: body.variants.map((v) => ({ ...v, ...(v.fields ? { fields: v.fields.map(field) } : {}) })) } : {}),
+                    ...(body.alias !== undefined ? { alias: inst(body.alias, env2) } : {}),
+                },
+            });
+        }
+        return { defined: made1 };
+    };
+    const none = new Map();
+    const field = (f) => (isField(f) ? { ...f, type: inst(f.type, none) } : inst(f, none));
+    const types = (idl.types ?? []).map((d) => d.generics?.length
+        ? d
+        : {
+            ...d,
+            type: {
+                ...d.type,
+                ...(d.type.fields ? { fields: d.type.fields.map(field) } : {}),
+                ...(d.type.variants ? { variants: d.type.variants.map((v) => ({ ...v, ...(v.fields ? { fields: v.fields.map(field) } : {}) })) } : {}),
+                ...(d.type.alias !== undefined ? { alias: inst(d.type.alias, none) } : {}),
+            },
+        });
+    const instructions = idl.instructions.map((ix) => ({
+        ...ix,
+        args: ix.args.map((a) => ({ ...a, type: inst(a.type, none) })),
+        ...(ix.returns !== undefined ? { returns: inst(ix.returns, none) } : {}),
+    }));
+    return { ...idl, instructions, types: [...types, ...extra] };
+}
 export function generateClient(idl, opts = {}) {
     const programAddress = opts.address ?? idl.address;
     validate(idl, programAddress);
+    idl = monomorphize(idl);
     if (!programAddress)
         throw new ClientIdlError("the IDL has no program address; pass one");
     const typesol = idl.metadata?.description === "Built with TypeSOL";
@@ -448,6 +562,70 @@ export function generateClient(idl, opts = {}) {
             return { kind: "fenum", base: n.slice("FixedEnum_".length), size: 1 + arrayLen(f[1].type) };
         return undefined;
     };
+    // ---- Zero-copy (bytemuck) layouts: #[repr(C)] in memory, as the program sees it on SBF ------------------------
+    const zeroCopy = (d) => d?.serialization === "bytemuck" || d?.serialization === "bytemuckunsafe";
+    const layouts = new Map();
+    /** Size and alignment of a type inside a zero-copy struct, or why it cannot be in one. */
+    function cLayout(t) {
+        if (typeof t === "string") {
+            if (t in INTS)
+                return { size: INTS[t] / 8, align: Math.min(INTS[t] / 8, 8) }; // SBF aligns u128/i128 to 8, not 16
+            if (t in FLOATS)
+                return { size: FLOATS[t] / 8, align: FLOATS[t] / 8 };
+            if (t === "bool")
+                return { size: 1, align: 1 };
+            if (t === "pubkey" || t === "publicKey")
+                return { size: 32, align: 1 };
+            return `"${t}" has no fixed size`;
+        }
+        if (t.array) {
+            const e = cLayout(t.array[0]);
+            const n = Number(t.array[1]);
+            return typeof e === "string" ? e : { size: e.size * n, align: e.align };
+        }
+        const n = definedName(t);
+        const d = defs.get(n ?? "");
+        if (!n || !d || !zeroCopy(d))
+            return `${n ?? "the type"} is not a zero-copy type`;
+        const l = structLayout(d);
+        return typeof l === "string" ? l : { size: l.size, align: l.align };
+    }
+    function structLayout(d) {
+        const known = layouts.get(d.name);
+        if (known)
+            return known;
+        layouts.set(d.name, `type ${d.name} contains itself`);
+        const repr = (d.repr ?? {});
+        const fields = d.type.kind === "struct" ? (d.type.fields ?? []) : undefined;
+        let out;
+        if (!fields || !fields.every(isField))
+            out = `zero-copy type ${d.name} is not a struct with named fields`;
+        else if (repr.kind === "rust")
+            out = `zero-copy type ${d.name} has Rust's unspecified layout`;
+        else {
+            let offset = 0;
+            let align = 1;
+            const offsets = [];
+            let why;
+            for (const f of fields) {
+                const l = cLayout(f.type);
+                if (typeof l === "string") {
+                    why = `${d.name}.${f.name}: ${l}`;
+                    break;
+                }
+                const a = repr.packed ? 1 : l.align;
+                offset = Math.ceil(offset / a) * a;
+                offsets.push(offset);
+                offset += l.size;
+                align = Math.max(align, a);
+            }
+            if (Number.isInteger(repr.align) && repr.align > 0)
+                align = Math.max(align, repr.align);
+            out = why ?? { size: Math.ceil(offset / align) * align, align, offsets };
+        }
+        layouts.set(d.name, out);
+        return out;
+    }
     // ---- What can be expressed --------------------------------------------------------------------------------
     const typeIssues = new Map();
     /** Why a type cannot be generated, or undefined when it can. */
@@ -483,9 +661,14 @@ export function generateClient(idl, opts = {}) {
         if (!d)
             why = `type ${n} is not defined in the IDL`;
         else if (d.generics?.length)
-            why = `type ${n} is generic`;
+            why = `type ${n} is generic (each use with concrete arguments is generated as its own type)`;
+        else if (zeroCopy(d)) {
+            const l = structLayout(d);
+            if (typeof l === "string")
+                why = l;
+        }
         else if (d.serialization && d.serialization !== "borsh")
-            why = `type ${n} uses ${d.serialization} serialization (zero-copy layouts are not supported)`;
+            why = `type ${n} uses ${d.serialization} serialization, which is not supported`;
         else if (special(n)?.kind === "foption")
             why = issue(special(n).inner);
         else if (d.type.kind === "struct")
@@ -547,6 +730,7 @@ export function generateClient(idl, opts = {}) {
     let needsFixedOption = false;
     let needsFixedVec = false;
     let needsUnitEnum = false;
+    let needsCStruct = false;
     function codec(t) {
         if (typeof t === "string") {
             if (t in INTS || t in FLOATS) {
@@ -640,6 +824,10 @@ export function generateClient(idl, opts = {}) {
         const d = defs.get(n);
         if (!d)
             return undefined;
+        if (zeroCopy(d)) {
+            const l = structLayout(d);
+            return typeof l === "string" ? undefined : l.size;
+        }
         if (isUnitEnum(d))
             return 1;
         if (d.type.kind !== "struct")
@@ -676,6 +864,16 @@ export function generateClient(idl, opts = {}) {
                 continue;
             }
             const named = fields;
+            if (zeroCopy(d)) {
+                // Fields at their #[repr(C)] offsets (padding written as zeros), not one after another as Borsh would.
+                const l = structLayout(d);
+                needsCStruct = true;
+                typeOut.push(`${doc(d.docs)}export interface ${T} {\n${named.map((f) => `${doc(f.docs, "  ")}  ${prop(camel(f.name))}: ${tsType(f.type, "out")};`).join("\n")}\n}\n` +
+                    `export interface ${T}Args {\n${named.map((f) => `  ${prop(camel(f.name))}: ${tsType(f.type, "in")};`).join("\n")}\n}\n` +
+                    `/** Zero-copy (#[repr(C)]) layout: ${l.size} bytes. */\n` +
+                    `export function get${T}Codec(): Codec<${T}Args, ${T}> {\n  return cStruct([${named.map((f, i) => `[${JSON.stringify(camel(f.name))}, ${codec(f.type)}, ${l.offsets[i]}]`).join(", ")}], ${l.size}) ${cast};\n}\n`);
+                continue;
+            }
             use("getStructCodec");
             typeOut.push(`${doc(d.docs)}export interface ${T} {\n${named.map((f) => `${doc(f.docs, "  ")}  ${prop(camel(f.name))}: ${tsType(f.type, "out")};`).join("\n")}\n}\n` +
                 `export interface ${T}Args {\n${named.map((f) => `  ${prop(camel(f.name))}: ${tsType(f.type, "in")};`).join("\n")}\n}\n` +
@@ -839,12 +1037,20 @@ export function generateClient(idl, opts = {}) {
             if (s.kind === "const")
                 return bytes(s.value);
             if (s.kind === "arg") {
-                if (s.path.includes("."))
-                    return { why: `the seed ${s.path} is a field of an argument` };
-                const t = argType.get(s.path);
+                // `params.id`: a field (of a field…) of a struct argument.
+                const [head, ...rest] = s.path.split(".");
+                let t = argType.get(head);
                 if (t === undefined)
-                    return { why: `the seed argument ${s.path} does not exist` };
-                const v = `args.${camel(s.path)}`;
+                    return { why: `the seed argument ${head} does not exist` };
+                let v = `args.${camel(head)}`;
+                for (const part of rest) {
+                    const d = defs.get(definedName(t) ?? "");
+                    const f = d?.type.kind === "struct" ? (d.type.fields ?? []).find((x) => isField(x) && x.name === part) : undefined;
+                    if (!f || !NAME.test(part))
+                        return { why: `the seed ${s.path} is not a field of a struct argument` };
+                    t = f.type;
+                    v += `[${JSON.stringify(camel(part))}]`;
+                }
                 if (t === "string")
                     return (use("getUtf8Encoder"), `getUtf8Encoder().encode(${v})`);
                 if (t === "bytes" || (typeof t === "object" && t.vec !== undefined && isU8(t.vec)))
@@ -874,8 +1080,10 @@ export function generateClient(idl, opts = {}) {
                 const target = p.path.includes(".") ? undefined : byPath(p.path, a.group);
                 program = target ? `key($${target.key})` : { why: `the PDA program ${p.path} is not an account of the instruction` };
             }
-            else if (p?.kind === "arg")
-                program = { why: "the PDA program comes from an argument" };
+            else if (p?.kind === "arg") {
+                const t = p.path.includes(".") ? undefined : argType.get(p.path);
+                program = t === "pubkey" || t === "publicKey" ? `args.${camel(p.path)}` : { why: "the PDA program comes from an argument that is not a Pubkey" };
+            }
             const why = [...seeds, ...(program === undefined ? [] : [program])].find((x) => typeof x === "object");
             if (why) {
                 notes.push(`instruction ${ix.name}: ${a.name} is not filled in (${why.why}); pass it`);
@@ -942,8 +1150,10 @@ export function generateClient(idl, opts = {}) {
             const inputs = [...a.pda.seeds, ...(a.pda.program ? [a.pda.program] : [])].filter((s) => s.kind !== "const");
             const params = [
                 ...new Map(inputs.map((s) => {
-                    if (s.kind === "arg")
-                        return [camel(s.path), `${camel(s.path)}: ${tsType(argType.get(s.path), "in")}`];
+                    if (s.kind === "arg") {
+                        const head = s.path.split(".")[0];
+                        return [camel(head), `${camel(head)}: ${tsType(argType.get(head), "in")}`];
+                    }
                     const k = byPath(s.path, a.group).key;
                     return [k, `${k}: Address | TransactionSigner`];
                 })).values(),
@@ -978,8 +1188,38 @@ export function generateClient(idl, opts = {}) {
             lines.join("\n") +
             `\n  return {\n    programAddress: PROGRAM_ADDRESS,\n    accounts: [\n${metas.join("\n")}\n      ...remaining,\n    ],\n    data: ${data},\n  } as Instruction;\n}\n`);
         ixKeys.push(`${prop(fn)}: build${P}`);
-        // has_one relations (Anchor's `relations`): a non-signing account another account of the instruction names in a
-        // Pubkey field can be read from that account on chain.
+        // `resolve.<instruction>`: what needs the chain or the caller's wallet, filled in on a copy of the accounts in this
+        // order: signers (a default signer), has_one accounts, then PDAs seeded from other accounts' fields.
+        const acc = (f) => `acc${NAME.test(f.key) && !JS_RESERVED.has(f.key) ? `.${f.key}` : `[${JSON.stringify(f.key)}]`}`;
+        // A field's value as seed bytes: scalars by their codec, strings as UTF-8, byte fields as they are.
+        const seedOfField = (t, v) => {
+            if (typeof t === "string") {
+                if (t in INTS || t === "bool" || t === "pubkey" || t === "publicKey")
+                    return `${codec(t)}.encode(${v})`;
+                if (t === "string")
+                    return (use("getUtf8Encoder"), `getUtf8Encoder().encode(${v})`);
+                if (t === "bytes")
+                    return `Uint8Array.from(${v})`;
+                return undefined;
+            }
+            if ((t.vec !== undefined && isU8(t.vec)) || (t.array && isU8(t.array[0])))
+                return `Uint8Array.from(${v})`;
+            const name = definedName(t);
+            if (name === undefined)
+                return undefined;
+            if (special(name)?.kind === "fstring")
+                return (use("getUtf8Encoder"), `getUtf8Encoder().encode(${v})`);
+            const d = defs.get(name);
+            return d?.type.kind === "enum" && (d.type.variants ?? []).every((x) => !x.fields?.length) ? `${codec(t)}.encode(${v})` : undefined;
+        };
+        // The builder's "pass it" note for an account, pointing at what fills it in instead.
+        const renote = (a, how) => {
+            const i = notes.findIndex((n) => n.startsWith(`instruction ${ix.name}: ${a.name} is not filled in (`));
+            if (i >= 0)
+                notes[i] = `${notes[i].replace(/; pass it$/, "")}; ${how}`;
+        };
+        const fieldOf = (accountType, field) => (defs.get(accountType ?? "")?.type.fields ?? []).find((f) => typeof f === "object" && f !== null && f.name === field);
+        const signers = flat.filter((a) => a.signer && !auto(a) && !a.optional);
         const rels = [];
         for (const a of flat) {
             if (auto(a) || a.optional || a.signer || !a.relations?.length)
@@ -997,30 +1237,30 @@ export function generateClient(idl, opts = {}) {
                 break;
             }
         }
-        // PDAs seeded from fields of another account of the instruction (Anchor `seeds = [b"vault", book.owner]`): the
-        // account is read on chain, then the PDA derived. Only scalar fields (integers, bool, Pubkey, unit enums).
-        const inputOf = (f) => `input${NAME.test(f.key) && !JS_RESERVED.has(f.key) ? `.${f.key}` : `[${JSON.stringify(f.key)}]`}`;
-        const scalarSeed = (t) => {
-            if (t === undefined)
-                return false;
-            if (typeof t === "string")
-                return t in INTS || t === "bool" || t === "pubkey" || t === "publicKey";
-            if (!t.defined)
-                return false;
-            const d = defs.get(definedName(t) ?? "");
-            return d?.type.kind === "enum" && (d.type.variants ?? []).every((v) => !v.fields?.length);
-        };
         const fieldPdas = [];
         for (const a of flat) {
             if (!a.pda || a.address || resolvable.has(a.key) || a.optional)
                 continue;
             const p = a.pda.program;
-            if (p && p.kind !== "const")
+            if (p && p.kind === "account")
                 continue;
+            let program = "PROGRAM_ADDRESS";
+            if (p?.kind === "const")
+                program = `programFromBytes(${bytes(p.value)})`;
+            else if (p?.kind === "arg") {
+                const t = argType.get(p.path ?? "");
+                if (t !== "pubkey" && t !== "publicKey")
+                    continue;
+                program = `args.${camel(p.path)}`;
+            }
             const bases = new Map();
             const seeds = [];
+            const own = [];
+            // Inputs of a `pdas` helper for a PDA seeded from its own fields: its own field values, accounts and arguments.
+            const params = new Map();
+            let autoDep = false;
             let ok = true;
-            let usesArgs = false;
+            let usesArgs = p?.kind === "arg";
             for (const sd of a.pda.seeds) {
                 if (sd.kind === "const")
                     seeds.push(bytes(sd.value));
@@ -1028,62 +1268,109 @@ export function generateClient(idl, opts = {}) {
                     const e = seedExpr(sd, a.group);
                     if (typeof e !== "string")
                         ok = false;
-                    else
-                        (seeds.push(e), (usesArgs = true));
+                    else {
+                        seeds.push(e);
+                        usesArgs = true;
+                        const head = sd.path.split(".")[0];
+                        params.set(camel(head), `${camel(head)}: ${tsType(argType.get(head), "in")}`);
+                    }
                 }
                 else if (!sd.path.includes(".")) {
                     const t = byPath(sd.path, a.group);
-                    if (!t || t === a || auto(t) || t.optional)
+                    if (!t || t === a || t.optional)
                         ok = false;
-                    else
-                        seeds.push(`getAddressEncoder().encode(key(${inputOf(t)}))`);
+                    else {
+                        use("getAddressEncoder");
+                        seeds.push(`getAddressEncoder().encode(key(${acc(t)}!))`);
+                        params.set(t.key, `${t.key}: Address | TransactionSigner`);
+                        if (auto(t))
+                            autoDep = true;
+                    }
                 }
                 else {
                     const parts = sd.path.split(".");
                     const base = parts.length === 2 ? byPath(parts[0], a.group) : undefined;
-                    const acc = accountConsts.find((c) => c.name === sd.account);
-                    const field = (defs.get(sd.account ?? "")?.type.fields ?? []).find((f) => typeof f === "object" && f !== null && f.name === parts[1]);
-                    if (!base || base === a || base.optional || auto(base) || !acc || !field || !scalarSeed(field.type))
+                    const field = fieldOf(sd.account, parts[1]);
+                    const consts = accountConsts.find((c) => c.name === sd.account);
+                    const enc = field && seedOfField(field.type, base === a ? `seeds.${camel(parts[1])}` : `${"$$" + (base?.key ?? "")}[${JSON.stringify(camel(parts[1]))}]`);
+                    if (!base || !field || !enc || base.optional)
+                        ok = false;
+                    else if (base === a) {
+                        own.push({ field: parts[1], type: field.type });
+                        params.set(camel(parts[1]), `${camel(parts[1])}: ${tsType(field.type, "in")}`);
+                        seeds.push(enc);
+                    }
+                    else if (!consts || auto(base))
                         ok = false;
                     else {
-                        bases.set(base.key, { base, A: acc.A });
-                        seeds.push(`${codec(field.type)}.encode(${"$$" + base.key}[${JSON.stringify(camel(parts[1]))}])`);
+                        bases.set(base.key, { base, A: consts.A });
+                        seeds.push(enc);
                     }
                 }
                 if (!ok)
                     break;
             }
-            if (!ok || bases.size === 0)
+            if (!ok)
+                continue;
+            if (own.length) {
+                // Seeded from its own fields: the address is needed to read them, so the caller gives the values instead.
+                if (bases.size)
+                    continue;
+                const json = JSON.stringify(a.pda);
+                let pn = camel(a.name);
+                if (pdaFns.has(pn) && pdaFns.get(pn).json !== json) {
+                    pn = `${fn}${pascal(a.name)}`;
+                    for (let i = 2; pdaFns.has(pn) && pdaFns.get(pn).json !== json; i++)
+                        pn = `${fn}${pascal(a.name)}${i}`;
+                }
+                renote(a, `pass it (pdas.${pn} derives it from the field values)`);
+                if (pdaFns.has(pn))
+                    continue;
+                if (p?.kind === "arg")
+                    params.set(camel(p.path), `${camel(p.path)}: Address`);
+                const rewrite = (e) => e
+                    .replace(/\bargs\.([A-Za-z0-9_$]+)/g, "seeds.$1")
+                    .replace(/key\(acc\.([A-Za-z0-9_$]+)!\)/g, "key(seeds.$1)")
+                    .replace(/key\(acc\["([^"]+)"\]!\)/g, 'key(seeds["$1"])');
+                use("type ProgramDerivedAddress", "getProgramDerivedAddress");
+                pdaFns.set(pn, {
+                    json,
+                    source: `    /** The ${a.name} PDA (as ${ix.name} derives it), from the values of its own fields it is seeded with (${own.map((o) => camel(o.field)).join(", ")}). */\n    ${prop(pn)}(seeds: { ${[...params.values()].join("; ")} }): Promise<ProgramDerivedAddress> {\n      return getProgramDerivedAddress({ programAddress: ${rewrite(program)}, seeds: [${seeds.map(rewrite).join(", ")}] });\n    },`,
+                });
+                continue;
+            }
+            if (bases.size === 0 || autoDep)
                 continue;
-            const program = p ? `programFromBytes(${bytes(p.value)})` : "PROGRAM_ADDRESS";
+            renote(a, `resolve.${fn} fills it in`);
             fieldPdas.push({
                 a,
                 usesArgs,
                 lines: [
-                    `      const ${"$" + a.key} =`,
-                    `        ${inputOf(a)} ??`,
-                    `        (await (async () => {`,
-                    ...[...bases.values()].map(({ base, A }) => `          const ${"$$" + base.key} = await ${A}.fetch(rpc, key(${inputOf(base)}));`),
-                    `          return (await getProgramDerivedAddress({ programAddress: ${program}, seeds: [${seeds.join(", ")}] }))[0];`,
-                    `        })());`,
+                    `      if (${acc(a)} === undefined) {`,
+                    ...[...bases.values()].map(({ base, A }) => `        const ${"$$" + base.key} = await ${A}.fetch(rpc, key(${acc(base)}!));`),
+                    `        ${acc(a)} = (await getProgramDerivedAddress({ programAddress: ${program}, seeds: [${seeds.join(", ")}] }))[0];`,
+                    `      }`,
                 ],
             });
         }
-        if (rels.length || fieldPdas.length) {
-            const filled = [...rels.map((r) => r.a), ...fieldPdas.map((f) => f.a)];
-            const keysOf = filled.map((a) => JSON.stringify(a.key)).join(" | ");
+        if (rels.length || fieldPdas.length || signers.length) {
+            const filled = [...signers, ...rels.map((r) => r.a), ...fieldPdas.map((f) => f.a)];
+            const keysOf = [...new Set(filled.map((a) => JSON.stringify(a.key)))].join(" | ");
             const withArgs = fieldPdas.some((f) => f.usesArgs);
             const what = [
+                ...(signers.length ? [`${signers.map((a) => a.key).join(", ")} (options.signer when left out)`] : []),
                 ...rels.map((r) => `${r.a.key} (from ${r.source.key}.${camel(r.a.name)})`),
                 ...fieldPdas.map((f) => `${f.a.key} (a PDA seeded from account fields)`),
             ].join(", ");
-            resolveKeys.push(`    /** ${P}Accounts with ${what} read from the chain when left out. */\n` +
-                `    async ${prop(fn)}(rpc: Rpc<GetAccountInfoApi>, input: Omit<${P}Accounts, ${keysOf}> & Partial<Pick<${P}Accounts, ${keysOf}>>${withArgs ? `, args: ${P}Args` : ""}): Promise<${P}Accounts> {\n` +
+            resolveKeys.push(`    /** ${P}Accounts with ${what} filled in. */\n` +
+                `    async ${prop(fn)}(rpc: Rpc<GetAccountInfoApi>, input: Omit<${P}Accounts, ${keysOf}> & Partial<Pick<${P}Accounts, ${keysOf}>>${withArgs ? `, args: ${P}Args` : ""}, options: { signer?: TransactionSigner } = {}): Promise<${P}Accounts> {\n` +
+                `      const acc: Partial<${P}Accounts> = { ...input };\n` +
                 [
-                    ...rels.map((r) => `      const ${"$" + r.a.key} = ${inputOf(r.a)} ?? (await readRelation(rpc, key(${inputOf(r.source)}), ${JSON.stringify(r.a.key)}, [${r.readers.join(", ")}]));`),
+                    ...signers.map((a) => `      if (${acc(a)} === undefined) {\n        if (!options.signer) throw new Error(${JSON.stringify(`${ix.name}: pass ${a.key}, or a default signer as options.signer`)});\n        ${acc(a)} = options.signer;\n      }`),
+                    ...rels.map((r) => `      ${acc(r.a)} ??= await readRelation(rpc, key(${acc(r.source)}!), ${JSON.stringify(r.a.key)}, [${r.readers.join(", ")}]);`),
                     ...fieldPdas.flatMap((f) => f.lines),
                 ].join("\n") +
-                `\n      return { ...input, ${filled.map((a) => `${prop(a.key)}: ${"$" + a.key}`).join(", ")} } as ${P}Accounts;\n    },`);
+                `\n      void rpc;\n      return acc as ${P}Accounts;\n    },`);
         }
         if (ix.returns !== undefined) {
             const why = issue(ix.returns);
@@ -1237,6 +1524,23 @@ export function generateClient(idl, opts = {}) {
                 `  });`,
             ],
         });
+    if (needsCStruct)
+        helperDefs.push({
+            name: "cStruct",
+            lines: [
+                `/** A zero-copy struct: each field at its #[repr(C)] offset in a block of \`size\` bytes (padding is zero). */`,
+                `const cStruct = (fields: [string, Codec<any, any>, number][], size: number): Codec<Record<string, unknown>, Record<string, unknown>> =>`,
+                `  createCodec<Record<string, unknown>, Record<string, unknown>>({`,
+                `    fixedSize: size,`,
+                `    write: (value, bytes, offset) => {`,
+                `      bytes.fill(0, offset, offset + size);`,
+                `      for (const [k, c, at] of fields) c.write(value[k], bytes, offset + at);`,
+                `      return offset + size;`,
+                `    },`,
+                `    read: (bytes, offset) => [Object.fromEntries(fields.map(([k, c, at]) => [k, c.read(bytes, offset + at)[0]])), offset + size],`,
+                `  });`,
+            ],
+        });
     if (needsUnitEnum)
         helperDefs.push({
             name: "unitEnum",

package/dist/svmrpc.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A kit RPC and subscriptions pair answered by LiteSVM, so generated clients run in tests as they run against a
+ * cluster: `sendInstructions`, `simulate`, `views`, `accounts.<Name>.fetch*` and `watch`, `resolve`, `eventsOf` and
+ * `watchEvents`. Only the methods those helpers call are answered.
+ *
+ *   const { rpc, rpcSubscriptions } = svmConnection(svm);
+ *   await counter.sendInstructions({ rpc, rpcSubscriptions }, alice, [await counter.initialize({ authority: alice })]);
+ *   await counter.accounts.Counter.fetch(rpc, address);
+ *
+ * Transactions run as they are sent (confirmed at once). LiteSVM cannot list accounts, so `getProgramAccounts` scans
+ * the accounts transactions sent through this connection named, plus those passed to `track`.
+ */
+import { type Address, type Rpc, type RpcSubscriptions, type SolanaRpcApi, type SolanaRpcSubscriptionsApi } from "@solana/kit";
+import { type LiteSVM, type TransactionMetadata } from "litesvm";
+export interface SvmConnection {
+    rpc: Rpc<SolanaRpcApi>;
+    rpcSubscriptions: RpcSubscriptions<SolanaRpcSubscriptionsApi>;
+    /** Every transaction sent through `rpc` that succeeded, in order. */
+    transactions: {
+        signature: string;
+        meta: TransactionMetadata;
+    }[];
+    /** Add accounts for `getProgramAccounts` to scan (accounts the transactions named are scanned already). */
+    track(...addresses: Address[]): void;
+}
+export declare function svmConnection(svm: LiteSVM): SvmConnection;

package/dist/svmrpc.js

@@ -0,0 +1,150 @@
+/**
+ * A kit RPC and subscriptions pair answered by LiteSVM, so generated clients run in tests as they run against a
+ * cluster: `sendInstructions`, `simulate`, `views`, `accounts.<Name>.fetch*` and `watch`, `resolve`, `eventsOf` and
+ * `watchEvents`. Only the methods those helpers call are answered.
+ *
+ *   const { rpc, rpcSubscriptions } = svmConnection(svm);
+ *   await counter.sendInstructions({ rpc, rpcSubscriptions }, alice, [await counter.initialize({ authority: alice })]);
+ *   await counter.accounts.Counter.fetch(rpc, address);
+ *
+ * Transactions run as they are sent (confirmed at once). LiteSVM cannot list accounts, so `getProgramAccounts` scans
+ * the accounts transactions sent through this connection named, plus those passed to `track`.
+ */
+import { getAddressDecoder, getBase58Decoder, getBase58Encoder, getBase64Decoder, getBase64Encoder, getCompiledTransactionMessageDecoder, getTransactionDecoder, } from "@solana/kit";
+import { FailedTransactionMetadata } from "litesvm";
+const b64 = (bytes) => getBase64Decoder().decode(bytes);
+const reply = (value) => ({ send: async () => value });
+export function svmConnection(svm) {
+    const transactions = [];
+    const known = new Set();
+    const decode = (wire) => {
+        const tx = getTransactionDecoder().decode(getBase64Encoder().encode(wire));
+        return { tx, keys: getCompiledTransactionMessageDecoder().decode(tx.messageBytes).staticAccounts };
+    };
+    const encoded = (a) => {
+        const acct = svm.getAccount(a);
+        if (!acct.exists)
+            return null;
+        return {
+            data: [b64(acct.data), "base64"],
+            executable: acct.executable,
+            lamports: acct.lamports,
+            owner: acct.programAddress,
+            space: BigInt(acct.data.length),
+            rentEpoch: 0n,
+        };
+    };
+    const rpc = {
+        getLatestBlockhash: () => reply({ context: { slot: 0n }, value: { blockhash: svm.latestBlockhash(), lastValidBlockHeight: 1000000n } }),
+        getEpochInfo: () => reply({ absoluteSlot: 0n, blockHeight: 0n, epoch: 0n, slotIndex: 0n, slotsInEpoch: 432000n, transactionCount: null }),
+        getSignatureStatuses: (sigs) => reply({
+            context: { slot: 0n },
+            value: sigs.map((s) => transactions.some((t) => t.signature === s)
+                ? { confirmationStatus: "confirmed", confirmations: null, err: null, slot: 0n, status: { Ok: null } }
+                : null),
+        }),
+        getMinimumBalanceForRentExemption: (space) => reply(svm.minimumBalanceForRentExemption(space)),
+        getBalance: (a) => reply({ context: { slot: 0n }, value: svm.getBalance(a) ?? 0n }),
+        sendTransaction: (wire) => ({
+            send: async () => {
+                const { tx, keys } = decode(wire);
+                const res = svm.sendTransaction(tx);
+                svm.expireBlockhash();
+                if (res instanceof FailedTransactionMetadata)
+                    throw new Error(`transaction failed: ${String(res.err())}\n${res.meta().logs().join("\n")}`);
+                for (const k of keys)
+                    known.add(k);
+                const signature = getBase58Decoder().decode(res.signature());
+                transactions.push({ signature, meta: res });
+                return signature;
+            },
+        }),
+        simulateTransaction: (wire, config = {}) => ({
+            send: async () => {
+                // Simulations are usually unsigned (sigVerify: false): turn LiteSVM's check off for this one only.
+                const inner = svm.inner;
+                const restore = config.sigVerify === false && inner?.getSigverify?.() === true;
+                if (restore)
+                    svm.withSigverify(false);
+                let res;
+                try {
+                    res = svm.simulateTransaction(decode(wire).tx);
+                }
+                finally {
+                    if (restore)
+                        svm.withSigverify(true);
+                }
+                if (res instanceof FailedTransactionMetadata)
+                    return {
+                        context: { slot: 0n },
+                        value: { err: String(res.err()), logs: res.meta().logs(), unitsConsumed: res.meta().computeUnitsConsumed(), returnData: null },
+                    };
+                const meta = res.meta();
+                const ret = meta.returnData();
+                return {
+                    context: { slot: 0n },
+                    value: {
+                        err: null,
+                        logs: meta.logs(),
+                        unitsConsumed: meta.computeUnitsConsumed(),
+                        returnData: ret.data().length ? { programId: getAddressDecoder().decode(ret.programId()), data: [b64(ret.data()), "base64"] } : null,
+                    },
+                };
+            },
+        }),
+        getAccountInfo: (a) => reply({ context: { slot: 0n }, value: encoded(a) }),
+        getMultipleAccounts: (addresses) => reply({ context: { slot: 0n }, value: addresses.map(encoded) }),
+        getProgramAccounts: (program, config = {}) => reply([...known]
+            .map((a) => ({ pubkey: a, account: encoded(a) }))
+            .filter(({ account }) => account && account.owner === program)
+            .filter(({ account }) => {
+            const data = getBase64Encoder().encode(account.data[0]);
+            return (config.filters ?? []).every(({ memcmp, dataSize }) => {
+                if (dataSize !== undefined)
+                    return BigInt(data.length) === BigInt(dataSize);
+                if (!memcmp)
+                    return true;
+                const want = getBase58Encoder().encode(memcmp.bytes);
+                return want.every((b, i) => data[Number(memcmp.offset) + i] === b);
+            });
+        })),
+        // The json shape: log messages, and inner instructions with base58 data (what `eventsOf` reads).
+        getTransaction: (signature) => {
+            const t = transactions.find((x) => x.signature === signature);
+            return reply(t
+                ? {
+                    slot: 0n,
+                    blockTime: null,
+                    meta: {
+                        err: null,
+                        logMessages: t.meta.logs(),
+                        computeUnitsConsumed: t.meta.computeUnitsConsumed(),
+                        innerInstructions: t.meta
+                            .innerInstructions()
+                            .map((group, index) => ({ index, instructions: group.map((i) => ({ data: getBase58Decoder().decode(i.instruction().data()) })) })),
+                    },
+                }
+                : null);
+        },
+    };
+    /** Notifications that end when the subscriber aborts. */
+    const stream = (items) => ({
+        subscribe: async ({ abortSignal }) => (async function* () {
+            for (const item of items())
+                yield item;
+            await new Promise((resolve) => abortSignal.addEventListener("abort", resolve, { once: true }));
+        })(),
+    });
+    const rpcSubscriptions = {
+        signatureNotifications: () => stream(() => [{ context: { slot: 0n }, value: { err: null } }]),
+        slotNotifications: () => stream(() => []),
+        logsNotifications: () => stream(() => transactions.map((t) => ({ context: { slot: 0n }, value: { signature: t.signature, logs: t.meta.logs(), err: null } }))),
+        accountNotifications: (a) => stream(() => [{ context: { slot: 0n }, value: encoded(a) ?? { data: ["", "base64"], lamports: 0n } }]),
+    };
+    return {
+        rpc: rpc,
+        rpcSubscriptions: rpcSubscriptions,
+        transactions,
+        track: (...addresses) => addresses.forEach((a) => known.add(a)),
+    };
+}

package/dist/testing.d.ts

@@ -19,6 +19,8 @@
 import anchor, { type Idl } from "@anchor-lang/core";
 import { type Address, type Instruction, type KeyPairSigner } from "@solana/kit";
 import { FailedTransactionMetadata, LiteSVM, TransactionMetadata } from "litesvm";
+import { type SvmConnection, svmConnection } from "./svmrpc.js";
+export { type SvmConnection, svmConnection };
 declare const BorshCoder: typeof anchor.BorshCoder;
 type BorshCoder = InstanceType<typeof BorshCoder>;
 export type Result = TransactionMetadata | FailedTransactionMetadata;
@@ -58,9 +60,10 @@ export interface TestProgram {
     returned<T = unknown>(instruction: string, res: Result): T;
     /** Lamports of any account (0 when it does not exist). */
     balance(address: Address): bigint;
+    /** A kit RPC and subscriptions pair over this LiteSVM, for the generated client (`svmConnection`). */
+    connection: SvmConnection;
 }
 /** Build `program` of the project around `from` (a file URL such as import.meta.url, or a directory) and load it. */
 export declare function testProgram(program: string, from: string | URL): Promise<TestProgram>;
 /** The same helpers for a program already loaded into `svm` at `programId` with this IDL. */
 export declare function programHarness(svm: LiteSVM, programId: Address, idl: Idl): TestProgram;
-export {};

package/dist/testing.js

@@ -22,7 +22,9 @@ import { FailedTransactionMetadata, LiteSVM } from "litesvm";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { svmConnection } from "./svmrpc.js";
 import { buildWorkspace, findWorkspace } from "./workspace.js";
+export { svmConnection };
 // @anchor-lang/core is CommonJS: Node 22 cannot import its classes by name from an installed ES module.
 const { BN, BorshCoder } = anchor;
 const BIG = new Set(["u64", "i64", "u128", "i128"]);
@@ -332,6 +334,7 @@ export function programHarness(svm, programId, idl) {
         balance(address) {
             return svm.getBalance(address) ?? 0n;
         },
+        connection: svmConnection(svm),
     };
     return harness;
 }

package/docs/client.md

@@ -48,7 +48,7 @@ for await (const { signature, event } of ledgerbook.watchEvents(rpcSubscriptions
 await ledgerbook.approveMany({ approver: signer, book }, { indices: [0n, 1n] }, [{ address: extra, role: AccountRole.WRITABLE }]);
 
 // has_one accounts that do not sign, read from the account that names them (Anchor resolves `relations` the same way)
-const accounts = await ledgerbook.resolve.someInstruction(rpc, { book }); // fills in what book's Pubkey fields name
+const accounts = await ledgerbook.resolve.someInstruction(rpc, { book }, { signer }); // signers, and what book's fields name
 
 // Events of a fetched transaction (getTransaction, json): log events and emitCpi events from inner instructions
 ledgerbook.eventsOf(await rpc.getTransaction(signature, { maxSupportedTransactionVersion: 0 }).send());
@@ -64,9 +64,9 @@ Kit's own transaction functions work with the instructions as well; `sendInstruc
 | `<program>.<instruction>(accounts, args)` | Builds the `Instruction`. Accounts with a fixed address and PDAs whose seeds are constants, arguments or other accounts' keys are optional and filled in; pass one to override. An optional account passed as `null` is left out (sent as the program id, the convention TypeSOL and Anchor share); left undefined, it is filled in like any other. |
 | `<program>.<instruction>(accounts, args, remaining?)` | The same, with remaining accounts appended in order (kit `AccountMeta`s). |
 | `<program>.accounts.<Name>` | `decode(bytes)`, `encode(value)`, `fetch(rpc, address)`, `fetchMaybe(rpc, address)`, `fetchMultiple(rpc, addresses)`, `fetchAll(rpc, filters?)` (getProgramAccounts by discriminator, plus `{ offset, bytes }` filters), `watch(rpcSubscriptions, address, { abortSignal })`, `discriminator`. `decode` checks the discriminator. |
-| `<program>.pdas.<account>(seeds)` | The PDA (address and bump) for each account an instruction derives. |
+| `<program>.pdas.<account>(seeds)` | The PDA (address and bump) for each account an instruction derives, also one seeded from its own fields (from the field values). |
 | `<program>.returns.<instruction>(bytes)` | Decodes return data. |
-| `<program>.resolve.<instruction>(rpc, accounts, args?)` | Fills in what needs the chain: `has_one` accounts that do not sign (read from the account that names them) and PDAs seeded from another account's fields (`seeds = [b"vault", book.owner]`: the account is read, then the PDA derived). Given accounts are kept. |
+| `<program>.resolve.<instruction>(rpc, accounts, args?, { signer? })` | Fills in what needs the chain or the wallet: signer accounts left out (`options.signer`, the default signer, like Anchor's provider wallet), `has_one` accounts that do not sign (read from the account that names them), and PDAs seeded from another account's fields, scalars, strings or bytes (`seeds = [b"vault", book.owner]`: the account is read, then the PDA derived). Given accounts are kept. |
 | `<program>.views.<instruction>(rpc, feePayer, accounts, args)` | Simulates an instruction that returns a value and decodes it (throws with the logs if it fails). |
 | `<program>.sendInstructions(connection, feePayer, instructions)`, `simulate(rpc, feePayer, instructions)` | One transaction sent and confirmed (kit's sendAndConfirm), or simulated without signatures (error, logs, units, this program's return data). |
 | `<program>.errors`, `errorCode(e)`, `isError(e, name)` | The program's errors (6000+), and for TypeSOL programs also every Anchor framework error (`AnchorError` and the constraints raise them) and TypeSOL's runtime errors. |
@@ -89,12 +89,14 @@ Anchor IDLs are refused with a hint to convert them (`anchor idl convert`).
 
 - **Errors and events are matched by code and discriminator, not by program.** A program this one calls can raise the
   same error code, and `parseEvents` reads every `Program data:` line that decodes as one of this program's events.
-- **Not filled in automatically** (pass them): `has_one` accounts that sign (they have to sign), PDAs seeded from an
-  account's own fields or from fields inside an argument, PDAs seeded from non-scalar fields (strings, structs), and PDAs
-  whose program comes from an argument. `typesol client` prints a note for each. `has_one` accounts that do not sign and
-  PDAs seeded from another account's scalar fields are filled in by `resolve` (it reads the chain).
-- **Left out of a client generated from an Anchor IDL**, with a note: generic types and anything using them, and
-  zero-copy (`bytemuck`) accounts.
-- **Not done yet**: a LiteSVM loader for tests (use `svm.addProgramFromFile(ledgerbook.address, soPath)`, or
-  `typesol/testing`). `watchEvents` reads log events; with `rpc` it also fetches each transaction in which the program
-  invoked itself and reads its `emitCpi` events (log subscriptions do not carry inner instructions).
+- **Not filled in automatically** (pass them): PDAs seeded from struct fields (Anchor cannot seed with them either),
+  PDAs whose program is another account's field, and a PDA seeded from its own fields (derive it with its `pdas`
+  helper from the values). `typesol client` prints a note for each.
+- **Anchor IDLs**: zero-copy (`bytemuck`) accounts decode and encode at their `#[repr(C)]` offsets as the program sees
+  them on SBF (padding included; `packed` and `align` honored; 128-bit integers align to 8). Generic types become one
+  type per use with concrete arguments (`Pair<u64, 2>` is `PairU64N2`). Left out, with a note: zero-copy types with
+  Rust's own layout (`repr(Rust)`) or holding a non-zero-copy type, and the generic definitions themselves.
+- **In tests**: `svmConnection(svm)` from `typesol/testing` answers the client's RPC calls from LiteSVM, and
+  `testProgram(...)` has it as `t.connection` ([test-your-program.md](test-your-program.md)).
+- `watchEvents` reads log events; with `rpc` it also fetches each transaction in which the program invoked itself and
+  reads its `emitCpi` events (log subscriptions do not carry inner instructions).

package/docs/test-your-program.md

@@ -44,9 +44,12 @@ it("counts", async () => {
 | `t.account(type, address)` | the account decoded by its IDL type (bigints, address strings), or `null` once closed. TypeSOL fixed layouts come back as their IDL structs: a `FixedString<N>` as `{ len, bytes }`, a `FixedVec<T, N>` as `{ len, items }` (the generated client gives strings and arrays) |
 | `t.returned(instruction, res)` | the instruction's return data: an integer, boolean, Pubkey or struct |
 | `t.balance(address)` | lamports |
+| `t.connection` | `{ rpc, rpcSubscriptions }` answered by this LiteSVM, for the generated client: `counter.sendInstructions(t.connection, alice, [ix])`, `counter.accounts.Counter.fetch(t.connection.rpc, address)`, views, `resolve`, `watch` and `watchEvents` |
 
 `t.svm`, `t.programId`, `t.idl` and `t.coder` are there for anything else, e.g. writing a mint straight into the VM
 with `t.svm.setAccount` (see the escrow template). `programHarness(svm, programId, idl)` gives the same helpers for a
-program you loaded yourself.
+program you loaded yourself, and `svmConnection(svm)` the RPC pair alone (for any LiteSVM, e.g. one with an Anchor
+program loaded). Transactions sent through it run at once; `getProgramAccounts` (`fetchAll`) sees the accounts those
+transactions named, plus any you `track(...)`.
 
 The module needs `litesvm` and `@anchor-lang/core`, which `typesol init` adds to `devDependencies`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typesol/cli",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Compile a TypeScript-syntax language directly to Solana SBF programs.",
   "type": "module",
   "license": "MIT",