@typesol/cli 0.23.0 → 0.24.0

package/dist/compiler/emit/statements.js

@@ -1,6 +1,6 @@
 import ts from "typescript";
-import { MAX_RETURN_DATA, resolveScalarType, resolveValueType, structNameOf, typesolName } from "../analyze.js";
-import { INT_INFO, isWritable, optionKey, scalarSize, typeName } from "../model.js";
+import { MAX_RETURN_DATA, calleeName, resolveScalarType, resolveValueType, structNameOf, typesolName } from "../analyze.js";
+import { INT_INFO, isScalar, isWritable, optionKey, scalarSize, typeName, } from "../model.js";
 import { U64, BOOL, cString, fixedVecC, optC, scalarC, scalarStorageC, valueC } from "./shared.js";
 import { CpiEmitter } from "./cpi.js";
 /**
@@ -276,6 +276,15 @@ export class StatementEmitter extends CpiEmitter {
             this.loops.pop();
         });
     }
+    /** The function an identifier names (a closure, a local function or a helper), as something to expand; else undefined. */
+    functionNamed(id) {
+        const l = this.lookup(id.text);
+        if (l)
+            return l.closure;
+        const name = calleeName(id, this.model.helperDecls, this.checker);
+        const h = name ? (this.model.helpers.get(name) ?? this.model.generics.get(name)) : undefined;
+        return h ? { node: h.node, name: h.display, scopes: [], env: this.noEnv(), imports: h.imports } : undefined;
+    }
     /** `xs.map(…)` / `xs.filter(…)` (or a chain of them): a list built element by element, not stored anywhere yet. */
     isPipeline(e) {
         return ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) && (e.expression.name.text === "map" || e.expression.name.text === "filter");
