@typesol/cli 0.19.0 → 0.21.0

package/CHANGELOG.md

@@ -5,6 +5,34 @@ until 1.0, a minor version may change the language, the IDL layout or error code
 
 ## Unreleased
 
+## 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,
+PDAs seeded from another account's fields, and `emitCpi` events as they happen. Programs and their bytes are
+unchanged. Not externally audited (see SECURITY.md).
+
+### Added
+- `typesol client --address <program id> --url <rpc>`: a client from the IDL on chain, the canonical Program Metadata
+  IDL (`typesol idl publish`, Codama) or else Anchor's IDL account (`anchor idl init`).
+- Generated clients: `resolve.<instruction>(rpc, accounts)` fills in `has_one` accounts that do not sign from the
+  account that names them, as Anchor's client resolves `relations`, and PDAs seeded from another account's fields
+  (`seeds = [b"vault", book.owner]`: the account is read, then the PDA derived).
+- `watchEvents(rpcSubscriptions, { abortSignal, rpc })`: with an RPC, `emitCpi` events arrive live too (the transaction
+  is fetched when the program invoked itself).
+
+## 0.20.0 — 2026-10-28
+
+The generated TypeScript clients catch up with Anchor's: remaining accounts, listing and watching accounts, sending
+and simulating, views, `emitCpi` events and every Anchor error by name. Programs and their bytes are unchanged. Not
+externally audited (see SECURITY.md).
+
+### Added
+- Generated clients: remaining accounts on every instruction builder; `accounts.<Name>.fetchMultiple`, `fetchAll`
+  (getProgramAccounts by discriminator, with `{ offset, bytes }` filters) and `watch` (account subscription);
+  `sendInstructions` (send and confirm), `simulate`, and `views.<instruction>` (a return value by simulation, Anchor's
+  `.view()`); `parseCpiEvents` / `eventsOf` for `emitCpi` events, and `watchEvents` (log subscription). Every Anchor
+  framework error has its name in `errors`, so `isError` knows the codes `AnchorError` and the constraints raise.
+
 ## 0.19.0 — 2026-10-28
 
 Anchor's error codes where TypeSOL raised its own: `TokenOf` / `MintOf` constraints that name the parameters as

package/README.md

@@ -306,7 +306,7 @@ Details are in [docs/testing.md](docs/testing.md).
 
 ## Status
 
-**TypeSOL is pre-1.0 (0.19).** Releases follow the organization's
+**TypeSOL is pre-1.0 (0.21).** 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/cli.js

