@typesol/cli 0.16.0 → 0.18.0

package/package.json

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

package/runtime/typesol_rt.h

@@ -30,10 +30,12 @@
 #define TS_ERR_TOKEN_OWNER 2015            /* ConstraintTokenOwner */
 #define TS_ERR_MINT_AUTHORITY 2016         /* ConstraintMintMintAuthority */
 #define TS_ERR_FREEZE_AUTHORITY 2017       /* ConstraintMintFreezeAuthority */
+#define TS_ERR_MINT_DECIMALS 2018          /* ConstraintMintDecimals */
 #define TS_ERR_DUPLICATE_MUT 2040          /* ConstraintDuplicateMutableAccount */
 #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 */
@@ -41,6 +43,7 @@
 #define TS_ERR_WRONG_PROGRAM 3008          /* InvalidProgramId */
 #define TS_ERR_NOT_EXECUTABLE 3009         /* InvalidProgramExecutable */
 #define TS_ERR_NOT_SIGNER 3010             /* AccountNotSigner */
+#define TS_ERR_NOT_SYSTEM_OWNED 3011       /* AccountNotSystemOwned */
 #define TS_ERR_NOT_INITIALIZED 3012        /* AccountNotInitialized */
 #define TS_ERR_REALLOC 3016                /* AccountReallocExceedsLimit */
 #define TS_ERR_CAST 4102                   /* InvalidNumericConversion */
@@ -162,8 +165,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; }
@@ -630,6 +636,129 @@ static inline uint64_t ts_create_pda(TsParams *params, TsAccount *payer, TsAccou
   return SUCCESS;
 }
 
