@typesol/cli 0.24.0 → 0.24.1

package/CHANGELOG.md

@@ -1,10 +1,24 @@
 # Changelog
 
-TypeSOL follows [semantic versioning](https://semver.org/) with the 0.x rules described in CONTRIBUTING.md:
-until 1.0, a minor version may change the language, the IDL layout or error codes, and says so here.
+TypeSOL follows the organization's [versioning policy](https://github.com/typesol/.github/blob/main/VERSIONING.md)
+(compiler specifics in CONTRIBUTING.md): until 1.0, a minor version may change the language, the IDL layout or error
+codes, and says so here.
 
 ## Unreleased
 
+## 0.24.1 — 2026-10-28
+
+Smaller programs and fewer compute units, with the same results; no change to the language, IDLs or error codes. Also
+new contributor docs (repository layout, a guide to the C runtime). Not externally audited (see SECURITY.md).
+
+### Performance
+- Smaller programs, same results: the rent calculation no longer links soft-float (an exact integer equivalent,
+  checked against IEEE doubles), and every failure logs through one shared call. The benchmarked programs are 11.6%
+  smaller in total (counter 13.1 → 11.0 KB, escrow 23.9 → 21.3 KB). A failing instruction costs 2 more compute units;
+  successful ones are unchanged.
+- An identical signer-seed list in the same scope reuses the array declared for the first CPI (escrow `take_offer`
+  7058 → 7044, `refund_offer` 4287 → 4271).
+
 ## 0.24.0 — 2026-10-28
 
 Functions as values, closures for any helper, stored `map` to structs and text, Metaplex Core external plugins, and

package/README.md

@@ -232,7 +232,9 @@ Subpath exports: `typesol/compiler`, `typesol/workspace`, `typesol/cpi`, `typeso
 
 The same counter, vault and escrow programs, written four ways. All four use the same instruction encoding, account
 layout and checks. They get identical transactions in LiteSVM and must end in identical account state. The table
-shows mean compute units per call (generated by `scripts/readme-bench.ts` from the benchmark run):
+shows mean compute units per call (generated by `scripts/readme-bench.ts` from the benchmark run). The programs,
+scenarios and harness are in [typesol/benchmarks](https://github.com/typesol/benchmarks), which pins the compiler and
+toolchain and records them with every result:
 
 <!-- bench:table -->
 | Instruction | TypeSOL | Pinocchio 0.10 | Native Rust | Anchor 1.0.2 |
@@ -244,9 +246,9 @@ shows mean compute units per call (generated by `scripts/readme-bench.ts` from t
 | vault.withdraw | **315** | 370 | 1,176 | 3,628 |
 | vault.shut | **161** | 167 | 950 | 2,024 |
 | escrow.make | **3,605** | 6,179 | 9,240 | 13,304 |
-| escrow.take | **4,035** | 4,051 | 8,500 | 14,365 |
-| escrow.refund | **2,716** | 2,769 | 5,695 | 8,449 |
-| binary, counter / vault / escrow | 13.1 / 16.5 / 23.9 KB | 19.6 / 22.9 / 29.4 KB | 27.9 / 35.0 / 46.5 KB | 145.2 / 158.9 / 190.7 KB |
+| escrow.take | **4,019** | 4,051 | 8,500 | 14,365 |
+| escrow.refund | **2,696** | 2,769 | 5,695 | 8,449 |
+| binary, counter / vault / escrow | 11.0 / 14.1 / 21.3 KB | 19.6 / 22.9 / 29.4 KB | 27.9 / 35.0 / 46.5 KB | 145.2 / 158.9 / 190.7 KB |
 <!-- /bench:table -->
 
 `initialize`, `open` and `make` include the PDA bump search. TypeSOL hashes PDA candidates with the sha256 and
@@ -307,7 +309,7 @@ Details are in [docs/testing.md](docs/testing.md).
 
 ## Status
 
-**TypeSOL is pre-1.0 (0.24).** Releases follow the organization's
+**TypeSOL is pre-1.0.** 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

@@ -1102,7 +1102,10 @@ function generate(idl, opts) {
         // A seed or program path names an account: in the same group first, then at the top level.
         const byPath = (p, group) => flat.find((f) => `${f.group}${f.name}` === `${group}${p}`) ?? flat.find((f) => f.group === "" && f.name === p);
         const argType = new Map(ix.args.map((a) => [a.name, a.type]));
-        const seedExpr = (s, group) => {
+        const seedsProp = (k) => `seeds${NAME.test(k) && !JS_RESERVED.has(k) ? `.${k}` : `[${JSON.stringify(k)}]`}`;
+        const BUILDER = { arg: (n) => `args.${n}`, account: (k) => `$${k}` };
+        const HELPER = { arg: (n) => seedsProp(n), account: (k) => seedsProp(k) };
+        const seedExpr = (s, group, refs = BUILDER) => {
             if (s.kind === "const")
                 return bytes(s.value);
             if (s.kind === "arg") {
@@ -1111,7 +1114,7 @@ function generate(idl, opts) {
                 let t = argType.get(head);
                 if (t === undefined)
                     return { why: `the seed argument ${head} does not exist` };
-                let v = `args.${camel(head)}`;
+                let v = refs.arg(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;
@@ -1134,25 +1137,30 @@ function generate(idl, opts) {
             if (!target)
                 return { why: `the seed account ${s.path} is not an account of the instruction` };
             use("getAddressEncoder");
-            return `getAddressEncoder().encode(key($${target.key}))`;
+            return `getAddressEncoder().encode(key(${refs.account(target.key)}))`;
         };
-        const resolvable = new Map();
-        for (const a of flat) {
-            if (!a.pda || a.address)
-                continue;
-            const seeds = a.pda.seeds.map((s) => seedExpr(s, a.group));
-            let program;
+        /** A PDA's program as the code being written names it (undefined: this program). */
+        const pdaProgram = (a, refs) => {
             const p = a.pda.program;
             if (p?.kind === "const")
-                program = (use("getAddressDecoder"), `programFromBytes(${bytes(p.value)})`);
-            else if (p?.kind === "account") {
+                return (use("getAddressDecoder"), `programFromBytes(${bytes(p.value)})`);
+            if (p?.kind === "account") {
                 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` };
+                return target ? `key(${refs.account(target.key)})` : { why: `the PDA program ${p.path} is not an account of the instruction` };
             }
-            else if (p?.kind === "arg") {
+            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" };
+                return t === "pubkey" || t === "publicKey" ? refs.arg(camel(p.path)) : { why: "the PDA program comes from an argument that is not a Pubkey" };
             }