@@ -277,14 +277,37 @@ const COMMANDS = {
         },
     },
     client: {
-        usage: "typesol client <idl.json> [--out <file.ts>] [--address <base58>]",
-        help: "Generate a typed TypeScript client (on @solana/kit) from an Anchor IDL (0.30+/1.x or TypeSOL). The IDL is validated first;\n  what the client leaves out is printed as notes. `typesol build` already writes <name>.client.ts for TypeSOL programs.",
-        options: { out: { type: "string" }, address: { type: "string" } },
-        run(v, args) {
-            const file = one(args, "<idl.json>");
+        usage: "typesol client <idl.json> [--out <file.ts>] [--address <base58>]\n  typesol client --address <program id> [--url <rpc>] [--config <solana cli config>] [--out <file.ts>]",
+        help: [
+            "Generate a typed TypeScript client (on @solana/kit) from an Anchor IDL (0.30+/1.x or TypeSOL). The IDL is validated first;",
+            "what the client leaves out is printed as notes. `typesol build` already writes <name>.client.ts for TypeSOL programs.",
+            "Without an IDL file, the IDL is read from the chain for the program at --address: the canonical Program Metadata IDL",
+            "(`typesol idl publish`, Codama), else Anchor's IDL account (`anchor idl init`).",
+        ].join("\n  "),
+        options: { out: { type: "string" }, address: { type: "string" }, url: { type: "string" }, config: { type: "string" } },
+        async run(v, args) {
             if (v.address && !decodeAddress(v.address))
                 throw new UsageError(`--address "${v.address}" is not a base58 Solana address`);
-            const res = generateClient(readJson(file), { address: v.address });
+            let idl;
+            if (args.length === 0) {
+                if (!v.address)
+                    throw new UsageError("pass an IDL file, or --address to read the program's IDL from the chain");
+                const rpcUrl = v.url ?? solanaConfig(v.config).url;
+                if (!rpcUrl)
+                    throw new Error("no RPC: pass --url, or set json_rpc_url in the Solana CLI config");
+                // Loaded only here: the other commands do not need an RPC client.
+                const kit = await import("@solana/kit");
+                const { fetchProgramIdl } = await import("./idlpublish.js");
+                const found = await fetchProgramIdl(kit.createSolanaRpc(clusterUrl(rpcUrl)), kit.address(v.address));
+                console.error(`  IDL from ${found.source === "anchor" ? "Anchor's IDL account" : "the Program Metadata program"}`);
+                idl = found.idl;
+            }
+            else {
+                if (v.url)
+                    throw new UsageError("--url reads the IDL from the chain: leave out the IDL file");
+                idl = readJson(one(args, "<idl.json>"));
+            }
+            const res = generateClient(idl, { address: v.address });
             if (v.out) {
                 writeFileSync(v.out, res.source);
                 log(`  wrote ${v.out}`);

package/dist/clientgen.d.ts

@@ -90,7 +90,10 @@ export interface ClientGenResult {
 /** An IDL the generator refuses: malformed, unsafe to embed, or older than the 0.30 IDL format. */
 export declare class ClientIdlError extends Error {
 }
-/** TypeSOL runtime and Anchor framework errors a TypeSOL program can return, by code (runtime/typesol_rt.h). */
+/**
+ * Errors a TypeSOL program can return, by code: every Anchor framework error (`AnchorError` raises any of them, and
+ * the constraints raise their Anchor codes), then TypeSOL's own runtime errors (runtime/typesol_rt.h).
+ */
 export declare const TYPESOL_ERRORS: Record<number, string>;
 export declare function generateClient(idl: ClientIdl, opts?: {
     address?: string;

package/dist/clientgen.js

@@ -18,12 +18,17 @@
  * sanitized comments.
  */
 import { mkdirSync, writeFileSync } from "node:fs";
+import { ANCHOR_ERRORS } from "./compiler/anchor-errors.js";
 import path from "node:path";
 /** An IDL the generator refuses: malformed, unsafe to embed, or older than the 0.30 IDL format. */
 export class ClientIdlError extends Error {
 }
-/** TypeSOL runtime and Anchor framework errors a TypeSOL program can return, by code (runtime/typesol_rt.h). */
+/**
+ * Errors a TypeSOL program can return, by code: every Anchor framework error (`AnchorError` raises any of them, and
+ * the constraints raise their Anchor codes), then TypeSOL's own runtime errors (runtime/typesol_rt.h).
+ */
 export const TYPESOL_ERRORS = {
+    ...Object.fromEntries(Object.entries(ANCHOR_ERRORS).map(([name, code]) => [code, name])),
     100: "InstructionMissing",
     101: "InstructionFallbackNotFound",
     102: "InstructionDidNotDeserialize",
@@ -164,7 +169,25 @@ const TAKEN = [
     "globalThis",
 ];
 const KIT_TYPES = [
+    "AccountMeta",
+    "AccountNotificationsApi",
     "Address",
+    "Base58EncodedBytes",
+    "Commitment",
+    "FetchAccountsConfig",
+    "GetEpochInfoApi",
+    "GetLatestBlockhashApi",
+    "GetMultipleAccountsApi",
+    "GetProgramAccountsApi",
+    "GetSignatureStatusesApi",
+    "GetTransactionApi",
+    "LogsNotificationsApi",
+    "RpcSubscriptions",
+    "SendTransactionApi",
+    "Signature",
+    "SignatureNotificationsApi",
+    "SimulateTransactionApi",
+    "SlotNotificationsApi",
     "Codec",
     "FetchAccountConfig",
     "GetAccountInfoApi",
@@ -176,6 +199,21 @@ const KIT_TYPES = [
 ];
 const KIT_VALUES = [
     "AccountRole",
+    "appendTransactionMessageInstructions",
+    "assertIsTransactionWithBlockhashLifetime",
+    "compileTransaction",
+    "createTransactionMessage",
+    "fetchEncodedAccounts",
+    "getBase58Decoder",
+    "getBase58Encoder",
+    "getBase64EncodedWireTransaction",
+    "getSignatureFromTransaction",
+    "pipe",
+    "sendAndConfirmTransactionFactory",
+    "setTransactionMessageFeePayer",
+    "setTransactionMessageFeePayerSigner",
+    "setTransactionMessageLifetimeUsingBlockhash",
+    "signTransactionMessageWithSigners",
     "SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM",
     "addCodecSizePrefix",
     "address",
@@ -214,7 +252,23 @@ const KIT_VALUES = [
     "transformCodec",
 ];
 // Keys of the program object that instructions must not take.
-const PROGRAM_KEYS = new Set(["address", "accounts", "pdas", "returns", "errors", "errorCode", "isError", "parseEvents"]);
+const PROGRAM_KEYS = new Set([
+    "address",
+    "accounts",
+    "pdas",
+    "returns",
+    "views",
+    "resolve",
+    "errors",
+    "errorCode",
+    "isError",
+    "parseEvents",
+    "parseCpiEvents",
+    "eventsOf",
+    "watchEvents",
+    "sendInstructions",
+    "simulate",
+]);
 // snake_case → camelCase by splitting (linear time, whatever the input): "taker_token_a" → "takerTokenA".
 const camel = (s) => s
     .split("_")
@@ -671,6 +725,8 @@ export function generateClient(idl, opts = {}) {
     // ---- Accounts ---------------------------------------------------------------------------------------------
     const accountOut = [];
     const accountKeys = [];
+    /** Each account's decoder object and its Pubkey fields (snake_case), for has_one relations. */
+    const accountConsts = [];
     for (const a of idl.accounts ?? []) {
         if (!defs.has(a.name) || typeIssue(a.name) || special(a.name)) {
             notes.push(`account ${a.name}: ${typeIssue(a.name) ?? "no type definition"}; it is left out`);
@@ -699,8 +755,28 @@ export function generateClient(idl, opts = {}) {
             `    const found = await fetchEncodedAccount(rpc, at, config);\n` +
             `    return found.exists ? ${A}.decode(found.data) : null;\n` +
             `  },\n` +
+            `  /** Several accounts in one request, in order; null where one does not exist. */\n` +
+            `  async fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, at: readonly Address[], config?: FetchAccountsConfig): Promise<(${T} | null)[]> {\n` +
+            `    const found = await fetchEncodedAccounts(rpc, [...at], config);\n` +
+            `    return found.map((a) => (a.exists ? ${A}.decode(a.data) : null));\n` +
+            `  },\n` +
+            `  /** Every ${commentText(a.name)} account of the program (getProgramAccounts by discriminator), optionally where \`bytes\` are at \`offset\` of the data. */\n` +
+            `  async fetchAll(rpc: Rpc<GetProgramAccountsApi>, filters: readonly { offset: number; bytes: ReadonlyUint8Array }[] = []): Promise<{ address: Address; data: ${T} }[]> {\n` +
+            `    const found = await rpc.getProgramAccounts(PROGRAM_ADDRESS, { encoding: "base64", filters: memcmp([{ offset: 0, bytes: ${A}_DISCRIMINATOR }, ...filters]) }).send();\n` +
+            `    return found.map((a) => ({ address: a.pubkey, data: ${A}.decode(getBase64Encoder().encode(a.account.data[0])) }));\n` +
+            `  },\n` +
+            `  /** Each change of the account, decoded (null once it is closed), until \`abortSignal\` aborts. */\n` +
+            `  async *watch(rpcSubscriptions: RpcSubscriptions<AccountNotificationsApi>, at: Address, options: { abortSignal: AbortSignal; commitment?: Commitment }): AsyncGenerator<${T} | null> {\n` +
+            `    const updates = await rpcSubscriptions.accountNotifications(at, { encoding: "base64", ...(options.commitment ? { commitment: options.commitment } : {}) }).subscribe({ abortSignal: options.abortSignal });\n` +
+            `    for await (const u of updates) {\n` +
+            `      const data = getBase64Encoder().encode(u.value.data[0]);\n` +
+            `      yield data.length === 0 ? null : ${A}.decode(data);\n` +
+            `    }\n` +
+            `  },\n` +
             `};\n`);
         accountKeys.push(`${prop(a.name)}: ${A}`);
+        const fields = (defs.get(a.name).type.fields ?? []).filter((f) => typeof f === "object" && f !== null && "name" in f);
+        accountConsts.push({ name: a.name, A, pubkeys: new Set(fields.filter((f) => f.type === "pubkey" || f.type === "publicKey").map((f) => f.name)) });
     }
     // ---- Events -----------------------------------------------------------------------------------------------
     const events = (idl.events ?? []).filter((e) => {
@@ -724,6 +800,8 @@ export function generateClient(idl, opts = {}) {
     const ixKeys = [];
     const pdaFns = new Map();
     const returnKeys = [];
+    const viewKeys = [];
+    const resolveKeys = [];
     const usedKeys = new Set();
     for (const ix of idl.instructions) {
         const argIssue = ix.args.map((a) => issue(a.type)).find(Boolean);
@@ -825,7 +903,7 @@ export function generateClient(idl, opts = {}) {
             resolvable.delete(a.key);
         }
         const auto = (a) => Boolean(a.address) || resolvable.has(a.key);
-        use("type Address", "type TransactionSigner", "type Instruction", "AccountRole");
+        use("type Address", "type TransactionSigner", "type Instruction", "type AccountMeta", "AccountRole");
         const accType = (a) => `${a.signer ? "TransactionSigner | Address" : "Address"}${a.optional ? " | null" : ""}`;
         const accountsIface = `export interface ${P}Accounts {\n` +
             flat.map((a) => `${doc(a.docs, "  ")}  ${prop(a.key)}${auto(a) || a.optional ? "?" : ""}: ${accType(a)};`).join("\n") +
@@ -896,16 +974,132 @@ export function generateClient(idl, opts = {}) {
             : bytes(ix.discriminator);
         ixOut.push(accountsIface +
             argsIface +
-            `${doc(ix.docs)}async function build${P}(input: ${P}Accounts${argsField.length ? `, args: ${P}Args` : ""}): Promise<Instruction> {\n` +
+            `${doc(ix.docs)}async function build${P}(input: ${P}Accounts${argsField.length ? `, args: ${P}Args` : ""}, remaining: readonly AccountMeta[] = []): Promise<Instruction> {\n` +
             lines.join("\n") +
-            `\n  return {\n    programAddress: PROGRAM_ADDRESS,\n    accounts: [\n${metas.join("\n")}\n    ],\n    data: ${data},\n  } as Instruction;\n}\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.
+        const rels = [];
+        for (const a of flat) {
+            if (auto(a) || a.optional || a.signer || !a.relations?.length)
+                continue;
+            for (const r of a.relations) {
+                const source = byPath(r, a.group);
+                if (!source || source.optional)
+                    continue;
+                const readers = accountConsts
+                    .filter((c) => c.pubkeys.has(a.name))
+                    .map((c) => `(d) => (hasPrefix(d, ${c.A}.discriminator) ? ${c.A}.decode(d)[${JSON.stringify(camel(a.name))}] : undefined)`);
+                if (!readers.length)
+                    continue;
+                rels.push({ a, source, readers });
+                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")
+                continue;
+            const bases = new Map();
+            const seeds = [];
+            let ok = true;
+            let usesArgs = false;
+            for (const sd of a.pda.seeds) {
+                if (sd.kind === "const")
+                    seeds.push(bytes(sd.value));
+                else if (sd.kind === "arg") {
+                    const e = seedExpr(sd, a.group);
+                    if (typeof e !== "string")
+                        ok = false;
+                    else
+                        (seeds.push(e), (usesArgs = true));
+                }
+                else if (!sd.path.includes(".")) {
+                    const t = byPath(sd.path, a.group);
+                    if (!t || t === a || auto(t) || t.optional)
+                        ok = false;
+                    else
+                        seeds.push(`getAddressEncoder().encode(key(${inputOf(t)}))`);
+                }
+                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))
+                        ok = false;
+                    else {
+                        bases.set(base.key, { base, A: acc.A });
+                        seeds.push(`${codec(field.type)}.encode(${"$$" + base.key}[${JSON.stringify(camel(parts[1]))}])`);
+                    }
+                }
+                if (!ok)
+                    break;
+            }
+            if (!ok || bases.size === 0)
+                continue;
+            const program = p ? `programFromBytes(${bytes(p.value)})` : "PROGRAM_ADDRESS";
+            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 (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(" | ");
+            const withArgs = fieldPdas.some((f) => f.usesArgs);
+            const what = [
+                ...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` +
+                [
+                    ...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(", ")}]));`),
+                    ...fieldPdas.flatMap((f) => f.lines),
+                ].join("\n") +
+                `\n      return { ...input, ${filled.map((a) => `${prop(a.key)}: ${"$" + a.key}`).join(", ")} } as ${P}Accounts;\n    },`);
+        }
         if (ix.returns !== undefined) {
             const why = issue(ix.returns);
             if (why)
                 notes.push(`instruction ${ix.name}: the return value is not decoded (${why})`);
-            else
+            else {
                 returnKeys.push(`    ${prop(fn)}: (data: ReadonlyUint8Array): ${tsType(ix.returns, "out")} => ${codec(ix.returns)}.decode(data),`);
+                // Read-only call: simulate the instruction and decode what it returns (Anchor's `.view()`).
+                viewKeys.push(`    /** ${ix.name}'s return value, by simulation (nothing is sent). */\n` +
+                    `    async ${prop(fn)}(rpc: Rpc<SimulateTransactionApi & GetLatestBlockhashApi>, feePayer: Address | TransactionSigner, input: ${P}Accounts${argsField.length ? `, args: ${P}Args` : ""}): Promise<${tsType(ix.returns, "out")}> {\n` +
+                    `      const res = await simulate(rpc, feePayer, [await build${P}(input${argsField.length ? ", args" : ""})]);\n` +
+                    `      if (res.err !== null) throw new Error(${JSON.stringify(`${ix.name} failed in simulation: `)} + JSON.stringify(res.err, (_, v) => (typeof v === "bigint" ? v.toString() : v)) + "\\n" + res.logs.join("\\n"));\n` +
+                    `      if (res.returnData === null) throw new Error(${JSON.stringify(`${ix.name} returned nothing`)});\n` +
+                    `      return ${codec(ix.returns)}.decode(res.returnData);\n` +
+                    `    },`);
+            }
         }
     }
     // ---- Assemble ---------------------------------------------------------------------------------------------
@@ -961,6 +1155,28 @@ export function generateClient(idl, opts = {}) {
             ],
         },
         { name: "programFromBytes", lines: [`const programFromBytes = (b: Uint8Array): Address => getAddressDecoder().decode(b);`] },
+        {
+            name: "readRelation",
+            lines: [
+                `/** A Pubkey field of an account on chain, read by the first reader that knows its type. */`,
+                `const readRelation = async (rpc: Rpc<GetAccountInfoApi>, at: Address, name: string, readers: ((data: ReadonlyUint8Array) => Address | undefined)[]): Promise<Address> => {`,
+                `  const found = await fetchEncodedAccount(rpc, at);`,
+                `  if (!found.exists) throw new Error("cannot fill in " + name + ": account " + at + " does not exist");`,
+                `  for (const read of readers) {`,
+                `    const v = read(found.data);`,
+                `    if (v !== undefined) return v;`,
+                `  }`,
+                `  throw new Error("cannot fill in " + name + ": " + at + " is not an account that names it");`,
+                `};`,
+            ],
+        },
+        {
+            name: "memcmp",
+            lines: [
+                `const memcmp = (filters: readonly { offset: number; bytes: ReadonlyUint8Array }[]) =>`,
+                `  filters.map((f) => ({ memcmp: { offset: BigInt(f.offset), bytes: getBase58Decoder().decode(f.bytes) as Base58EncodedBytes, encoding: "base58" as const } }));`,
+            ],
+        },
     ];
     if (needsFixedString)
         helperDefs.push({
@@ -1078,30 +1294,135 @@ export function generateClient(idl, opts = {}) {
         "",
         `// ---- Events ----`,
         `export type Event = ${events.length ? events.map((e) => `{ name: ${JSON.stringify(e.name)}; data: ${tsName(e.name)} }`).join(" | ") : "never"};`,
+        `/** One event's bytes (discriminator, then the fields), or null when they are not one of this program's events. */`,
+        `function decodeEvent(data: ReadonlyUint8Array): Event | null {`,
+        events.length
+            ? [
+                `  try {`,
+                ...events.map((e) => `    if (hasPrefix(data, ${bytes(e.discriminator)})) return { name: ${JSON.stringify(e.name)}, data: get${tsName(e.name)}Codec().decode(data, ${e.discriminator.length}) };`),
+                `  } catch {`,
+                `    // not one of this program's events`,
+                `  }`,
+                `  return null;`,
+            ].join("\n")
+            : `  void data;\n  return null;`,
+        `}`,
         `/**`,
         ` * Events in a transaction's log messages (\`Program data:\` lines, as \`emit\` writes them). Lines are matched by`,
         ` * discriminator, whichever program wrote them; lines that do not decode are skipped. \`emitCpi\` events travel in inner`,
-        ` * instructions, not logs.`,
+        ` * instructions: see parseCpiEvents and eventsOf.`,
         ` */`,
         `export function parseEvents(logs: readonly string[]): Event[] {`,
-        events.length
-            ? [
-                `  const found: Event[] = [];`,
-                `  for (const line of logs) {`,
-                `    if (!line.startsWith("Program data: ")) continue;`,
-                `    try {`,
-                `      const data = getBase64Encoder().encode(line.slice("Program data: ".length));`,
-                ...events.map((e) => `      if (hasPrefix(data, ${bytes(e.discriminator)})) found.push({ name: ${JSON.stringify(e.name)}, data: get${tsName(e.name)}Codec().decode(data, ${e.discriminator.length}) });`),
-                `    } catch {`,
-                `      // not one of this program's events`,
-                `    }`,
-                `  }`,
-                `  return found;`,
-            ].join("\n")
-            : `  void logs;\n  return [];`,
+        `  const found: Event[] = [];`,
+        `  for (const line of logs) {`,
+        `    if (!line.startsWith("Program data: ")) continue;`,
+        `    let data: ReadonlyUint8Array;`,
+        `    try {`,
+        `      data = getBase64Encoder().encode(line.slice("Program data: ".length));`,
+        `    } catch {`,
+        `      continue;`,
+        `    }`,
+        `    const e = decodeEvent(data);`,
+        `    if (e) found.push(e);`,
+        `  }`,
+        `  return found;`,
+        `}`,
+        `/** \`emitCpi\` events: the data of inner instructions (bytes, or base58 as RPC returns them) that carry one. */`,
+        `export function parseCpiEvents(instructionData: Iterable<ReadonlyUint8Array | string>): Event[] {`,
+        `  const tag = new Uint8Array([228, 69, 165, 46, 81, 203, 154, 29]);`,
+        `  const found: Event[] = [];`,
+        `  for (const item of instructionData) {`,
+        `    let data: ReadonlyUint8Array;`,
+        `    try {`,
+        `      data = typeof item === "string" ? getBase58Encoder().encode(item) : item;`,
+        `    } catch {`,
+        `      continue;`,
+        `    }`,
+        `    if (!hasPrefix(data, tag)) continue;`,
+        `    const e = decodeEvent(data.slice(tag.length));`,
+        `    if (e) found.push(e);`,
+        `  }`,
+        `  return found;`,
+        `}`,
+        `/** Every event of a fetched transaction (getTransaction, json encoding): its logs, then its inner instructions. */`,
+        `export function eventsOf(tx: { meta: { logMessages?: readonly string[] | null; innerInstructions?: readonly { instructions: readonly { data: string }[] }[] | null } | null } | null): Event[] {`,
+        `  const meta = tx?.meta;`,
+        `  if (!meta) return [];`,
+        `  return [...parseEvents(meta.logMessages ?? []), ...parseCpiEvents((meta.innerInstructions ?? []).flatMap((g) => g.instructions.map((i) => i.data)))];`,
+        `}`,
+        `/**`,
+        ` * Events of every transaction that mentions the program, as their logs arrive, until \`abortSignal\` aborts. With`,
+        ` * \`rpc\`, \`emitCpi\` events too: a transaction in which the program invoked itself is fetched (getTransaction) and its`,
+        ` * inner instructions read, after its log events.`,
+        ` */`,
+        `export async function* watchEvents(`,
+        `  rpcSubscriptions: RpcSubscriptions<LogsNotificationsApi>,`,
+        `  options: { abortSignal: AbortSignal; commitment?: Commitment; rpc?: Rpc<GetTransactionApi> },`,
+        `): AsyncGenerator<{ signature: Signature; event: Event }> {`,
+        `  const logs = await rpcSubscriptions.logsNotifications({ mentions: [PROGRAM_ADDRESS] }, options.commitment ? { commitment: options.commitment } : {}).subscribe({ abortSignal: options.abortSignal });`,
+        `  const selfInvoke = new RegExp("^Program " + PROGRAM_ADDRESS + " invoke \\\\[([2-9]|\\\\d{2,})\\\\]$");`,
+        `  for await (const n of logs) {`,
+        `    for (const event of parseEvents(n.value.logs)) yield { signature: n.value.signature, event };`,
+        `    if (!options.rpc || !n.value.logs.some((l) => selfInvoke.test(l))) continue;`,
+        `    // The transaction can trail its logs by a moment: a few tries.`,
+        `    for (let attempt = 0; attempt < 5 && !options.abortSignal.aborted; attempt++) {`,
+        `      const tx = await options.rpc`,
+        `        .getTransaction(n.value.signature, { encoding: "json", maxSupportedTransactionVersion: 0, commitment: options.commitment === "finalized" ? "finalized" : "confirmed" })`,
+        `        .send();`,
+        `      if (tx) {`,
+        `        for (const event of parseCpiEvents((tx.meta?.innerInstructions ?? []).flatMap((g) => g.instructions.map((i) => i.data)))) yield { signature: n.value.signature, event };`,
+        `        break;`,
+        `      }`,
+        `      await new Promise((resolve) => setTimeout(resolve, 400));`,
+        `    }`,
+        `  }`,
+        `}`,
+        "",
+        `// ---- Transactions ----`,
+        `/** Send instructions in one transaction paid by \`feePayer\` (signers in the accounts sign too) and wait for confirmation. */`,
+        `export async function sendInstructions(`,
+        `  connection: { rpc: Rpc<GetEpochInfoApi & GetLatestBlockhashApi & GetSignatureStatusesApi & SendTransactionApi>; rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi> },`,
+        `  feePayer: TransactionSigner,`,
+        `  instructions: readonly Instruction[],`,
+        `  options: { commitment?: Commitment; abortSignal?: AbortSignal } = {},`,
+        `): Promise<Signature> {`,
+        `  const { value: latestBlockhash } = await connection.rpc.getLatestBlockhash().send();`,
+        `  const message = pipe(`,
+        `    createTransactionMessage({ version: 0 }),`,
+        `    (m) => setTransactionMessageFeePayerSigner(feePayer, m),`,
+        `    (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),`,
+        `    (m) => appendTransactionMessageInstructions(instructions, m),`,
+        `  );`,
+        `  const signed = await signTransactionMessageWithSigners(message);`,
+        `  assertIsTransactionWithBlockhashLifetime(signed);`,
+        `  await sendAndConfirmTransactionFactory(connection)(signed, { commitment: options.commitment ?? "confirmed", ...(options.abortSignal ? { abortSignal: options.abortSignal } : {}) });`,
+        `  return getSignatureFromTransaction(signed);`,
+        `}`,
+        `/** Simulate instructions (nothing is sent, signatures are not checked): the error if any, logs, units and the program's return data. */`,
+        `export async function simulate(`,
+        `  rpc: Rpc<SimulateTransactionApi & GetLatestBlockhashApi>,`,
+        `  feePayer: Address | TransactionSigner,`,
+        `  instructions: readonly Instruction[],`,
+        `): Promise<{ err: unknown; logs: readonly string[]; unitsConsumed: bigint | null; returnData: ReadonlyUint8Array | null }> {`,
+        `  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();`,
+        `  const message = pipe(`,
+        `    createTransactionMessage({ version: 0 }),`,
+        `    (m) => setTransactionMessageFeePayer(key(feePayer), m),`,
+        `    (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),`,
+        `    (m) => appendTransactionMessageInstructions(instructions, m),`,
+        `  );`,
+        `  const wire = getBase64EncodedWireTransaction(compileTransaction(message));`,
+        `  const { value } = await rpc.simulateTransaction(wire, { encoding: "base64", sigVerify: false, replaceRecentBlockhash: true }).send();`,
+        `  const ret = value.returnData;`,
+        `  return {`,
+        `    err: value.err,`,
+        `    logs: value.logs ?? [],`,
+        `    unitsConsumed: value.unitsConsumed ?? null,`,
+        `    returnData: ret && ret.programId === PROGRAM_ADDRESS ? getBase64Encoder().encode(ret.data[0]) : null,`,
+        `  };`,
         `}`,
         "",
-        `/** The ${displayName} program: instructions, accounts, PDAs, errors, events and return values. */`,
+        `/** The ${displayName} program: instructions, accounts, PDAs, errors, events, return values and transactions. */`,
         `export const ${programName} = {`,
         `  address: PROGRAM_ADDRESS,`,
         ...ixKeys.map((k) => `  ${k},`),
@@ -1112,10 +1433,21 @@ export function generateClient(idl, opts = {}) {
         `  returns: {`,
         ...returnKeys,
         `  },`,
+        `  views: {`,
+        ...viewKeys,
+        `  },`,
+        `  resolve: {`,
+        ...resolveKeys,
+        `  },`,
         `  errors: ERRORS,`,
         `  errorCode,`,
         `  isError,`,
         `  parseEvents,`,
+        `  parseCpiEvents,`,
+        `  eventsOf,`,
+        `  watchEvents,`,
+        `  sendInstructions,`,
+        `  simulate,`,
         `};`,
         "",
     ];

package/dist/idlpublish.d.ts

@@ -27,3 +27,15 @@ export declare function publishIdl(chain: Chain, opts: PublishOptions): Promise<
 export declare function metadataAddress(program: Address, authority: Address | null): Promise<Address>;
 /** Read an IDL back (canonical, or the one `authority` wrote). */
 export declare function fetchIdl(rpc: Chain["rpc"], program: Address, authority?: Address | null): Promise<object>;
+/** Where `anchor idl init` keeps a program's IDL: an account derived with seed "anchor:idl" from the program's base PDA. */
+export declare function anchorIdlAddress(program: Address): Promise<Address>;
+/** The IDL in Anchor's IDL account (`anchor idl init`), or null when the program has none. */
+export declare function fetchAnchorIdl(rpc: Chain["rpc"], program: Address): Promise<object | null>;
+/**
+ * A program's IDL from the chain: the canonical Program Metadata IDL (`typesol idl publish`, Codama) first, else
+ * Anchor's IDL account (`anchor idl init`).
+ */
+export declare function fetchProgramIdl(rpc: Chain["rpc"], program: Address): Promise<{
+    idl: object;
+    source: "program-metadata" | "anchor";
+}>;

package/dist/idlpublish.js

@@ -5,8 +5,9 @@
  *
  * Works against an RPC (`rpcChain`) or anything else that can read accounts and send transactions (tests use LiteSVM).
  */
+import { inflateSync } from "node:zlib";
 import { Compression, Encoding, Format, fetchMetadataContent, findMetadataPda, packDirectData, writeMetadata } from "@solana-program/program-metadata";
-import { createClient, createTransactionMessage, createTransactionPlanExecutor, createTransactionPlanner, extendClient, getAddressEncoder, getBase64EncodedWireTransaction, getProgramDerivedAddress, getSignatureFromTransaction, lamports, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from "@solana/kit";
+import { createAddressWithSeed, createClient, createTransactionMessage, createTransactionPlanExecutor, createTransactionPlanner, extendClient, getAddressEncoder, getBase64EncodedWireTransaction, getProgramDerivedAddress, getSignatureFromTransaction, lamports, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from "@solana/kit";
 export const PROGRAM_METADATA_ID = "ProgM6JCCvbYkfKqJYHePx4xxSUSqJp7rh8Lyv7nk7S";
 /** A Chain over an RPC endpoint (polls signature status: no websocket needed). */
 export function rpcChain(rpc) {
@@ -114,3 +115,39 @@ export async function metadataAddress(program, authority) {
 export async function fetchIdl(rpc, program, authority = null) {
     return JSON.parse(await fetchMetadataContent(rpc, program, "idl", authority));
 }
+/** Where `anchor idl init` keeps a program's IDL: an account derived with seed "anchor:idl" from the program's base PDA. */
+export async function anchorIdlAddress(program) {
+    const [base] = await getProgramDerivedAddress({ programAddress: program, seeds: [] });
+    return createAddressWithSeed({ baseAddress: base, programAddress: program, seed: "anchor:idl" });
+}
+/** The IDL in Anchor's IDL account (`anchor idl init`), or null when the program has none. */
+export async function fetchAnchorIdl(rpc, program) {
+    const { value } = await rpc.getAccountInfo(await anchorIdlAddress(program), { encoding: "base64" }).send();
+    if (!value)
+        return null;
+    const data = Buffer.from(value.data[0], "base64");
+    // IdlAccount: 8-byte discriminator, authority (32 bytes), a u32 length, then the zlib-compressed JSON.
+    if (data.length < 44)
+        throw new Error("Anchor IDL account is too short");
+    const len = data.readUInt32LE(40);
+    if (44 + len > data.length)
+        throw new Error("Anchor IDL account is truncated");
+    return JSON.parse(inflateSync(data.subarray(44, 44 + len)).toString("utf8"));
+}
+/**
+ * A program's IDL from the chain: the canonical Program Metadata IDL (`typesol idl publish`, Codama) first, else
+ * Anchor's IDL account (`anchor idl init`).
+ */
+export async function fetchProgramIdl(rpc, program) {
+    let metadataError;
+    try {
+        return { idl: await fetchIdl(rpc, program), source: "program-metadata" };
+    }
+    catch (e) {
+        metadataError = e;
+    }
+    const anchor = await fetchAnchorIdl(rpc, program);
+    if (anchor)
+        return { idl: anchor, source: "anchor" };
+    throw new Error(`no IDL on chain for ${program}: none in the Program Metadata program (${metadataError instanceof Error ? metadataError.message : String(metadataError)}) and no Anchor IDL account at ${await anchorIdlAddress(program)}`);
+}

package/docs/cli.md

@@ -15,7 +15,7 @@ error. Exit codes: **0** success, **1** failure (compile errors, failed deploy,
 | `typesol idl publish [<program>…] [--url <rpc>] [--keypair <authority.json>] [--config <cli config>] [--non-canonical]` | Compile (the binary is not rebuilt), then write each IDL to the Program Metadata program (seed `idl`). Canonical IDLs must be signed by the upgrade authority. Defaults come from the Solana CLI config (`~/.config/solana/cli/config.yml`). |
 | `typesol cpi <idl.json> [--out <file.ts>] [--prefix <name>] [--address <base58>]` | Generate TypeSOL helpers that call another program from its IDL. Unsupported instructions are listed on stderr. |
 | `typesol port <idl.json> [--out <file.ts>]` | A TypeSOL program skeleton from an Anchor IDL (0.30+/1.x), to port an Anchor program: account structs, enums, errors and one function per instruction with its accounts and arguments, each body `require(false, …NotPorted)` until written. Instruction discriminators (an explicit `@discriminator` when the name derives another), account names and error codes are kept, so existing clients keep working where the layouts match; notes on stderr list where they do not (Borsh `String`/`Option` in account data, a `Vec` that is not the last field, custom discriminators or error codes). |
-| `typesol client <idl.json> [--out <file.ts>] [--address <base58>]` | Generate a typed TypeScript client on `@solana/kit` from an Anchor IDL (0.30+/1.x or TypeSOL); the IDL is validated first, and what the client leaves out is printed as notes. See [client.md](client.md). |
+| `typesol client <idl.json> [--out <file.ts>] [--address <base58>]`, `typesol client --address <program id> [--url <rpc>] [--config <cli config>] [--out <file.ts>]` | Generate a typed TypeScript client on `@solana/kit` from an Anchor IDL (0.30+/1.x or TypeSOL); the IDL is validated first, and what the client leaves out is printed as notes. Without a file, the IDL is read from the chain: the canonical Program Metadata IDL, else Anchor's IDL account. See [client.md](client.md). |
 | `typesol verify <program\|file.ts> [<deployed.so>] [--address <program id>] [--url <rpc>] [--config <cli config>] [--sbpf …]` | Rebuild and compare with what is deployed. Without a `.so`, reads the program from the cluster (`--url`, cluster monikers such as `mainnet-beta` included, else the Solana CLI config) at `--address` or the address `typesol.json` records, under any loader (v2, upgradeable v3, v4); prints the upgrade authority (or that the program is immutable) and the last deploy slot, and compares the IDL published with `typesol idl publish` (a published IDL that differs is a mismatch). With a `.so` (e.g. `solana program dump`), compares with that file. Trailing zero padding is ignored; the SBPF version is read from the deployed ELF unless `--sbpf` is given. |
 | `typesol profile <logs.txt\|-> [--program <id>]` | Compute units per TypeScript line from the logs of a `--profile` build's transaction (exit 1 when the logs have no markers). |
 | `typesol help <command>` | Same as `typesol <command> --help`. |

package/docs/client.md

@@ -3,7 +3,10 @@
 Every `typesol build` writes a typed client next to the program: `<out>/<name>/<name>.client.ts`. It is one file, it
 depends only on [`@solana/kit`](https://github.com/anza-xyz/kit) (8.5 or later), and it is rewritten on every build, so
 it always matches the program. `typesol client <idl.json>` writes the same kind of client from an Anchor IDL (Anchor 0.30+
-and 1.x), so one client style covers TypeSOL programs and the Anchor programs they talk to.
+and 1.x), so one client style covers TypeSOL programs and the Anchor programs they talk to. `typesol client --address
+<program id> --url <rpc>` reads the IDL from the chain instead: the canonical Program Metadata IDL (`typesol idl
+publish`, Codama), else Anchor's IDL account (`anchor idl init`), so any deployed Anchor or TypeSOL program with a
+published IDL gets a client from its address alone.
 
 ```ts
 import { ledgerbook } from "./target/ledgerbook/ledgerbook.client.js";
@@ -25,23 +28,49 @@ ledgerbook.errorCode(e); // 6002
 // Events written by `emit`, from a transaction's log messages
 for (const ev of ledgerbook.parseEvents(logs)) if (ev.name === "Filed") ev.data.amount;
 
-// Return data of an instruction that returns a value
+// Return data of an instruction that returns a value, or the value itself by simulation (Anchor's `.view()`)
 ledgerbook.returns.total(returnDataBytes); // bigint
+await ledgerbook.views.total(rpc, signer, { book }, { status: Status.Approved }); // bigint, nothing sent
+
+// Send and confirm (one transaction, signers in the accounts sign too), or simulate
+const signature = await ledgerbook.sendInstructions({ rpc, rpcSubscriptions }, signer, [create, file]);
+const { err, logs, unitsConsumed, returnData } = await ledgerbook.simulate(rpc, signer, [file]);
+
+// Every Book of the program, or those with given bytes at an offset (after the 8-byte discriminator)
+const books = await ledgerbook.accounts.Book.fetchAll(rpc); // [{ address, data }]
+const several = await ledgerbook.accounts.Book.fetchMultiple(rpc, [a, b]); // (Book | null)[]
+
+// Live updates, until the AbortSignal aborts
+for await (const book of ledgerbook.accounts.Book.watch(rpcSubscriptions, address, { abortSignal })) render(book);
+for await (const { signature, event } of ledgerbook.watchEvents(rpcSubscriptions, { abortSignal, rpc })) show(event); // with rpc: emitCpi events too
+
+// Remaining accounts go after the instruction's own (Anchor's `.remainingAccounts([...])`)
+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
+
+// Events of a fetched transaction (getTransaction, json): log events and emitCpi events from inner instructions
+ledgerbook.eventsOf(await rpc.getTransaction(signature, { maxSupportedTransactionVersion: 0 }).send());
 ```
 
-Send instructions the usual kit way (`createTransactionMessage` … `signTransactionMessageWithSigners`). Signer
-accounts take a `TransactionSigner`, which kit uses to sign; an `Address` works too when you sign separately.
+Signer accounts take a `TransactionSigner`, which kit uses to sign; an `Address` works too when you sign separately.
+Kit's own transaction functions work with the instructions as well; `sendInstructions` is that pipeline in one call.
 
 ## What the client contains
 
 | | |
 | --- | --- |
 | `<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>.accounts.<Name>` | `decode(bytes)`, `encode(value)`, `fetch(rpc, address)`, `fetchMaybe(rpc, address)`, `discriminator`. `decode` checks the discriminator. |
+| `<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>.returns.<instruction>(bytes)` | Decodes return data. |
-| `<program>.errors`, `errorCode(e)`, `isError(e, name)` | The program's errors (6000+), and for TypeSOL programs also TypeSOL's runtime errors and the Anchor framework errors it uses (2001, 2006, 3007, …). |
-| `<program>.parseEvents(logs)` | Events from `Program data:` log lines. |
+| `<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>.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. |
+| `<program>.parseEvents(logs)`, `parseCpiEvents(data)`, `eventsOf(tx)`, `watchEvents(rpcSubscriptions, { abortSignal })` | Events from `Program data:` log lines, from `emitCpi` inner instructions (bytes or base58), from a fetched transaction (both), or live from log subscriptions. |
 | Types and codecs | Every defined type as a TypeScript type (`Book`, the decoded value) and an input type (`BookArgs`, which also accepts `number` for 64- and 128-bit integers), with a kit codec (`getBookCodec()`). |
 
 Types follow the program's TypeScript: `u64`/`i64`/`u128`/`i128` are `bigint` (inputs accept `number` too), smaller
@@ -60,10 +89,12 @@ 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): accounts named by `has_one` relations, PDAs seeded from fields inside
-  another account or inside an argument, and PDAs whose program comes from an argument. `typesol client` prints a note
-  for each.
+- **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**: events sent with `emitCpi` (they travel in inner instructions, not logs), and a LiteSVM loader for
-  tests (use `svm.addProgramFromFile(ledgerbook.address, soPath)`).
+- **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).

package/package.json

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