+/*
+ * Create `acct` with `space` bytes owned by `owner` (a token program), funded by `payer`: a PDA of this program when
+ * `n` > 0 (seeds without the bump; a pre-funded address is topped up, allocated and assigned), otherwise a new keypair
+ * account that signed the transaction. Writes the bump (0 for a keypair).
+ */
+static inline uint64_t ts_create_owned(TsParams *params, TsAccount *payer, TsAccount *acct, SolSignerSeed *seeds, int n,
+                                       const SolPubkey *owner, uint64_t space, uint8_t *bump_out) {
+  uint8_t bump = 0;
+  if (n > 0) {
+    SolPubkey derived;
+    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");
+    seeds[n].addr = &bump;
+    seeds[n].len = 1;
+  } else if (!acct->is_signer) {
+    TS_FAIL(TS_ERR_NOT_SIGNER, "TypeSOL: a new keypair account must sign");
+  }
+  if (acct->data_len != 0 || !ts_key_eq(&acct->owner, &TS_SYSTEM_PROGRAM_ID))
+    TS_FAIL(TS_ERR_ALREADY_INITIALIZED, "TypeSOL: account already exists");
+  uint64_t lamports;
+  TS_TRY(ts_minimum_balance(space, &lamports));
+  SolSignerSeeds signer = {seeds, (uint64_t)(n + 1)};
+  SolSignerSeeds *signers = n > 0 ? &signer : NULL;
+  int nsigners = n > 0 ? 1 : 0;
+  if (acct->lamports == 0) {
+    uint8_t data[52];
+    uint32_t tag = 0; /* CreateAccount */
+    ts_memcpy(data, &tag, 4);
+    ts_memcpy(data + 4, &lamports, 8);
+    ts_memcpy(data + 12, &space, 8);
+    ts_memcpy(data + 20, owner, 32);
+    SolAccountMeta metas[2] = {{&payer->key, true, true}, {&acct->key, true, true}};
+    SolInstruction ix = {(SolPubkey *)&TS_SYSTEM_PROGRAM_ID, metas, 2, data, sizeof(data)};
+    TS_TRY(ts_invoke(params, &ix, signers, nsigners));
+  } else {
+    if (acct->lamports < lamports) TS_TRY(ts_system_transfer(params, payer, acct, lamports - acct->lamports));
+    uint8_t alloc[12];
+    uint32_t alloc_tag = 8; /* Allocate */
+    ts_memcpy(alloc, &alloc_tag, 4);
+    ts_memcpy(alloc + 4, &space, 8);
+    SolAccountMeta one[1] = {{&acct->key, true, true}};
+    SolInstruction alloc_ix = {(SolPubkey *)&TS_SYSTEM_PROGRAM_ID, one, 1, alloc, sizeof(alloc)};
+    TS_TRY(ts_invoke(params, &alloc_ix, signers, nsigners));
+    uint8_t assign[36];
+    uint32_t assign_tag = 1; /* Assign */
+    ts_memcpy(assign, &assign_tag, 4);
+    ts_memcpy(assign + 4, owner, 32);
+    SolInstruction assign_ix = {(SolPubkey *)&TS_SYSTEM_PROGRAM_ID, one, 1, assign, sizeof(assign)};
+    TS_TRY(ts_invoke(params, &assign_ix, signers, nsigners));
+  }
+  *bump_out = bump;
+  return SUCCESS;
+}
+
+/* InitializeMint2: decimals, mint authority, optional freeze authority. */
+static inline uint64_t ts_token_init_mint(TsParams *params, TsAccount *tp, TsAccount *mint, uint8_t decimals,
+                                          const SolPubkey *authority, const SolPubkey *freeze) {
+  uint8_t data[67];
+  data[0] = 20;
+  data[1] = decimals;
+  ts_memcpy(data + 2, authority, 32);
+  data[34] = freeze ? 1 : 0;
+  if (freeze) ts_memcpy(data + 35, freeze, 32);
+  SolAccountMeta metas[1] = {{&mint->key, true, false}};
+  SolInstruction ix = {(SolPubkey *)&tp->key, metas, 1, data, freeze ? 67 : 35};
+  return ts_invoke(params, &ix, NULL, 0);
+}
+
+/* Bytes a token account of `mint` needs: 165 under SPL Token, Token-2022's GetAccountDataSize answer otherwise
+   (a mint's extensions can add account extensions). */
+static inline uint64_t ts_token_account_space(TsParams *params, TsAccount *tp, TsAccount *mint, uint64_t *space) {
+  if (ts_key_eq(&tp->key, &TS_TOKEN_PROGRAM_ID)) {
+    *space = TS_TOKEN_ACCOUNT_LEN;
+    return SUCCESS;
+  }
+  uint8_t data[1] = {21}; /* GetAccountDataSize */
+  SolAccountMeta metas[1] = {{&mint->key, false, false}};
+  SolInstruction ix = {(SolPubkey *)&tp->key, metas, 1, data, 1};
+  TS_TRY(ts_invoke(params, &ix, NULL, 0));
+  SolPubkey from;
+  uint64_t size = 0;
+  if (sol_get_return_data((uint8_t *)&size, 8, &from) != 8 || !ts_key_eq(&from, &tp->key))
+    TS_FAIL(TS_ERR_TOKEN_ACCOUNT, "TypeSOL: the token program did not report an account size");
+  *space = size;
+  return SUCCESS;
+}
+
+/* InitializeAccount3: `acct` holds `mint` tokens for `owner`. */
+static inline uint64_t ts_token_init_account(TsParams *params, TsAccount *tp, TsAccount *acct, TsAccount *mint, const SolPubkey *owner) {
+  uint8_t data[33];
+  data[0] = 18;
+  ts_memcpy(data + 1, owner, 32);
+  SolAccountMeta metas[2] = {{&acct->key, true, false}, {&mint->key, false, false}};
+  SolInstruction ix = {(SolPubkey *)&tp->key, metas, 2, data, sizeof(data)};
+  return ts_invoke(params, &ix, NULL, 0);
+}
+
+/* An existing account `init_if_needed` found: the PDA it must be (when seeds are given) and owned by token program `tp`. */
+static inline uint64_t ts_token_existing(TsParams *params, TsAccount *acct, TsAccount *tp, SolSignerSeed *seeds, int n,
+                                         uint8_t *bump_out) {
+  *bump_out = 0;
+  if (n > 0) {
+    SolPubkey derived;
+    if (ts_find_pda(seeds, n, params->program_id, &derived, bump_out) != SUCCESS || !ts_key_eq(&derived, &acct->key))
+      TS_FAIL(TS_ERR_SEEDS, "TypeSOL: PDA seeds do not match account");
+  }
+  if (!ts_key_eq(&acct->owner, &tp->key)) TS_FAIL(TS_ERR_WRONG_OWNER, "TypeSOL: account not owned by the token program");
+  return SUCCESS;
+}
+
+/* An existing mint must have these decimals and authorities (Anchor's mint:: constraints on init_if_needed). */
+static inline uint64_t ts_check_mint_is(const TsAccount *mint, uint8_t decimals, const SolPubkey *authority, const SolPubkey *freeze) {
+  const uint8_t *d = mint->data;
+  uint32_t tag;
+  ts_memcpy(&tag, d, 4);
+  if (tag != 1 || !ts_key_eq((const SolPubkey *)(d + 4), authority)) TS_FAIL(TS_ERR_MINT_AUTHORITY, "TypeSOL: mint authority does not match");
+  ts_memcpy(&tag, d + 46, 4);
+  if (freeze ? (tag != 1 || !ts_key_eq((const SolPubkey *)(d + 50), freeze)) : tag != 0)
+    TS_FAIL(TS_ERR_FREEZE_AUTHORITY, "TypeSOL: freeze authority does not match");
+  if (d[44] != decimals) TS_FAIL(TS_ERR_MINT_DECIMALS, "TypeSOL: mint decimals do not match");
+  return SUCCESS;
+}
+
 /*
  * Resize a program-owned account to `new_len` bytes (realloc). Growth is limited to 10 KiB past the
  * size the account had when the instruction started; new bytes are zeroed. When growing, `payer`
@@ -670,16 +799,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;
@@ -970,6 +1100,44 @@ static inline uint64_t ts_alloc(uint64_t n, uint8_t **out) {
   return SUCCESS;
 }
 
+/* Base58 text of a 32-byte value (a Pubkey or Hash in a template), on the heap. The value is eight big-endian u32
+   limbs divided by 58^5 at a time, so each pass gives five digits with one 64-bit division per limb. */
+static uint64_t ts_base58_32(const uint8_t *in, TS_Str *out) {
+  static const char digits[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  const uint64_t D = 656356768ULL; /* 58^5 */
+  uint32_t limb[8];
+  for (int i = 0; i < 8; i++)
+    limb[i] = (uint32_t)in[4 * i] << 24 | (uint32_t)in[4 * i + 1] << 16 | (uint32_t)in[4 * i + 2] << 8 | (uint32_t)in[4 * i + 3];
+  uint8_t rev[50]; /* base-58 digits, least significant first; 32 bytes need at most 44 */
+  uint64_t len = 0;
+  int start = 0;
+  while (start < 8 && limb[start] == 0) start++;
+  while (start < 8) {
+    uint64_t rem = 0;
+    for (int i = start; i < 8; i++) {
+      uint64_t cur = (rem << 32) | limb[i];
+      uint64_t q = cur / D;
+      rem = cur - q * D;
+      limb[i] = (uint32_t)q;
+    }
+    while (start < 8 && limb[start] == 0) start++;
+    for (int k = 0; k < 5; k++) {
+      uint64_t q = rem / 58;
+      rev[len++] = (uint8_t)(rem - q * 58);
+      rem = q;
+    }
+  }
+  while (len > 0 && rev[len - 1] == 0) len--;
+  uint64_t zeros = 0;
+  while (zeros < 32 && in[zeros] == 0) zeros++;
+  uint8_t *p;
+  TS_TRY(ts_alloc(zeros + len, &p));
+  for (uint64_t i = 0; i < zeros; i++) p[i] = '1';
+  for (uint64_t j = 0; j < len; j++) p[zeros + j] = (uint8_t)digits[rev[len - 1 - j]];
+  *out = ts_str(p, zeros + len);
+  return SUCCESS;
+}
+
 static inline uint64_t ts_str_concat(TS_Str a, TS_Str b, TS_Str *out) {
   uint8_t *p;
   TS_TRY(ts_alloc(a.len + b.len, &p));
@@ -1000,6 +1168,41 @@ static inline uint64_t ts_mul_div(uint64_t a, uint64_t b, uint64_t c, bool ceil,
   return SUCCESS;
 }
 
+/* floor or ceil of a * b / c for u128 through a 256-bit product; fails on c == 0 or a result above u128. */
+static uint64_t ts_mul_div_u128(unsigned __int128 a, unsigned __int128 b, unsigned __int128 c, bool ceil, unsigned __int128 *out) {
+  if (c == 0) TS_FAIL(TS_ERR_DIV_ZERO, "TypeSOL: division by zero");
+  const unsigned __int128 M = (unsigned __int128)UINT64_MAX;
+  unsigned __int128 a0 = a & M, a1 = a >> 64, b0 = b & M, b1 = b >> 64;
+  unsigned __int128 p00 = a0 * b0, p01 = a0 * b1, p10 = a1 * b0, p11 = a1 * b1;
+  unsigned __int128 mid = (p00 >> 64) + (p01 & M) + (p10 & M);
+  unsigned __int128 lo = (p00 & M) | (mid << 64);
+  unsigned __int128 hi = p11 + (p01 >> 64) + (p10 >> 64) + (mid >> 64);
+  unsigned __int128 q, r;
+  if (hi == 0) {
+    q = lo / c;
+    r = lo % c;
+  } else {
+    /* The quotient fits in 128 bits only when hi < c; then long division of hi:lo by c, one bit at a time. */
+    if (hi >= c) TS_FAIL(TS_ERR_OVERFLOW, "TypeSOL: arithmetic overflow");
+    q = 0;
+    r = hi;
+    for (int i = 127; i >= 0; i--) {
+      bool carry = (r >> 127) != 0;
+      r = (r << 1) | ((lo >> i) & 1);
+      if (carry || r >= c) {
+        r -= c;
+        q |= (unsigned __int128)1 << i;
+      }
+    }
+  }
+  if (ceil && r != 0) {
+    if (q == ~(unsigned __int128)0) TS_FAIL(TS_ERR_OVERFLOW, "TypeSOL: arithmetic overflow");
+    q += 1;
+  }
+  *out = q;
+  return SUCCESS;
+}
+
 /* Integer square roots (floor), by Newton's method from an over-estimate. */
 static inline uint64_t ts_isqrt_u64(uint64_t x) {
   if (x < 2) return x;
@@ -1209,9 +1412,21 @@ 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 Option<Vec<Creator>>, collection Option<Collection>, 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.
@@ -1220,10 +1435,10 @@ static inline uint64_t ts_mpl_create_v3(TsParams *params, const TsAccount *progr
                                         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 uint8_t *creators, int ncreators,
-                                        const SolPubkey *collection, const SolSignerSeed *seeds, int n) {
+                                        const SolPubkey *collection, bool sized_collection, const SolSignerSeed *seeds, int n) {
   uint8_t *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, &data));
+  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);
@@ -1251,7 +1466,15 @@ static inline uint64_t ts_mpl_create_v3(TsParams *params, const TsAccount *progr
   }
   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},