+            return undefined;
+        };
+        const resolvable = new Map();
+        for (const a of flat) {
+            if (!a.pda || a.address)
+                continue;
+            const seeds = a.pda.seeds.map((s) => seedExpr(s, a.group));
+            const program = pdaProgram(a, BUILDER);
+            const p = a.pda.program;
             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`);
@@ -1228,11 +1236,13 @@ function generate(idl, opts) {
                     return [k, `${k}: Address | TransactionSigner`];
                 })).values(),
             ];
-            const rewrite = (e) => e.replace(/\bargs\.([A-Za-z0-9_$]+)/g, "seeds.$1").replace(/key\(\$([A-Za-z0-9_]+)\)/g, "key(seeds.$1)");
+            // The same derivation, its inputs named as the helper's `seeds` parameter.
+            const helperSeeds = a.pda.seeds.map((s) => seedExpr(s, a.group, HELPER));
+            const helperProgram = pdaProgram(a, HELPER) ?? "PROGRAM_ADDRESS";
             use("type ProgramDerivedAddress");
             pdaFns.set(pn, {
                 json,
-                source: `    /** The ${a.name} PDA (as ${ix.name} derives it). */\n    ${prop(pn)}(seeds: { ${params.join("; ")} }): Promise<ProgramDerivedAddress> {\n      return getProgramDerivedAddress({ programAddress: ${rewrite(r.program ?? "PROGRAM_ADDRESS")}, seeds: [${r.seeds.map(rewrite).join(", ")}] });\n    },`,
+                source: `    /** The ${a.name} PDA (as ${ix.name} derives it). */\n    ${prop(pn)}(seeds: { ${params.join("; ")} }): Promise<ProgramDerivedAddress> {\n      return getProgramDerivedAddress({ programAddress: ${helperProgram}, seeds: [${helperSeeds.join(", ")}] });\n    },`,
             });
         }
         const metas = flat.map((a) => {
@@ -1326,6 +1336,7 @@ function generate(idl, opts) {
             }
             const bases = new Map();
             const seeds = [];
+            const helperSeeds = []; // the same seeds, named as a `pdas` helper's `seeds` (for one seeded from its own fields)
             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();
@@ -1334,13 +1345,14 @@ function generate(idl, opts) {
             let usesArgs = p?.kind === "arg";
             for (const sd of a.pda.seeds) {
                 if (sd.kind === "const")
-                    seeds.push(bytes(sd.value));
+                    (seeds.push(bytes(sd.value)), helperSeeds.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);
+                        helperSeeds.push(seedExpr(sd, a.group, HELPER));
                         usesArgs = true;
                         const head = sd.path.split(".")[0];
                         params.set(camel(head), `${camel(head)}: ${tsType(argType.get(head), "in")}`);
@@ -1353,6 +1365,7 @@ function generate(idl, opts) {
                     else {
                         use("getAddressEncoder");
                         seeds.push(`getAddressEncoder().encode(key(${acc(t)}!))`);
+                        helperSeeds.push(`getAddressEncoder().encode(key(${seedsProp(t.key)}))`);
                         params.set(t.key, `${t.key}: Address | TransactionSigner`);
                         if (auto(t))
                             autoDep = true;
@@ -1370,6 +1383,7 @@ function generate(idl, opts) {
                         own.push({ field: parts[1], type: field.type });
                         params.set(camel(parts[1]), `${camel(parts[1])}: ${tsType(field.type, "in")}`);
                         seeds.push(enc);
+                        helperSeeds.push(enc);
                     }
                     else if (!consts || auto(base))
                         ok = false;
@@ -1399,13 +1413,11 @@ function generate(idl, opts) {
                     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\(ownProp\(acc, "([^"]+)"\)!\)/g, (_, k) => `key(seeds${NAME.test(k) && !JS_RESERVED.has(k) ? `.${k}` : `[${JSON.stringify(k)}]`})`);
+                const helperProgram = p?.kind === "arg" ? seedsProp(camel(p.path)) : program;
                 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    },`,
+                    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: ${helperProgram}, seeds: [${helperSeeds.join(", ")}] });\n    },`,
                 });
                 continue;
             }

package/dist/compiler/analyze.js

@@ -680,7 +680,7 @@ export function analyze(entry) {
             dataEnums,
             options,
             constants,
-            events: new Set(),
+            events: collectEvents([...functions, ...helperNodes], structs),
             accountStructs,
             argStructs,
             fstrings,
@@ -1164,6 +1164,26 @@ function fnParamType(arrow, checker) {
     }
     return undefined;
 }
+/**
+ * The structs a program emits (`emit<T>(…)` / `emitCpi<T>(…)` anywhere in its functions and helpers), known before
+ * any code is emitted, so the IDL and the event checks do not depend on the order code is emitted in.
+ */
+function collectEvents(sources, structs) {
+    const events = new Set();
+    for (const { node, imports } of sources) {
+        const visit = (n) => {
+            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression)) {
+                const name = imports.get(n.expression.text);
+                const t = n.typeArguments?.[0];
+                if ((name === "emit" || name === "emitCpi") && t && ts.isTypeReferenceNode(t) && ts.isIdentifier(t.typeName) && structs.has(t.typeName.text))
+                    events.add(t.typeName.text);
+            }
+            ts.forEachChild(n, visit);
+        };
+        visit(node);
+    }
+    return events;
+}
 /** Whether a function returns a function: typed so, or its body is (or only returns) an arrow. */
 function returnsFunction(fn) {
     if (fn.type)

package/dist/compiler/emit/base.d.ts

@@ -24,6 +24,16 @@ export declare abstract class EmitterBase {
     protected readonly pendingInit: Set<string>;
     /** Bump temporaries from create()/createIfNeeded(), for `acct.pdaBump`. */
     protected readonly bumps: Map<string, string>;
+    /**
+     * Seed arrays already declared (no spare slot, every seed read in place): the C entries, and where the array is.
+     * An identical list in the same or an inner block reuses it (see seeds()).
+     */
+    protected readonly seedArrays: Map<string, {
+        name: string;
+        scope: Map<string, Local>;
+        at: number;
+        text: string;
+    }>;
     /** Closures being expanded, innermost last: a `return` inside one assigns `result` and jumps to `label`. */
     protected inlineFrames: {
         label: string;

package/dist/compiler/emit/base.js

@@ -23,6 +23,11 @@ export class EmitterBase {
     pendingInit = new Set();
     /** Bump temporaries from create()/createIfNeeded(), for `acct.pdaBump`. */
     bumps = new Map();
+    /**
+     * Seed arrays already declared (no spare slot, every seed read in place): the C entries, and where the array is.
+     * An identical list in the same or an inner block reuses it (see seeds()).
+     */
+    seedArrays = new Map();
     /** Closures being expanded, innermost last: a `return` inside one assigns `result` and jumps to `label`. */
     inlineFrames = [];
     /** Closures being expanded (a closure calling itself cannot be expanded). */
@@ -300,6 +305,7 @@ export class EmitterBase {
             created: new Set(this.created),
             pendingInit: new Set(this.pendingInit),
             bumps: new Map(this.bumps),
+            seedArrays: new Map(this.seedArrays),
         };
         try {
             return this.reporter.guard(fn);
@@ -322,6 +328,8 @@ export class EmitterBase {
             }
             this.bumps.clear();
             saved.bumps.forEach((v, k) => this.bumps.set(k, v));
+            this.seedArrays.clear();
+            saved.seedArrays.forEach((v, k) => this.seedArrays.set(k, v));
         }
     }
     fail(node, message) {

package/dist/compiler/emit/cpi.d.ts

@@ -103,8 +103,17 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected corePlugin(n: ts.Expression, withAuthority: boolean): MplField[];
     /** CreateV1 / CreateCollectionV1 plugins: Option<Vec<PluginAuthorityPair>>. */
     protected corePluginList(n: ts.Expression | undefined): MplField[];
-    /** Metaplex Core: assets and collections (with plugins), plugins added, updated and removed, transfer and burn. */
+    /**
+     * Metaplex Core: assets and collections (with plugins), plugins and external plugin adapters added, updated, written
+     * and removed, transfer and burn. Each method is a row of CORE_OPS below: its accounts in order, its data.
+     */
     protected coreOp(node: ts.CallExpression, core: AccountParam, method: string): undefined;
+    /**
+     * Core instructions: `args` fixed arguments (then an optional plugin list when `plugins`, then optional signer
+     * seeds), accounts in order (`[argument, label, writable, signer]`, or "self": the Core program, Core's "none" for an
+     * optional account), at most `max` bytes of data.
+     */
+    private coreOps;
     /** The fields of a Core object literal (`{ kind: "AppData", … }`) by name. */
     private coreProps;
     /** PluginAuthority: "none" | "owner" | "updateAuthority" (literals), or an address. */

package/dist/compiler/emit/cpi.js

@@ -207,6 +207,7 @@ export class CpiEmitter extends CallEmitter {
             ts.isPostfixUnaryExpression(n) ||
             ts.forEachChild(n, mutates) === true;
         const inPlace = !node.elements.some(mutates);
+        const mark = this.lines.length;
         for (const el of node.elements) {
             const desc = this.describeSeed(el);
             if (!desc)
@@ -252,9 +253,19 @@ export class CpiEmitter extends CallEmitter {
             else
                 this.fail(el, "seeds can be strings, Pubkeys, integers or unit enum values");
         }
+        // The same list again (escrow: the vault transfer, then its close) reuses the array declared for the first, when
+        // nothing was copied into temporaries (every entry points at a literal or at the place itself, so the array reads
+        // what a new one would), it has no spare slot (callers never write into those arrays) and it is still in scope.
+        const key = parts.join(", ");
+        const reusable = extra === 0 && parts.length > 0 && this.lines.length === mark;
+        const known = reusable ? this.seedArrays.get(key) : undefined;
+        if (known && this.scopes.includes(known.scope) && this.lines[known.at]?.trim() === known.text)
+            return { name: known.name, count: parts.length, idl };
         const name = this.tmp("seeds");
         const slots = parts.length + extra;
         this.line(`SolSignerSeed ${name}[${Math.max(slots, 1)}] = {${parts.join(", ")}};`);
+        if (reusable)
+            this.seedArrays.set(key, { name, scope: this.scopes[this.scopes.length - 1], at: this.lines.length - 1, text: this.lines.at(-1).trim() });
         return { name, count: parts.length, idl };
     }
     describeSeed(el) {
@@ -1715,179 +1726,180 @@ export class CpiEmitter extends CallEmitter {
         });
         return [{ bytes: [1, els.length & 0xff, 0, 0, 0] }, ...els.flatMap((e) => this.corePlugin(e, true))];
     }
-    /** Metaplex Core: assets and collections (with plugins), plugins added, updated and removed, transfer and burn. */
+    /**
+     * Metaplex Core: assets and collections (with plugins), plugins and external plugin adapters added, updated, written
+     * and removed, transfer and burn. Each method is a row of CORE_OPS below: its accounts in order, its data.
+     */
     coreOp(node, core, method) {
         const a = node.arguments;
         const p = `a_${core.name}`;
-        const seedsAt = (i) => (a[i] ? this.signingSeeds(a[i]) : { name: "NULL", count: 0 });
-        const str = (n) => ({ value: n, type: STRING });
-        // An array literal of object literals after the uri is the plugin list; the signer seeds come after it.
+        const op = this.coreOps()[method];
+        if (!op)
+            this.fail(node.expression, `Metaplex Core supports createAsset, createCollection, addPlugin, updatePlugin, removePlugin, addExternalPlugin, removeExternalPlugin, writeExternalPluginData (and the Collection forms), transferAsset and burnAsset, not ${method}`);
+        // An array literal of object literals right after the fixed arguments is the plugin list; the signer seeds follow.
         const isPlugins = (n) => !!n && ts.isArrayLiteralExpression(n) && (n.elements.length === 0 || n.elements.every((e) => ts.isObjectLiteralExpression(e)));
-        const self = [p, false, false];
-        switch (method) {
-            case "createAsset": {
-                // CreateV1: asset, collection, authority, payer, owner, updateAuthority, systemProgram, logWrapper.
-                const plugins = isPlugins(a[8]) ? a[8] : undefined;
-                if (a.length < 8 || a.length > (plugins ? 10 : 9))
-                    this.fail(node, "createAsset(asset, collection | null, authority | null, payer, owner | null, systemProgram, name, uri, plugins?, signerSeeds?)");
-                const metas = [
-                    this.mplMeta(a[0], core, "the asset", true, true),
-                    this.mplMeta(a[1], core, "the collection", true, false),
-                    this.mplMeta(a[2], core, "the collection authority", false, true),
-                    this.mplMeta(a[3], core, "the payer", true, true),
-                    this.mplMeta(a[4], core, "the owner", false, false),
-                    [p, false, false], // update authority: the collection's, or the payer by default
-                    this.mplMeta(a[5], core, "the system program", false, false),
-                    [p, false, false],
-                ];
-                const data = this.mplData(node, 2048, [{ bytes: [0, 0] }, str(a[6]), str(a[7]), ...this.corePluginList(plugins)]);
-                this.cpi(p, metas, data.buf, data.len, seedsAt(plugins ? 9 : 8));
-                return undefined;
-            }
-            case "createCollection": {
+        const list = op.plugins && isPlugins(a[op.args]) ? a[op.args] : undefined;
+        const seedsAt = op.args + (list ? 1 : 0);
+        if (op.plugins ? a.length < op.args || a.length > seedsAt + 1 : a.length !== op.args && a.length !== op.args + 1)
+            this.fail(node, op.usage(method));
+        const metas = op.metas.map((m) => (m === "self" ? [p, false, false] : this.mplMeta(a[m[0]], core, m[1], m[2], m[3])));
+        const data = this.mplData(node, op.max, op.data(a, list));
+        this.cpi(p, metas, data.buf, data.len, a[seedsAt] ? this.signingSeeds(a[seedsAt]) : { name: "NULL", count: 0 });
+        return undefined;
+    }
+    /**
+     * Core instructions: `args` fixed arguments (then an optional plugin list when `plugins`, then optional signer
+     * seeds), accounts in order (`[argument, label, writable, signer]`, or "self": the Core program, Core's "none" for an
+     * optional account), at most `max` bytes of data.
+     */
+    coreOps() {
+        const str = (n) => ({ value: n, type: STRING });
+        const asset = [0, "the asset", true, false];
+        const assetPlugin = {
+            usage: (m) => `${m}(asset, collection | null, payer, authority | null, systemProgram, ${m === "removePlugin" ? "kind" : "plugin"}, signerSeeds?)`,
+            args: 6,
+            // Add/Remove/UpdatePluginV1: asset, collection, payer, authority, systemProgram, logWrapper.
+            metas: [
+                asset,
+                [1, "the collection", true, false],
+                [2, "the payer", true, true],
+                [3, "the authority", false, true],
+                [4, "the system program", false, false],
+                "self",
+            ],
+            max: 2048,
+        };
+        const collectionPlugin = {
+            usage: (m) => `${m}(collection, payer, authority | null, systemProgram, ${m === "removeCollectionPlugin" ? "kind" : "plugin"}, signerSeeds?)`,
+            args: 5,
+            // Add/Remove/UpdateCollectionPluginV1: collection, payer, authority, systemProgram, logWrapper.
+            metas: [
+                [0, "the collection", true, false],
+                [1, "the payer", true, true],
+                [2, "the authority", false, true],
+                [3, "the system program", false, false],
+                "self",
+            ],
+            max: 2048,
+        };
+        const assetPluginOp = (method, disc) => ({
+            ...assetPlugin,
+            data: (a) => [
+                { bytes: [disc] },
+                ...(method === "removePlugin" ? [this.corePluginType(a[5])] : this.corePlugin(a[5], method === "addPlugin")),
+            ],
+        });
+        const collectionPluginOp = (method, disc) => ({
+            ...collectionPlugin,
+            data: (a) => [
+                { bytes: [disc] },
+                ...(method === "removeCollectionPlugin" ? [this.corePluginType(a[4])] : this.corePlugin(a[4], method === "addCollectionPlugin")),
+            ],
+        });
+        // Add/RemoveExternalPluginAdapterV1: asset, collection, payer, authority, systemProgram, logWrapper; the write has a
+        // buffer account (left out: the data is in the instruction) before systemProgram. The Collection forms drop the asset.
+        const external = (method, disc, collection) => {
+            const write = method.startsWith("write");
+            const add = method.startsWith("add");
+            const n = (collection ? 5 : 6) + (write ? 1 : 0);
+            const at = collection ? 4 : 5;
+            const head = collection ? "collection, payer, authority | null, systemProgram" : "asset, collection | null, payer, authority | null, systemProgram";
+            const metas = collection
+                ? [
+                    [0, "the collection", true, false],
+                    [1, "the payer", true, true],
+                    [2, "the authority", false, true],
+                ]
+                : [asset, [1, "the collection", true, false], [2, "the payer", true, true], [3, "the authority", false, true]];
+            if (write)
+                metas.push("self");
+            metas.push([collection ? 3 : 4, "the system program", false, false], "self");
+            return {
+                usage: (m) => `${m}(${head}, ${add ? "plugin" : write ? "key, data" : "key"}, signerSeeds?)`,
+                args: n,
+                metas,
+                max: 1024,
+                data: (a) => [
+                    { bytes: [disc] },
+                    ...(add
+                        ? this.coreExternalPlugin(a[at])
+                        : write
+                            ? [...this.coreExternalKey(a[at]), ...this.coreExternalData(a[at + 1])]
+                            : this.coreExternalKey(a[at])),
+                ],
+            };
+        };
+        return {
+            createAsset: {
+                usage: () => "createAsset(asset, collection | null, authority | null, payer, owner | null, systemProgram, name, uri, plugins?, signerSeeds?)",
+                args: 8,
+                plugins: true,
+                // CreateV1: asset, collection, authority, payer, owner, updateAuthority (the collection's, or the payer by
+                // default), systemProgram, logWrapper.
+                metas: [
+                    [0, "the asset", true, true],
+                    [1, "the collection", true, false],
+                    [2, "the collection authority", false, true],
+                    [3, "the payer", true, true],
+                    [4, "the owner", false, false],
+                    "self",
+                    [5, "the system program", false, false],
+                    "self",
+                ],
+                max: 2048,
+                data: (a, plugins) => [{ bytes: [0, 0] }, str(a[6]), str(a[7]), ...this.corePluginList(plugins)],
+            },
+            createCollection: {
+                usage: () => "createCollection(collection, updateAuthority | null, payer, systemProgram, name, uri, plugins?, signerSeeds?)",
+                args: 6,
+                plugins: true,
                 // CreateCollectionV1: collection, updateAuthority, payer, systemProgram.
-                const plugins = isPlugins(a[6]) ? a[6] : undefined;
-                if (a.length < 6 || a.length > (plugins ? 8 : 7))
-                    this.fail(node, "createCollection(collection, updateAuthority | null, payer, systemProgram, name, uri, plugins?, signerSeeds?)");
-                const metas = [
-                    this.mplMeta(a[0], core, "the collection", true, true),
-                    this.mplMeta(a[1], core, "the update authority", false, false),
-                    this.mplMeta(a[2], core, "the payer", true, true),
-                    this.mplMeta(a[3], core, "the system program", false, false),
-                ];
-                const data = this.mplData(node, 2048, [{ bytes: [1] }, str(a[4]), str(a[5]), ...this.corePluginList(plugins)]);
-                this.cpi(p, metas, data.buf, data.len, seedsAt(plugins ? 7 : 6));
-                return undefined;
-            }
-            case "addPlugin":
-            case "updatePlugin":
-            case "removePlugin": {
-                // Add/Remove/UpdatePluginV1: asset, collection, payer, authority, systemProgram, logWrapper.
-                const last = method === "removePlugin" ? "kind" : "plugin";
-                if (a.length !== 6 && a.length !== 7)
-                    this.fail(node, `${method}(asset, collection | null, payer, authority | null, systemProgram, ${last}, signerSeeds?)`);
-                const metas = [
-                    this.mplMeta(a[0], core, "the asset", true, false),
-                    this.mplMeta(a[1], core, "the collection", true, false),
-                    this.mplMeta(a[2], core, "the payer", true, true),
-                    this.mplMeta(a[3], core, "the authority", false, true),
-                    this.mplMeta(a[4], core, "the system program", false, false),
-                    self,
-                ];
-                const body = method === "removePlugin" ? [this.corePluginType(a[5])] : this.corePlugin(a[5], method === "addPlugin");
-                const data = this.mplData(node, 2048, [{ bytes: [{ addPlugin: 2, removePlugin: 4, updatePlugin: 6 }[method]] }, ...body]);
-                this.cpi(p, metas, data.buf, data.len, seedsAt(6));
-                return undefined;
-            }
-            case "addCollectionPlugin":
-            case "updateCollectionPlugin":
-            case "removeCollectionPlugin": {
-                // Add/Remove/UpdateCollectionPluginV1: collection, payer, authority, systemProgram, logWrapper.
-                const last = method === "removeCollectionPlugin" ? "kind" : "plugin";
-                if (a.length !== 5 && a.length !== 6)
-                    this.fail(node, `${method}(collection, payer, authority | null, systemProgram, ${last}, signerSeeds?)`);
-                const metas = [
-                    this.mplMeta(a[0], core, "the collection", true, false),
-                    this.mplMeta(a[1], core, "the payer", true, true),
-                    this.mplMeta(a[2], core, "the authority", false, true),
-                    this.mplMeta(a[3], core, "the system program", false, false),
-                    self,
-                ];
-                const body = method === "removeCollectionPlugin" ? [this.corePluginType(a[4])] : this.corePlugin(a[4], method === "addCollectionPlugin");
-                const data = this.mplData(node, 2048, [{ bytes: [{ addCollectionPlugin: 3, removeCollectionPlugin: 5, updateCollectionPlugin: 7 }[method]] }, ...body]);
-                this.cpi(p, metas, data.buf, data.len, seedsAt(5));
-                return undefined;
-            }
-            case "transferAsset": {
+                metas: [
+                    [0, "the collection", true, true],
+                    [1, "the update authority", false, false],
+                    [2, "the payer", true, true],
+                    [3, "the system program", false, false],
+                ],
+                max: 2048,
+                data: (a, plugins) => [{ bytes: [1] }, str(a[4]), str(a[5]), ...this.corePluginList(plugins)],
+            },
+            addPlugin: assetPluginOp("addPlugin", 2),
+            removePlugin: assetPluginOp("removePlugin", 4),
+            updatePlugin: assetPluginOp("updatePlugin", 6),
+            addCollectionPlugin: collectionPluginOp("addCollectionPlugin", 3),
+            removeCollectionPlugin: collectionPluginOp("removeCollectionPlugin", 5),
+            updateCollectionPlugin: collectionPluginOp("updateCollectionPlugin", 7),
+            transferAsset: {
+                usage: () => "transferAsset(asset, collection | null, payer, authority | null, newOwner, signerSeeds?)",
+                args: 5,
                 // TransferV1: asset, collection, payer, authority, newOwner, systemProgram, logWrapper.
-                if (a.length !== 5 && a.length !== 6)
-                    this.fail(node, "transferAsset(asset, collection | null, payer, authority | null, newOwner, signerSeeds?)");
-                const metas = [
-                    this.mplMeta(a[0], core, "the asset", true, false),
-                    this.mplMeta(a[1], core, "the collection", false, false),
-                    this.mplMeta(a[2], core, "the payer", true, true),
-                    this.mplMeta(a[3], core, "the authority", false, true),
-                    this.mplMeta(a[4], core, "the new owner", false, false),
-                    [p, false, false],
-                    [p, false, false],
-                ];
-                const data = this.mplData(node, 8, [{ bytes: [14, 0] }]);
-                this.cpi(p, metas, data.buf, data.len, seedsAt(5));
-                return undefined;
-            }
-            case "burnAsset": {
+                metas: [
+                    asset,
+                    [1, "the collection", false, false],
+                    [2, "the payer", true, true],
+                    [3, "the authority", false, true],
+                    [4, "the new owner", false, false],
+                    "self",
+                    "self",
+                ],
+                max: 8,
+                data: () => [{ bytes: [14, 0] }],
+            },
+            burnAsset: {
+                usage: () => "burnAsset(asset, collection | null, payer, authority | null, signerSeeds?)",
+                args: 4,
                 // BurnV1: asset, collection, payer, authority, systemProgram, logWrapper.
-                if (a.length !== 4 && a.length !== 5)
-                    this.fail(node, "burnAsset(asset, collection | null, payer, authority | null, signerSeeds?)");
-                const metas = [
-                    this.mplMeta(a[0], core, "the asset", true, false),
-                    this.mplMeta(a[1], core, "the collection", true, false),
-                    this.mplMeta(a[2], core, "the payer", true, true),
-                    this.mplMeta(a[3], core, "the authority", false, true),
-                    [p, false, false],
-                    [p, false, false],
-                ];
-                const data = this.mplData(node, 8, [{ bytes: [12, 0] }]);
-                this.cpi(p, metas, data.buf, data.len, seedsAt(4));
-                return undefined;
-            }
-            case "addExternalPlugin":
-            case "removeExternalPlugin":
-            case "writeExternalPluginData": {
-                // Add/RemoveExternalPluginAdapterV1: asset, collection, payer, authority, systemProgram, logWrapper;
-                // WriteExternalPluginAdapterDataV1 has a buffer account (left out: the data is in the instruction) before systemProgram.
-                const write = method === "writeExternalPluginData";
-                const n = write ? 7 : 6;
-                if (a.length !== n && a.length !== n + 1)
-                    this.fail(node, `${method}(asset, collection | null, payer, authority | null, systemProgram, ${method === "addExternalPlugin" ? "plugin" : write ? "key, data" : "key"}, signerSeeds?)`);
-                const metas = [
-                    this.mplMeta(a[0], core, "the asset", true, false),
-                    this.mplMeta(a[1], core, "the collection", true, false),
-                    this.mplMeta(a[2], core, "the payer", true, true),
-                    this.mplMeta(a[3], core, "the authority", false, true),
-                    ...(write ? [self] : []),
-                    this.mplMeta(a[4], core, "the system program", false, false),
-                    self,
-                ];
-                const body = method === "addExternalPlugin"
-                    ? this.coreExternalPlugin(a[5])
-                    : write
-                        ? [...this.coreExternalKey(a[5]), ...this.coreExternalData(a[6])]
-                        : this.coreExternalKey(a[5]);
-                const data = this.mplData(node, 1024, [{ bytes: [{ addExternalPlugin: 22, removeExternalPlugin: 24, writeExternalPluginData: 28 }[method]] }, ...body]);
-                this.cpi(p, metas, data.buf, data.len, seedsAt(n));
-                return undefined;
-            }
-            case "addCollectionExternalPlugin":
-            case "removeCollectionExternalPlugin":
-            case "writeCollectionExternalPluginData": {
-                // The same on a collection: collection, payer, authority, (buffer,) systemProgram, logWrapper.
-                const write = method === "writeCollectionExternalPluginData";
-                const n = write ? 6 : 5;
-                if (a.length !== n && a.length !== n + 1)
-                    this.fail(node, `${method}(collection, payer, authority | null, systemProgram, ${method === "addCollectionExternalPlugin" ? "plugin" : write ? "key, data" : "key"}, signerSeeds?)`);
-                const metas = [
-                    this.mplMeta(a[0], core, "the collection", true, false),
-                    this.mplMeta(a[1], core, "the payer", true, true),
-                    this.mplMeta(a[2], core, "the authority", false, true),
-                    ...(write ? [self] : []),
-                    this.mplMeta(a[3], core, "the system program", false, false),
-                    self,
-                ];
-                const body = method === "addCollectionExternalPlugin"
-                    ? this.coreExternalPlugin(a[4])
-                    : write
-                        ? [...this.coreExternalKey(a[4]), ...this.coreExternalData(a[5])]
-                        : this.coreExternalKey(a[4]);
-                const data = this.mplData(node, 1024, [
-                    { bytes: [{ addCollectionExternalPlugin: 23, removeCollectionExternalPlugin: 25, writeCollectionExternalPluginData: 29 }[method]] },
-                    ...body,
-                ]);
-                this.cpi(p, metas, data.buf, data.len, seedsAt(n));
-                return undefined;
-            }
-        }
-        this.fail(node.expression, `Metaplex Core supports createAsset, createCollection, addPlugin, updatePlugin, removePlugin, addExternalPlugin, removeExternalPlugin, writeExternalPluginData (and the Collection forms), transferAsset and burnAsset, not ${method}`);
+                metas: [asset, [1, "the collection", true, false], [2, "the payer", true, true], [3, "the authority", false, true], "self", "self"],
+                max: 8,
+                data: () => [{ bytes: [12, 0] }],
+            },
+            addExternalPlugin: external("addExternalPlugin", 22, false),
+            removeExternalPlugin: external("removeExternalPlugin", 24, false),
+            writeExternalPluginData: external("writeExternalPluginData", 28, false),
+            addCollectionExternalPlugin: external("addCollectionExternalPlugin", 23, true),
+            removeCollectionExternalPlugin: external("removeCollectionExternalPlugin", 25, true),
+            writeCollectionExternalPluginData: external("writeCollectionExternalPluginData", 29, true),
+        };
     }
     /** The fields of a Core object literal (`{ kind: "AppData", … }`) by name. */
     coreProps(node, what) {

package/docs/architecture.md

@@ -22,6 +22,21 @@ program.so + program.build.json (manifest: versions, sha256 of sources and binar
 `compiler/index.ts` wires the stages together. `generate()` runs analyze, emit and IDL generation in memory, and
 `build()` also compiles and writes the output files.
 
+## Repository layout
+
+| Path | Contents |
+| --- | --- |
+| `src/` | The compiler (`src/compiler/`) and the tools around it: CLI, workspace, client, CPI and port generators, testing, IDL publishing (source map below) |
+| `runtime/` | `typesol_rt.h`, the C runtime every program includes ([runtime.md](runtime.md)) |
+| `lib/` | `typesol.d.ts`, the language surface programs typecheck against |
+| `ts-plugin/` | The editor plugin (`typesol/ts-plugin`) |
+| `examples/` | Example programs; the `typesol init` templates are copies of three of them |
+| `test/` | The test suite: `fixtures/` (programs the tests compile), `ports/` (TypeSOL rewrites of solana-developers/program-examples), `golden/` (pinned generated clients), `programs/` (third-party program binaries, see its SOURCES.md) |
+| `bench/anchor/` | Anchor twins of the counter, vault and escrow examples, for the differential tests (`pnpm bench:anchor`) and the zero-copy client test; the benchmarks themselves are in [typesol/benchmarks](https://github.com/typesol/benchmarks) |
+| `scripts/` | `smoke.ts` and `localnet.sh` (a local validator run), `fetch-programs.sh` (third-party binaries), `readme-bench.ts` (the README numbers) |
+| `docs/` | User and contributor documentation (also published on typesol.com) |
+| `assets/` | The CLI's logo and the README images (`readme/`, generated) |
+
 ## Source map
 
 | Path | Role |
@@ -34,11 +49,17 @@ program.so + program.build.json (manifest: versions, sha256 of sources and binar
 | `src/compiler/idl.ts` | Turns the model into an Anchor IDL: accounts with `pda`, `relations`, `address` and `optional`, plus types, events, errors and docs. |
 | `src/compiler/toolchain.ts` | Finds the Agave SDK and runs clang and lld with the SDK's flags, plus per-function sections, `--gc-sections` and `--strip-all` so unused code and symbol tables stay out of the binary. |
 | `src/compiler/diagnostics.ts` | `Reporter` and `CompileError`: diagnostics with file, line and column. |
+| `src/compiler/anchor-errors.ts` | Anchor's own error codes (`AnchorError.X`), shared by `require` and the generated clients. |
+| `src/compiler/index.ts` | The compiler's API (`generate`, `build`, `verifyBinary`, the build manifest). |
 | `runtime/typesol_rt.h` | The C runtime: error codes, word-wise memory helpers, the entry point's input parser (`ts_deserialize`), account checks, checked math, Borsh helpers, CPIs (System, Token, Token-2022, ATA, Metaplex), oracles and the heap allocator. Header-only and `static inline`, so unused code is dropped. |
 | `src/workspace.ts` | `typesol.json` projects, program keypairs, `typesol init` templates and deploy arguments. |
 | `src/cpigen.ts` | `typesol cpi`: reads an Anchor IDL and writes typed TypeSOL CPI helpers. |
 | `src/clientgen.ts` | The TypeScript client (`<name>.client.ts`, [client.md](client.md)): reads an IDL, validates it (it may come from anywhere), and writes one `@solana/kit` file. Not part of the compiler core: `workspace.ts` and the CLI write it after `build()`, and `typesol client` writes it for any IDL. |
-| `src/idlpublish.ts` | `typesol idl publish` through the Program Metadata program. |
+| `src/idlpublish.ts` | `typesol idl publish` through the Program Metadata program, and reading a program's IDL back from the chain (Program Metadata or Anchor's IDL account) for `typesol client --address`. |
+| `src/portgen.ts` | `typesol port`: a TypeSOL program skeleton from an Anchor IDL (structs, enums, errors, events, one function per instruction). |
+| `src/templates.ts` | The programs and tests `typesol init --template` writes (copies of `examples/`; a test checks they match). |
+| `src/svmrpc.ts` | `svmConnection`: a kit RPC and subscriptions pair answered by LiteSVM, so generated clients run in tests (exported by `typesol/testing`). |
+| `src/keys.ts` | Base58 and program keypair helpers. |
 | `ts-plugin/index.js` | `typesol/ts-plugin` (CommonJS, loaded by tsserver): runs `typesol check --json --stdin` on program entries and adds the diagnostics. |
 | `src/testing.ts` | `typesol/testing`: LiteSVM test helpers for projects (accounts by name from the IDL, plain values). |
 | `src/onchain.ts` | `typesol verify --address`: a deployed program's ELF, authority and deploy slot under loader v2, v3 or v4. |
@@ -54,7 +75,7 @@ call evaluates expressions), the method is declared `abstract` at the end of `ba
 
 | File | Layer | Contents |
 | --- | --- | --- |
