@typesol/cli 0.15.0 → 0.17.0

package/runtime/typesol_rt.h

@@ -34,6 +34,7 @@
 #define TS_ERR_ALREADY_INITIALIZED 3000    /* AccountDiscriminatorAlreadySet */
 #define TS_ERR_DISCRIMINATOR 3002          /* AccountDiscriminatorMismatch */
 #define TS_ERR_ACCOUNT_TOO_SMALL 3003      /* AccountDidNotDeserialize */
+#define TS_ERR_DID_NOT_SERIALIZE 3004      /* AccountDidNotSerialize */
 #define TS_ERR_TOKEN_ACCOUNT 3003          /* AccountDidNotDeserialize (not an initialized token account) */
 #define TS_ERR_MINT 3003                   /* AccountDidNotDeserialize (not an initialized mint) */
 #define TS_ERR_NOT_ENOUGH_ACCOUNTS 3005    /* AccountNotEnoughKeys */
@@ -162,8 +163,11 @@ static inline TS_Str ts_str(const uint8_t *ptr, uint64_t len) {
 static inline bool ts_utf8_valid(const uint8_t *p, uint64_t n) {
   uint64_t i = 0;
   while (i < n) {
+    /* ASCII eight bytes at a time (no high bit set), then byte by byte up to the next multi-byte sequence. */
+    while (i + 8 <= n && (ts_ld64(p + i) & 0x8080808080808080ULL) == 0) i += 8;
+    while (i < n && p[i] < 0x80) i++;
+    if (i == n) break;
     uint8_t c = p[i];
-    if (c < 0x80) { i++; continue; }
     uint64_t len;
     uint32_t cp;
     if (c >= 0xc2 && c <= 0xdf) { len = 2; cp = c & 0x1f; }
@@ -670,16 +674,17 @@ static inline uint64_t ts_realloc(TsParams *params, TsAccount *payer, TsAccount
   return ts_resize(params, payer, acct, new_len, entry_len);
 }
 
+/* `space` for a new account; an existing one needs `min_space` (less for a @layout borsh account). */
 static inline uint64_t ts_create_pda_if_needed(TsParams *params, TsAccount *payer, TsAccount *acct,
                                                SolSignerSeed *seeds, int n, const uint8_t disc[8], uint64_t space,
-                                               uint8_t *bump_out, bool *created) {
+                                               uint64_t min_space, uint8_t *bump_out, bool *created) {
   if (ts_key_eq(&acct->owner, params->program_id)) {
     SolPubkey derived;
     uint8_t bump;
     if (ts_find_pda(seeds, n, params->program_id, &derived, &bump) != SUCCESS ||
         !ts_key_eq(&derived, &acct->key))
       TS_FAIL(TS_ERR_SEEDS, "TypeSOL: PDA seeds do not match account");
-    if (acct->data_len < space) TS_FAIL(TS_ERR_ACCOUNT_TOO_SMALL, "TypeSOL: account data too small");
+    if (acct->data_len < min_space) TS_FAIL(TS_ERR_ACCOUNT_TOO_SMALL, "TypeSOL: account data too small");
     if (!ts_mem_eq(acct->data, disc, 8)) TS_FAIL(TS_ERR_DISCRIMINATOR, "TypeSOL: account discriminator mismatch");
     *bump_out = bump;
     *created = false;
@@ -1209,17 +1214,33 @@ static inline uint64_t ts_metadata_address(const SolPubkey *mint, SolPubkey *out
   return SUCCESS;
 }
 
+static inline uint64_t ts_master_edition_address(const SolPubkey *mint, SolPubkey *out) {
+  SolSignerSeed seeds[4] = {{(const uint8_t *)"metadata", 8},
+                            {(const uint8_t *)&TS_MPL_METADATA_ID, 32},
+                            {(const uint8_t *)mint, 32},
+                            {(const uint8_t *)"edition", 7}};
+  uint8_t bump;
+  if (ts_find_pda(seeds, 4, &TS_MPL_METADATA_ID, out, &bump) != SUCCESS)
+    TS_FAIL(TS_ERR_SEEDS, "TypeSOL: cannot derive the master edition address");
+  return SUCCESS;
+}
+
 /*
  * Metaplex CreateMetadataAccountV3 (instruction 33): DataV2 { name, symbol, uri, seller_fee_basis_points u16,
- * creators None, collection None, uses None }, is_mutable bool, collection_details None.
+ * creators Option<Vec<Creator>>, collection Option<Collection>, uses None }, is_mutable bool, collection_details
+ * None, or Some(V1 { size: 0 }) when `sized_collection`.
+ * `creators` holds `ncreators` packed Creator records (address, verified, share: 34 bytes); ncreators < 0 is None.
+ * `collection` (NULL for None) is written unverified, as Metaplex requires at creation.
  * Accounts: metadata (w), mint, mint authority (s), payer (ws), update authority, system program.
  */
 static inline uint64_t ts_mpl_create_v3(TsParams *params, const TsAccount *program, TsAccount *metadata,
                                         TsAccount *mint, TsAccount *mint_authority, TsAccount *payer,
                                         TsAccount *update_authority, TsAccount *system, TS_Str name, TS_Str symbol,
-                                        TS_Str uri, uint16_t fee_bps, bool is_mutable, const SolSignerSeed *seeds, int n) {
+                                        TS_Str uri, uint16_t fee_bps, bool is_mutable, const uint8_t *creators, int ncreators,
+                                        const SolPubkey *collection, bool sized_collection, const SolSignerSeed *seeds, int n) {
   uint8_t *data;
-  TS_TRY(ts_alloc(1 + 12 + name.len + symbol.len + uri.len + 2 + 3 + 1 + 1, &data));
+  uint64_t ncr = ncreators > 0 ? (uint64_t)ncreators : 0;
+  TS_TRY(ts_alloc(1 + 12 + name.len + symbol.len + uri.len + 2 + (1 + 4 + 34 * ncr) + (1 + 33) + 1 + 1 + (1 + 9), &data));
   uint64_t at = 0;
   data[at++] = 33;
   ts_put_str(data, &at, name);
@@ -1227,11 +1248,35 @@ static inline uint64_t ts_mpl_create_v3(TsParams *params, const TsAccount *progr
   ts_put_str(data, &at, uri);
   ts_memcpy(data + at, &fee_bps, 2);
   at += 2;
-  data[at++] = 0; /* creators: None */
-  data[at++] = 0; /* collection: None */
+  if (ncreators < 0) {
+    data[at++] = 0; /* creators: None */
+  } else {
+    data[at++] = 1;
+    uint32_t count = (uint32_t)ncreators;
+    ts_memcpy(data + at, &count, 4);
+    at += 4;
+    ts_memcpy(data + at, creators, 34 * ncr);
+    at += 34 * ncr;
+  }
+  if (collection) {
+    data[at++] = 1;
+    data[at++] = 0; /* verified: false */
+    ts_memcpy(data + at, collection, 32);
+    at += 32;
+  } else {
+    data[at++] = 0; /* collection: None */
+  }
   data[at++] = 0; /* uses: None */
   data[at++] = is_mutable ? 1 : 0;
-  data[at++] = 0; /* collection_details: None */
+  if (sized_collection) {
+    /* collection_details: Some(V1 { size: 0 }): this NFT is a collection items can be verified into */
+    data[at++] = 1;
+    data[at++] = 0;
+    ts_memzero(data + at, 8);
+    at += 8;
+  } else {
+    data[at++] = 0; /* collection_details: None */
+  }
   bool ua_signs = update_authority->is_signer || ts_key_eq(&update_authority->key, &mint_authority->key);
   SolAccountMeta metas[6] = {{&metadata->key, true, false},          {&mint->key, false, false},
                              {&mint_authority->key, false, true},     {&payer->key, true, true},

package/ts-plugin/index.js

@@ -0,0 +1,112 @@
+// TypeScript language-service plugin: TypeSOL's own errors in the editor, next to TypeScript's.
+//
+//   programs/tsconfig.json: { "compilerOptions": { …, "plugins": [{ "name": "typesol/ts-plugin" }] } }
+//
+// For each program entry of the project (typesol.json), once TypeScript itself reports no errors, it runs
+// `typesol check --json --stdin` on the editor's text (unsaved changes included) and shows what the compiler refuses
+// (an unsupported construct, a missing account constraint…) at its line and column. Editors load tsconfig plugins
+// from the workspace's TypeScript (VS Code: "TypeScript: Select TypeScript Version" → "Use Workspace Version").
+// CommonJS on purpose: tsserver loads plugins with require().
+"use strict";
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const CLI = path.join(__dirname, "..", "dist", "cli.js");
+const CODE = 9900;
+
+/** The program entry files of the typesol.json at or above `dir` (absolute), or an empty set. */
+function entriesNear(dir) {
+  for (let d = dir; ; d = path.dirname(d)) {
+    const config = path.join(d, "typesol.json");
+    if (fs.existsSync(config)) {
+      try {
+        const programs = JSON.parse(fs.readFileSync(config, "utf8")).programs || {};
+        return new Set(Object.values(programs).map((p) => path.resolve(d, typeof p === "string" ? p : p.path)));
+      } catch {
+        return new Set();
+      }
+    }
+    if (path.dirname(d) === d) return new Set();
+  }
+}
+
+function init({ typescript: ts }) {
+  function create(info) {
+    const ls = info.languageService;
+    const log = (m) => info.project.projectService.logger.info(`[typesol] ${m}`);
+    const cache = new Map(); // fileName -> { text, found }
+
+    /** The entry's text plus the modification times of the .ts files beside it (its imports usually live there). */
+    function key(fileName, sf) {
+      const dir = path.dirname(path.resolve(fileName));
+      let stamps = "";
+      try {
+        for (const f of fs.readdirSync(dir).sort())
+          if (f.endsWith(".ts") && path.join(dir, f) !== path.resolve(fileName)) stamps += `${f}:${fs.statSync(path.join(dir, f)).mtimeMs};`;
+      } catch {
+        stamps = "";
+      }
+      return `${stamps}\n${sf.text}`;
+    }
+
+    function typesolDiagnostics(fileName, sf) {
+      const k = key(fileName, sf);
+      const hit = cache.get(fileName);
+      if (hit && hit.key === k) return hit.found;
+      let found = [];
+      try {
+        const out = execFileSync(process.execPath, [CLI, "check", fileName, "--json", "--stdin"], {
+          input: sf.text,
+          encoding: "utf8",
+          timeout: 15000,
+          // tsserver may run inside an editor's Electron: make it behave as plain Node for the child.
+          env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" },
+          stdio: ["pipe", "pipe", "pipe"],
+        });
+        found = JSON.parse(out).diagnostics;
+      } catch (e) {
+        // Exit 1 with JSON on stdout means diagnostics; anything else is a crash worth logging, not showing.
+        try {
+          found = JSON.parse(String(e.stdout)).diagnostics;
+        } catch {
+          log(`check failed for ${fileName}: ${e.message}`);
+          found = [];
+        }
+      }
+      cache.set(fileName, { key: k, found });
+      return found;
+    }
+
+    const proxy = Object.create(null);
+    for (const k of Object.keys(ls)) proxy[k] = (...args) => ls[k](...args);
+    proxy.getSemanticDiagnostics = (fileName) => {
+      const prior = ls.getSemanticDiagnostics(fileName);
+      if (prior.some((d) => d.category === ts.DiagnosticCategory.Error)) return prior; // TypeScript's errors first
+      if (!entriesNear(path.dirname(path.resolve(fileName))).has(path.resolve(fileName))) return prior;
+      const sf = ls.getProgram() && ls.getProgram().getSourceFile(fileName);
+      if (!sf) return prior;
+      const own = typesolDiagnostics(fileName, sf)
+        .filter((d) => path.resolve(d.file) === path.resolve(fileName))
+        .map((d) => {
+          const line = Math.max(0, Math.min(d.line - 1, sf.getLineStarts().length - 1));
+          const start = Math.min(sf.getPositionOfLineAndCharacter(line, 0) + Math.max(0, d.column - 1), sf.end);
+          const word = /^[\w$]+/.exec(sf.text.slice(start));
+          return {
+            file: sf,
+            start,
+            length: word ? word[0].length : 1,
+            messageText: d.message,
+            category: ts.DiagnosticCategory.Error,
+            code: CODE,
+            source: "typesol",
+          };
+        });
+      return [...prior, ...own];
+    };
+    return proxy;
+  }
+  return { create };
+}
+
+module.exports = init;

package/ts-plugin/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "main": "index.js"
+}