@@ -343,7 +352,13 @@ export class StatementEmitter extends CpiEmitter {
                 let idx = indexId;
                 let k = 0;
                 for (const st of stages) {
-                    const closure = { node: st.fn, name: `${st.kind}'s callback`, scopes: [...this.scopes] };
+                    if (st.kind === "map") {
+                        const ret = st.fn.body && !ts.isBlock(st.fn.body) ? st.fn.body : undefined;
+                        const bare = ret && ts.isParenthesizedExpression(ret) ? ret.expression : ret;
+                        if (bare && ts.isObjectLiteralExpression(bare))
+                            this.fail(st.fn, "a map to structs is stored, with the struct type: const ys: FixedVec<MyStruct, N> = xs.map((x) => ({ … }))");
+                    }
+                    const closure = { node: st.fn, name: `${st.kind}'s callback`, scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports };
                     const v = this.expandClosure(closure, [element, idx].slice(0, st.fn.parameters.length), st.fn);
                     if (st.kind === "filter") {
                         if (!v)
@@ -393,8 +408,13 @@ export class StatementEmitter extends CpiEmitter {
             const n = args[1] && ts.isLiteralTypeNode(args[1]) && ts.isNumericLiteral(args[1].literal) ? Number(args[1].literal.text) : NaN;
             const elemNode = args[0];
             const sn = elemNode && structNameOf(elemNode, this.scope);
+            const fs = elemNode && typesolName(elemNode, this.scope.imports) === "FixedString" ? elemNode.typeArguments?.[0] : undefined;
+            const fcap = fs && ts.isLiteralTypeNode(fs) && ts.isNumericLiteral(fs.literal) ? Number(fs.literal.text) : NaN;
+            if (Number.isInteger(fcap) && fcap >= 1)
+                this.model.fstrings.add(fcap);
             annotatedElem = elemNode
-                ? (resolveScalarType(elemNode, this.scope) ?? (sn && this.model.structs.has(sn) ? { kind: "struct", name: sn } : undefined))
+                ? (resolveScalarType(elemNode, this.scope) ??
+                    (sn && this.model.structs.has(sn) ? { kind: "struct", name: sn } : Number.isInteger(fcap) && fcap >= 1 ? { kind: "fstring", cap: fcap } : undefined))
                 : undefined;
             if (!ts.isTypeReferenceNode(t) || typesolName(t, this.scope.imports) !== "FixedVec" || !annotatedElem || !Number.isInteger(n) || n < 1)
                 this.fail(t, "annotate the new list as FixedVec<T, N> (N a literal)");
@@ -415,21 +435,39 @@ export class StatementEmitter extends CpiEmitter {
         this.line(`/* ${c} */`);
         let elem = stages.some((st) => st.kind === "map") ? undefined : this.listElem(base);
         const cap0 = cap;
-        this.eachElement(init, init, { index: `__ml${this.temp++}`, ci: this.tmp("ml_i") }, (element) => {
-            if (!elem) {
-                const v = this.expr(element);
-                elem = v.type;
-            }
-            const target = annotatedElem ?? elem;
-            const sub = { lv: `${c}.items[${c}.len]`, type: target, writable: true };
-            this.line(`if (${c}.len >= ${cap0}) TS_FAIL(TS_ERR_INDEX, "TypeSOL: the new list is full");`);
-            const vt = this.storageValueType(target);
-            if (vt)
-                this.line(this.writeStorage(sub, this.ownedString(this.expect(this.expr(element, vt), vt, element)).c) + ";");
-            else
-                this.writeAggregate(sub, element);
-            this.line(`${c}.len++;`);
-        });
+        // A last map to structs or FixedStrings (annotated) writes each result straight into its slot.
+        const last = stages.at(-1);
+        if (last?.kind === "map" && annotatedElem && !isScalar(annotatedElem)) {
+            const target = annotatedElem;
+            const inner = init.expression.expression;
+            this.eachElement(inner, init, { index: `__ml${this.temp++}`, ci: this.tmp("ml_i") }, (element, index) => {
+                this.line(`if (${c}.len >= ${cap0}) TS_FAIL(TS_ERR_INDEX, "TypeSOL: the new list is full");`);
+                const closure = { node: last.fn, name: "map's callback", scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports };
+                this.expandClosure(closure, [element, index].slice(0, last.fn.parameters.length), last.fn, {
+                    lv: `${c}.items[${c}.len]`,
+                    type: target,
+                    writable: true,
+                });
+                this.line(`${c}.len++;`);
+            });
+            elem = target;
+        }
+        else
+            this.eachElement(init, init, { index: `__ml${this.temp++}`, ci: this.tmp("ml_i") }, (element) => {
+                if (!elem) {
+                    const v = this.expr(element);
+                    elem = v.type;
+                }
+                const target = annotatedElem ?? elem;
+                const sub = { lv: `${c}.items[${c}.len]`, type: target, writable: true };
+                this.line(`if (${c}.len >= ${cap0}) TS_FAIL(TS_ERR_INDEX, "TypeSOL: the new list is full");`);
+                const vt = this.storageValueType(target);
+                if (vt)
+                    this.line(this.writeStorage(sub, this.ownedString(this.expect(this.expr(element, vt), vt, element)).c) + ";");
+                else
+                    this.writeAggregate(sub, element);
+                this.line(`${c}.len++;`);
+            });
         const t = { kind: "vec", elem: annotatedElem ?? elem, cap: cap0 };
         const bytes = 4 + this.fieldBytes(t.elem) * cap0;
         if (bytes > 2048)
@@ -484,13 +522,17 @@ export class StatementEmitter extends CpiEmitter {
      * was declared with, so a block around the call that declares the same name does not change what it reads, and
      * writes to captured `let`s are seen by the enclosing function. Returns the result (undefined for no value).
      */
-    expandClosure(c, args, node) {
+    expandClosure(c, args, node, into) {
         const fn = c.node;
         if (this.inlining.has(fn))
             this.fail(node, `${c.name} calls itself: closures cannot be recursive`);
+        // Its types are written in its own file: they mean what that file's imports say (the arguments are the caller's).
+        const calleeScope = c.imports === this.scope.imports ? this.scope : { ...this.scope, imports: c.imports };
         if (args.length !== fn.parameters.length)
             this.fail(node, `${c.name}() takes ${fn.parameters.length} argument(s)`);
         const params = new Map();
+        // Account parameters (of a helper expanded here) name the caller's accounts while the body runs.
+        const aliases = new Map();
         fn.parameters.forEach((p, i) => {
             if (!ts.isIdentifier(p.name) || p.initializer || p.dotDotDotToken)
                 this.fail(p, "closure parameters are plain names");
@@ -501,12 +543,22 @@ export class StatementEmitter extends CpiEmitter {
                 params.set(name, { c: "", type: BOOL, mutable: false, closure: this.closureOf(arg) });
                 return;
             }
+            if (p.type && ts.isIdentifier(arg) && !this.lookup(arg.text) && this.accounts.has(arg.text) && !resolveValueType(p.type, calleeScope)) {
+                aliases.set(name, this.accounts.get(arg.text));
+                return;
+            }
             const c2 = `l_${name}_${this.temp++}`;
-            const annotated = p.type ? resolveValueType(p.type, this.scope) : undefined;
+            const annotated = p.type ? resolveValueType(p.type, calleeScope) : undefined;
             if (!annotated && this.looksLikeStructPlace(arg)) {
                 const place = this.structPlace(arg);
                 this.line(`TSS_${place.struct} *${c2} = ${place.ptr};`);
-                params.set(name, { c: c2, type: { kind: "structRef", struct: place.struct, writable: place.writable }, mutable: false, paths: this.pathsOf(arg) });
+                params.set(name, {
+                    c: c2,
+                    type: { kind: "structRef", struct: place.struct, writable: place.writable },
+                    mutable: false,
+                    paths: this.pathsOf(arg),
+                    decl: p,
+                });
                 return;
             }
             let v = this.expr(arg, annotated);
@@ -522,7 +574,7 @@ export class StatementEmitter extends CpiEmitter {
                 this.line(`${valueC(type)}${type.kind === "account" ? "" : " "}${c2} = ${this.ownedString(v).c};`);
             params.set(name, { c: c2, type, mutable: true });
         });
-        const declared = fn.type && fn.type.kind !== ts.SyntaxKind.VoidKeyword ? resolveValueType(fn.type, this.scope) : undefined;
+        const declared = fn.type && fn.type.kind !== ts.SyntaxKind.VoidKeyword ? resolveValueType(fn.type, calleeScope) : undefined;
         if (fn.type && fn.type.kind !== ts.SyntaxKind.VoidKeyword && !declared)
             this.fail(fn.type, "closures return integers, booleans, Pubkeys, strings, enums or Options");
         const frame = {
@@ -532,10 +584,34 @@ export class StatementEmitter extends CpiEmitter {
             declAt: this.lines.length,
             pad: "  ".repeat(this.indent),
             node: fn,
+            into,
         };
         this.line(declared ? `${declared.kind === "pubkey" ? "SolPubkey" : valueC(declared)} ${frame.result};` : `/* ${frame.result} */`);
-        const saved = { scopes: this.scopes, loops: this.loops.splice(0) };
+        // The body names what it could where it was written: a closure the caller's arguments and accounts, a helper
+        // only its own parameters (its account parameters name the caller's accounts) and the module.
+        const swap = (m, to) => {
+            const before = new Map(m);
+            m.clear();
+            for (const [k, v] of to)
+                m.set(k, v);
+            return before;
+        };
+        const bodyAccounts = new Map(c.env.accounts);
+        for (const [n, a] of aliases)
+            bodyAccounts.set(n, a);
+        // Accounts are found by name before locals: a parameter named like one the body can see would read the account.
+        for (const n of params.keys())
+            if (bodyAccounts.has(n))
+                this.fail(fn.parameters.find((p) => ts.isIdentifier(p.name) && p.name.text === n) ?? node, `"${n}" shadows the account "${n}"; use another name`);
+        const saved = {
+            scope: this.scope,
+            scopes: this.scopes,
+            loops: this.loops.splice(0),
+            args: swap(this.args, c.env.args),
+            accounts: swap(this.accounts, bodyAccounts),
+        };
         this.scopes = [...c.scopes, params];
+        this.scope = calleeScope;
         this.inlining.add(fn);
         this.inlineFrames.push(frame);
         try {
@@ -551,7 +627,7 @@ export class StatementEmitter extends CpiEmitter {
                     const ret = ts.factory.createReturnStatement(body);
                     ts.setTextRange(ret, body);
                     ret.parent = fn;
-                    if (ts.isCallExpression(body) && !frame.type) {
+                    if (ts.isCallExpression(body) && !frame.type && !into) {
                         const v = this.call(body, false);
                         if (v)
                             this.closureResult(v, body, frame);
@@ -566,7 +642,10 @@ export class StatementEmitter extends CpiEmitter {
         finally {
             this.inlineFrames.pop();
             this.inlining.delete(fn);
+            swap(this.args, saved.args);
+            swap(this.accounts, saved.accounts);
             this.scopes = saved.scopes;
+            this.scope = saved.scope;
             this.loops.push(...saved.loops);
         }
         if (!frame.type) {
@@ -656,7 +735,7 @@ export class StatementEmitter extends CpiEmitter {
                 this.line(`}`);
             }
             else {
-                const closure = { node: fn, name: `${method}'s callback`, scopes: [...this.scopes] };
+                const closure = { node: fn, name: `${method}'s callback`, scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports };
                 const accId = method === "reduce" ? place(f.createIdentifier(`__acc${this.temp++}`)) : undefined;
                 if (accId)
                     this.scopes.at(-1).set(accId.text, { c: res, type: accType, mutable: true });
@@ -708,6 +787,17 @@ export class StatementEmitter extends CpiEmitter {
     }
     /** `return` inside an expanded closure: the value goes to the closure's result, then past its body. */
     closureReturn(stmt, frame) {
+        if (frame.into && stmt.expression) {
+            // Written straight into its place (an object literal for a struct, text for a FixedString, or a value).
+            const target = frame.into;
+            const vt = this.storageValueType(target.type);
+            if (vt)
+                this.line(this.writeStorage(target, this.ownedString(this.expect(this.expr(stmt.expression, vt), vt, stmt.expression)).c) + ";");
+            else
+                this.writeAggregate(target, stmt.expression);
+            this.line(`goto ${frame.label};`);
+            return;
+        }
         if (!stmt.expression) {
             if (frame.type)
                 this.fail(stmt, "this function returns a value");
@@ -781,7 +871,7 @@ export class StatementEmitter extends CpiEmitter {
                         c: "",
                         type: BOOL,
                         mutable: false,
-                        closure: { node: d.initializer, name: d.name.text, scopes: [...this.scopes] },
+                        closure: { node: d.initializer, name: d.name.text, scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports },
                     });
                     continue;
                 }
@@ -797,6 +887,15 @@ export class StatementEmitter extends CpiEmitter {
                 this.fail(d.name, `"${name}" shadows the parameter "${name}"; use another name`);
             const c = `l_${name}_${this.temp++}`;
             const init = d.initializer;
+            // A function as a value: another name for one (`const h = g`), or the one a function returns (`adder(5n)`).
+            const made = ts.isCallExpression(init) ? this.madeFunction(init) : undefined;
+            const alias = ts.isIdentifier(init) ? this.functionNamed(init) : undefined;
+            if (made || alias) {
+                if (mutable)
+                    this.fail(d, "bind functions with const");
+                this.scopes.at(-1).set(name, { c: "", type: BOOL, mutable: false, closure: (made ?? alias) });
+                continue;
+            }
             const fn = ts.isCallExpression(init) ? this.exportName(init.expression) : undefined;
             if (fn === "fixedArray") {
                 const t = this.localArray(init, c);
@@ -1009,6 +1108,8 @@ export class StatementEmitter extends CpiEmitter {
                     const pieces = this.templatePieces(rhsNode);
                     if (pieces.text !== undefined)
                         this.line(`TS_TRY(ts_str_append(&${cur}, ts_str((const uint8_t *)${cString(pieces.text)}, ${Buffer.byteLength(pieces.text, "utf8")})));`);
+                    else if (pieces.only !== undefined)
+                        this.line(`TS_TRY(ts_str_append(&${cur}, ${pieces.only}));`);
                     else
                         this.line(`TS_TRY(ts_str_append_parts(&${cur}, ${pieces.arr}, ${pieces.n}));`);
                     return;

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

@@ -27,8 +27,12 @@ export declare abstract class StorageEmitter extends EmitterBase {
      * value. Refuse when a live reference into the replaced place is still used afterwards.
      */
     protected assertNotAliased(replaced: string[] | undefined, at: ts.Node, helper?: string): void;
-    /** Whether the variable declared by `decl` is read after `at` (later in its block, or anywhere in a loop around `at`). */
-    protected usedAfter(decl: ts.VariableDeclaration, at: ts.Node): boolean;
+    /**
+     * Whether the variable declared by `decl` is read after `at` (later in its block, or anywhere in a loop around `at`).
+     * A parameter (of a closure or helper expanded here) is read after `at` when its function reads it after `at`; when
+     * `at` is in another function (a closure or helper it calls), any read of it in its own function counts.
+     */
+    protected usedAfter(decl: ts.VariableDeclaration | ts.ParameterDeclaration, at: ts.Node): boolean;
     /**
      * A pointer to a struct in storage, from `place` or `cond ? placeA : placeB` (same struct type).
      * Returns undefined when the expression is not such a place.

package/dist/compiler/emit/storage.js

@@ -73,16 +73,7 @@ export class StorageEmitter extends EmitterBase {
         return r?.type.kind === "dataEnum" ? r : undefined;
     }
     looksLikeDataEnum(node) {
-        const saved = { lines: this.lines.length, hoisted: this.hoisted.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
-        try {
-            return this.reporter.guard(() => this.ref(node))?.type.kind === "dataEnum";
-        }
-        finally {
-            this.lines.length = saved.lines;
-            this.hoisted.length = saved.hoisted; // a probed helper call may hoist declarations
-            this.temp = saved.temp;
-            this.reporter.diagnostics.length = saved.diagnostics;
-        }
+        return this.probe(() => this.ref(node))?.type.kind === "dataEnum";
     }
     variantIndex(enumName, lit) {
         const e = this.model.dataEnums.get(enumName);
@@ -137,11 +128,37 @@ export class StorageEmitter extends EmitterBase {
                     : `"${name}" still refers to ${hit}; replacing it here would change what "${name}" reads (in JS it keeps the old value). Copy the fields you need into locals first`);
             }
     }
-    /** Whether the variable declared by `decl` is read after `at` (later in its block, or anywhere in a loop around `at`). */
+    /**
+     * Whether the variable declared by `decl` is read after `at` (later in its block, or anywhere in a loop around `at`).
+     * A parameter (of a closure or helper expanded here) is read after `at` when its function reads it after `at`; when
+     * `at` is in another function (a closure or helper it calls), any read of it in its own function counts.
+     */
     usedAfter(decl, at) {
         const symbol = this.checker.getSymbolAtLocation(decl.name);
         if (!symbol)
             return true;
+        if (ts.isParameter(decl)) {
+            const fn = decl.parent;
+            const inside = at.getSourceFile() === fn.getSourceFile() && at.pos >= fn.pos && at.end <= fn.end;
+            let read = false;
+            const visitParam = (n) => {
+                if (read)
+                    return;
+                if (ts.isIdentifier(n) && n !== decl.name && this.checker.getSymbolAtLocation(n) === symbol) {
+                    if (!inside || n.pos >= at.end)
+                        read = true;
+                    // A loop inside the function, around `at`, reads it again on its next turn.
+                    for (let p = at.parent; inside && p && p !== fn; p = p.parent)
+                        if ((ts.isForStatement(p) || ts.isForOfStatement(p) || ts.isWhileStatement(p) || ts.isDoStatement(p)) && n.pos >= p.pos && n.end <= p.end)
+                            read = true;
+                }
+                ts.forEachChild(n, visitParam);
+            };
+            const body = fn.body;
+            if (body)
+                visitParam(body);
+            return read;
+        }
         // Loops around `at` that do not also contain the declaration run their earlier statements again later.
         let loop;
         for (let n = at.parent; n && n !== decl.parent; n = n.parent)
@@ -208,17 +225,8 @@ export class StorageEmitter extends EmitterBase {
             return this.looksLikeStructPlace(node.expression);
         if (ts.isConditionalExpression(node))
             return this.looksLikeStructPlace(node.whenTrue) && this.looksLikeStructPlace(node.whenFalse);
-        const saved = { lines: this.lines.length, hoisted: this.hoisted.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
-        try {
-            const r = this.reporter.guard(() => this.ref(node));
-            return r?.type.kind === "struct";
-        }
-        finally {
-            this.lines.length = saved.lines;
-            this.hoisted.length = saved.hoisted; // a probed helper call may hoist declarations
-            this.temp = saved.temp;
-            this.reporter.diagnostics.length = saved.diagnostics;
-        }
+        const r = this.probe(() => this.ref(node));
+        return r?.type.kind === "struct";
     }
     /** `fixedArray<T, N>(fill)` as a local declaration. */
     localArray(init, c) {
@@ -591,6 +599,11 @@ export class StorageEmitter extends EmitterBase {
             const els = valueNode.elements;
             if (els.length > t.cap)
                 this.fail(valueNode, `${els.length} elements do not fit in ${typeName(t)}`);
+            // Empty: nothing reads the old list, so it is cleared in place (length 0, every slot zero).
+            if (els.length === 0) {
+                this.line(`ts_memzero(&${target.lv}, sizeof(${target.lv}));`);
+                return;
+            }
             const tmp = this.tmp("fv");
             this.line(`${fixedVecC(t)} ${tmp};`);
             this.line(`ts_memzero(&${tmp}, sizeof(${tmp}));`);
@@ -681,16 +694,7 @@ export class StorageEmitter extends EmitterBase {
     }
     /** The kind of storage an expression names (struct, array, dataEnum…), without emitting code or failing. */
     peekKind(node) {
-        const saved = { lines: this.lines.length, hoisted: this.hoisted.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
-        try {
-            return this.reporter.guard(() => this.ref(node))?.type.kind;
-        }
-        finally {
-            this.lines.length = saved.lines;
-            this.hoisted.length = saved.hoisted; // a probed helper call may hoist declarations
-            this.temp = saved.temp;
-            this.reporter.diagnostics.length = saved.diagnostics;
-        }
+        return this.probe(() => this.ref(node))?.type.kind;
     }
     place(node) {
         if (ts.isIdentifier(node)) {

package/dist/compiler/model.d.ts

@@ -423,6 +423,14 @@ export interface ProgramModel {
     helperDecls: Map<ts.Node, string>;
     /** Local closures (they read the enclosing function's variables): their declaration -> name; expanded where called. */
     closureDecls: Map<ts.Node, string>;
+    /**
+     * Functions that return a function (`function adder(n: u64): (x: u64) => u64 { return (x) => x + n; }`): no C
+     * function; a call binds the returned function, with the arguments, as a closure where it is made.
+     */
+    factories: Map<string, {
+        node: HelperNode;
+        imports: Map<string, string>;
+    }>;
     errors: ErrorDef[];
     /** Enum name -> member name -> error */
     errorEnums: Map<string, Map<string, ErrorDef>>;

package/dist/idlpublish.d.ts

@@ -25,7 +25,12 @@ export interface PublishOptions {
 /** Write (create or update) the IDL metadata account; returns its address. */
 export declare function publishIdl(chain: Chain, opts: PublishOptions): Promise<Address>;
 export declare function metadataAddress(program: Address, authority: Address | null): Promise<Address>;
-/** Read an IDL back (canonical, or the one `authority` wrote). */
+/** The most an IDL read from the chain may inflate to: compressed data can expand far past the account's size. */
+export declare const MAX_IDL_BYTES: number;
+/**
+ * Read an IDL back (canonical, or the one `authority` wrote). Only an IDL stored in the metadata account itself is
+ * read: one that links to a URL or points at another account is refused (nothing is fetched from where it points).
+ */
 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>;

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 { createHash } from "node:crypto";
+import { gunzipSync, inflateSync } from "node:zlib";
+import { Compression, DataSource, Encoding, Format, decodeData, fetchMaybeMetadata, findMetadataPda, packDirectData, writeMetadata, } from "@solana-program/program-metadata";
 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). */
@@ -111,15 +112,54 @@ function planFailure(e) {
 export async function metadataAddress(program, authority) {
     return (await findMetadataPda({ program, authority, seed: "idl" }))[0];
 }
-/** Read an IDL back (canonical, or the one `authority` wrote). */
+/** The most an IDL read from the chain may inflate to: compressed data can expand far past the account's size. */
+export const MAX_IDL_BYTES = 16 * 1024 * 1024;
+/** Decompress `data` (zlib or gzip), refusing output past MAX_IDL_BYTES. */
+function inflateCapped(data, gzip, what) {
+    try {
+        return (gzip ? gunzipSync : inflateSync)(data, { maxOutputLength: MAX_IDL_BYTES });
+    }
+    catch (e) {
+        if (e.code === "ERR_BUFFER_TOO_LARGE" || e instanceof RangeError)
+            throw new Error(`${what} inflates to more than ${MAX_IDL_BYTES / 1024 / 1024} MiB; refusing it`);
+        throw new Error(`${what} is not valid compressed data: ${e.message}`);
+    }
+}
+/**
+ * Read an IDL back (canonical, or the one `authority` wrote). Only an IDL stored in the metadata account itself is
+ * read: one that links to a URL or points at another account is refused (nothing is fetched from where it points).
+ */
 export async function fetchIdl(rpc, program, authority = null) {
-    return JSON.parse(await fetchMetadataContent(rpc, program, "idl", authority));
+    const at = await metadataAddress(program, authority);
+    const account = await fetchMaybeMetadata(rpc, at);
+    if (!account.exists)
+        throw new Error(`no IDL metadata account at ${at}`);
+    const m = account.data;
+    if (m.dataLength > m.data.length)
+        throw new Error(`the IDL metadata at ${at} is truncated`);
+    const content = (what) => {
+        const raw = new Uint8Array(m.data.subarray(0, m.dataLength));
+        const bytes = m.compression === Compression.None ? raw : inflateCapped(raw, m.compression === Compression.Gzip, what);
+        // Base58 decodes in quadratic time: only small contents.
+        if (m.encoding === Encoding.Base58 && bytes.length > 64 * 1024)
+            throw new Error(`${what} is too large for base58`);
+        return decodeData(bytes, m.encoding);
+    };
+    if (m.dataSource === DataSource.Url) {
+        const url = content(`the IDL link at ${at}`);
+        throw new Error(`the IDL at ${at} is not stored on chain but linked: ${JSON.stringify(url.slice(0, 200))}. Fetch it yourself and pass the file (typesol client <idl.json>)`);
+    }
+    if (m.dataSource !== DataSource.Direct)
+        throw new Error(`the IDL at ${at} is stored in another account (external data), which is not read`);
+    return JSON.parse(content(`the IDL at ${at}`));
 }
 /** 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" });
 }
+/** Anchor's account discriminator for IdlAccount: sha256("account:IdlAccount")[0..8]. */
+const IDL_ACCOUNT_DISCRIMINATOR = createHash("sha256").update("account:IdlAccount").digest().subarray(0, 8);
 /** 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();
@@ -129,10 +169,12 @@ export async function fetchAnchorIdl(rpc, program) {
     // 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");
+    if (!data.subarray(0, 8).equals(IDL_ACCOUNT_DISCRIMINATOR))
+        throw new Error("the account at Anchor's IDL address is not an IdlAccount");
     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"));
+    return JSON.parse(inflateCapped(data.subarray(44, 44 + len), false, "the Anchor IDL").toString("utf8"));
 }
 /**
  * A program's IDL from the chain: the canonical Program Metadata IDL (`typesol idl publish`, Codama) first, else

package/dist/portgen.js

@@ -152,7 +152,7 @@ export function generatePort(idl) {
         if (t.vec) {
             const inner = tsType(t.vec, where, at);
             if (where === "variant" || where === "struct" || (where === "account" && !last)) {
-                notes.push(`${at}: a Vec here (TypeSOL keeps a Vec only as an account's last field or as an argument); replaced by FixedArray, so the layout differs.`);
+                notes.push(`${at}: a Vec here (TypeSOL keeps Anchor's bytes for a growable Vec only as an account's last field or as an argument); replaced by FixedArray, so the layout differs.`);
                 return `${use("FixedArray")}<${inner}, 8> /* TODO: Anchor has a Vec here */`;
             }
             return `${use("Vec")}<${inner}>`;

package/dist/svmrpc.d.ts

@@ -8,7 +8,11 @@
  *   await counter.accounts.Counter.fetch(rpc, address);
  *
  * Transactions run as they are sent (confirmed at once). LiteSVM cannot list accounts, so `getProgramAccounts` scans
- * the accounts transactions sent through this connection named, plus those passed to `track`.
+ * the accounts transactions sent through this connection named, plus those passed to `track`. Subscriptions see the
+ * transactions sent through this connection: `logsNotifications` replays those sent so far (failed ones too, with
+ * `err` set), then each new one, as `{ mentions: [address] }` filters them; `accountNotifications` yields the account
+ * after each later transaction that names it. Errors are in the JSON shape RPC nodes return
+ * (`{ InstructionError: [0, { Custom: 6000 }] }`).
  */
 import { type Address, type Rpc, type RpcSubscriptions, type SolanaRpcApi, type SolanaRpcSubscriptionsApi } from "@solana/kit";
 import { type LiteSVM, type TransactionMetadata } from "litesvm";
@@ -23,4 +27,6 @@ export interface SvmConnection {
     /** Add accounts for `getProgramAccounts` to scan (accounts the transactions named are scanned already). */
     track(...addresses: Address[]): void;
 }
+/** A LiteSVM transaction error in the JSON shape RPC nodes return: `{ InstructionError: [0, { Custom: 6000 }] }`. */
+export declare function rpcError(err: unknown): unknown;
 export declare function svmConnection(svm: LiteSVM): SvmConnection;