-| `shared.ts` | | `Value`, `Ref` and `Local`, limits, and the C type helpers (`valueC`, `fieldC`, `storageDecl`, `cString`) |
+| `shared.ts` | | `Value`, `Ref` and `Local`, limits, and the C type helpers (`valueC`, `fieldC`, `storageDecl`, `cString`), growable Vec placement (`vecPlace`, `vecLenCheck`) |
 | `base.ts` | `EmitterBase` | function state; `line()`, `tmp()`, `settle()`, scopes, `fail()`, account lookup |
 | `storage.ts` | `StorageEmitter` | references into account data and locals, reads and writes, indexing, aliasing, argument validation |
 | `expressions.ts` | `ExpressionEmitter` | literals, operators and checked arithmetic, property reads, conditionals, text, casts |
@@ -63,6 +84,9 @@ call evaluates expressions), the method is declared `abstract` at the end of `ba
 | `statements.ts` | `StatementEmitter` | variables, assignment, `if`/loops/`switch`, `return` |
 | `function.ts` | `FunctionEmitter` | the instruction prologue (account checks, constraints, argument decoding) and epilogue |
 
+`borsh.ts` writes the Borsh pack/unpack codecs of `@layout borsh` structs, and `program.ts` assembles the C file
+(typedefs, codecs, helpers, instructions, the entry point). `index.ts` is the emitter's export.
+
 ## Rules the emitter keeps
 
 These invariants are easy to break. Each one has tests.

package/docs/runtime.md

@@ -0,0 +1,59 @@
+# The C runtime
+
+`runtime/typesol_rt.h` is included by every generated program. It holds what the emitted C calls: error codes, the
+entry point's input parser, account checks, checked arithmetic, Borsh helpers, CPIs, sysvars, strings and the heap.
+This page is for people changing it; programs never call it directly.
+
+## Conventions
+
+- **Header-only, `static inline`.** Each program compiles the header with its own code, and `--gc-sections` drops
+  what it does not use. `always_inline` marks the few helpers that must disappear into their caller (word loads and
+  stores, `ts_memcpy`, checked add/subtract); `noinline` marks the ones that should exist once per program because
+  many call sites would otherwise each grow the binary (`ts_fail`, the rent fallback `ts_rent_slow`, PDA search).
+- **Errors are return values.** A function that can fail returns `uint64_t`: `SUCCESS`, or an error code. Fail with
+  `TS_FAIL(code, "TypeSOL: …")` (logs the message, then returns the code) and propagate with `TS_TRY(call)`.
+  Nothing aborts: the instruction returns the code, and the runtime reports it as `Custom(code)`.
+- **Error codes follow Anchor.** Where Anchor has a framework error with the same meaning, its number is used (2006
+  ConstraintSeeds, 3003 AccountDidNotDeserialize, …), so Anchor and Codama clients name failures correctly.
+  TypeSOL-only conditions are 5100–5199; user errors start at 6000. Every code is listed in [errors.md](errors.md).
+- **No byte loops from the SDK.** The SDK's `sol_memcpy`, `sol_memcmp` and `SolPubkey_same` move one byte per
+  iteration. The runtime uses `ts_ld64` / `ts_st64` (unaligned 8-byte loads and stores, which SBF allows) in
+  `ts_memcpy`, `ts_memzero`, `ts_mem_eq`, `ts_key_eq` and `ts_memmove`.
+- **Same results as the reference.** Fast paths must give bit-identical results to what they replace: `ts_add_overflow_u64`
+  matches `__builtin_add_overflow`, the rent fast path and `ts_rent_slow` match the double computation, PDA search
+  matches `sol_try_find_program_address`. A change here needs a test against the reference, not only against itself.
+
+## Sections
+
+In file order:
+
+| Section | What it provides |
+| --- | --- |
+| Error codes, `TS_FAIL`, `TS_TRY` | The codes above and the two macros |
+| Word-wise memory helpers | `ts_ld64`, `ts_st64`, `ts_memcpy`, `ts_memmove`, `ts_memzero`, `ts_mem_eq`; checked u64 add/subtract/multiply |
+| Well-known program ids | System, Token, Token-2022, ATA, Metaplex and the other programs the language names |
+| Strings | `TS_Str` views (pointer, length), UTF-8 validation, comparison, `FixedString<N>` storage |
+| Entry point input | `TsAccount` (the loader's serialized account, read in place), `TsParams`, `ts_deserialize` |
+| Account checks | owner, discriminator, signer, writable, executable, address, size, uniqueness (`ts_check_*`), growable Vec lengths |
+| Little-endian IO | `ts_read_le` and friends for argument decoding and Borsh |
+| Sysvars | clock, rent (`ts_rent`, `ts_minimum_balance_of`, `ts_minimum_balance`), program data |
+| PDA | `ts_pda_hash`, `ts_create_pda_address`, `ts_find_pda` (canonical bump), `ts_require_pda` |
+| System program CPIs | create, assign, allocate, transfer, `ts_create_pda`, `ts_resize` / `ts_realloc`, close |
+| Token-2022 extensions | TLV walking for the extensions the language reads |
+| Metaplex Core and Bubblegum | account readers (`coreAssetOwner`, …) |
+| SPL Token / Token-2022 CPIs | transfer, mint, burn, approve, close, freeze and their checked forms |
+| Return data | `sol_set_return_data` wrappers |
+| Crypto | sha256, keccak256, ed25519 / secp256k1 verification helpers, Merkle proofs |
+| Heap | `ts_alloc`, a bump allocator (32 KiB by default, `HEAP_SIZE_KIB` up to 256), string building (`ts_str_join`, `ts_str_append`, number and base58 text) |
+| Oracles | Pyth price updates, Switchboard |
+| Associated token accounts, token metadata, transfer hooks | ATA derivation and creation, Token Metadata CPIs, transfer-hook extra accounts |
+
+## Changing it
+
+- Every runtime change can move compute units or binary size. Measure it before and after with
+  [typesol/benchmarks](https://github.com/typesol/benchmarks) pointed at your checkout, and put the difference in
+  the pull request (see CONTRIBUTING).
+- A change that alters behavior (a result, an error code, a log line, account bytes) is a language change and goes
+  in the CHANGELOG as one. One that only changes cost says so: "same results".
+- New error codes: add the `#define` here, the row in [errors.md](errors.md) and the name in the compiler's runtime
+  error list (`TYPESOL_ERRORS` in `src/clientgen.ts`), so clients name it (a test checks every code has a name).

package/package.json

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

package/runtime/typesol_rt.h

@@ -62,11 +62,12 @@
 #define TS_ERR_NO_RETURN 5114
 #define TS_ERR_ACCOUNT_MISSING 5115
 
-#define TS_FAIL(code, msg) \
-  do {                     \
-    sol_log(msg);          \
-    return (code);         \
-  } while (0)
+/* Every failure logs through this one sol_log_ call: each syscall call site costs a 16-byte relocation in the binary. */
+static __attribute__((noinline)) uint64_t ts_fail(uint64_t code, const char *msg, uint64_t len) {
+  sol_log_(msg, len);
+  return code;
+}
+#define TS_FAIL(code, msg) return ts_fail((code), (msg), sol_strlen(msg))
 
 #define TS_TRY(expr)                 \
   do {                               \
@@ -503,6 +504,49 @@ static inline void ts_write_le(uint8_t *p, uint64_t v, int n) { ts_memcpy(p, &v,
 uint64_t sol_get_rent_sysvar(void *ret);
 uint64_t sol_get_clock_sysvar(void *ret);
 
+/* The general case, in integers: exactly (uint64_t)((double)per_year * threshold) as soft-float computes it (the
+   conversion and the product rounded to nearest, ties to even; NaN, negative and < 1 give 0), or UINT64_MAX when that
+   product is >= 2^64 (no double below 2^64 converts to UINT64_MAX: the largest is 2^64 - 2048). No soft-float routine
+   is linked, which keeps about 1.7 KB out of every program that creates accounts. */
+static __attribute__((noinline, minsize)) uint64_t ts_rent_slow(uint64_t per_year, uint64_t tbits) {
+  uint64_t e = (tbits >> 52) & 0x7ff, f = tbits & 0xfffffffffffffULL;
+  if (e == 0x7ff) return !f && per_year && !(tbits >> 63) ? UINT64_MAX : 0; /* +inf overflows; NaN, inf * 0, -inf: 0 */
+  if ((tbits >> 63) || !per_year || (!e && !f)) return 0;                   /* a negative or zero product */
+  /* Round v * 2^ex (with a sticky bit for bits already dropped) to 53 bits, nearest-even, twice: per_year to a double,
+     then the exact product of the two significands. */
+  uint64_t v = per_year, sticky = 0, mt = e ? f | (1ULL << 52) : f;
+  int64_t ex = (e ? (int64_t)e : 1) - 1075;
+  for (int pass = 0; pass < 2; pass++) {
+    int top = 63;
+    while (!(v >> top)) top--;
+    if (top > 52) {
+      int sh = top - 52;
+      uint64_t rem = v & ((1ULL << sh) - 1), half = 1ULL << (sh - 1);
+      v >>= sh;
+      ex += sh;
+      if (rem > half || (rem == half && (sticky || (v & 1)))) v++;
+      if (v >> 53) v >>= 1, ex++;
+    }
+    if (pass) break;
+    /* v (< 2^53) * mt (< 2^53) as hi:lo, folded to 64 bits with the dropped low bits as the sticky bit. */
+    uint64_t a0 = v & 0xffffffff, a1 = v >> 32, b0 = mt & 0xffffffff, b1 = mt >> 32;
+    uint64_t lo = a0 * b0, mid = a0 * b1 + a1 * b0, hi = a1 * b1;
+    uint64_t lo2 = lo + (mid << 32);
+    hi += (mid >> 32) + (lo2 < lo);
+    lo = lo2;
+    int s = 0;
+    while (hi >> s) s++;
+    v = s ? (hi << (64 - s)) | (lo >> s) : lo;
+    sticky = s ? (lo & ((1ULL << s) - 1)) != 0 : 0;
+    ex += s;
+  }
+  int top = 63;
+  while (!(v >> top)) top--;
+  if (top + ex >= 64) return UINT64_MAX;
+  if (ex >= 0) return v << ex;
+  return ex > -64 ? v >> -ex : 0;
+}
+
 /* The minimum balance of `data_len` bytes under `rent`, the Rent sysvar
    { lamports_per_byte_year: u64, exemption_threshold: f64, burn_percent: u8 }. */
 static inline uint64_t ts_minimum_balance_of(const uint64_t rent[3], uint64_t data_len, uint64_t *out) {
@@ -520,11 +564,9 @@ static inline uint64_t ts_minimum_balance_of(const uint64_t rent[3], uint64_t da
       return SUCCESS;
     }
   }
-  double threshold;
-  ts_memcpy(&threshold, &rent[1], 8);
-  double lamports = (double)per_year * threshold;
-  if (lamports >= 18446744073709551615.0) TS_FAIL(TS_ERR_OVERFLOW, "TypeSOL: arithmetic overflow");
-  *out = (uint64_t)lamports;
+  uint64_t lamports = ts_rent_slow(per_year, rent[1]);
+  if (lamports == UINT64_MAX) TS_FAIL(TS_ERR_OVERFLOW, "TypeSOL: arithmetic overflow");
+  *out = lamports;
   return SUCCESS;
 }