@typesol/cli 0.17.0 → 0.19.0

package/package.json

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

package/runtime/typesol_rt.h

@@ -30,6 +30,7 @@
 #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 */
@@ -42,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 */
@@ -634,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 = ≎
+    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`
@@ -975,15 +1100,129 @@ static inline uint64_t ts_alloc(uint64_t n, uint8_t **out) {
   return SUCCESS;
 }
 
-static inline uint64_t ts_str_concat(TS_Str a, TS_Str b, TS_Str *out) {
+/* 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 */
+  uint64_t limb[8];
+  for (int i = 0; i < 8; i++) limb[i] = __builtin_bswap32(*(const ts_u32_unaligned *)(in + 4 * i)); /* big-endian words */
+  /* Digits are written as characters from the end of `buf`, five per pass; 32 bytes need at most 44. */
+  char buf[50];
+  uint64_t pos = sizeof(buf);
+  int start = 0;
+  while (start < 8 && limb[start] == 0) start++;
+  while (start < 8) {
+    uint64_t rem = 0;
+    /* One long-division pass from the first nonzero limb, unrolled. */
+#define TS_B58_STEP(i)                       \
+  {                                          \
+    uint64_t cur = (rem << 32) | limb[i];    \
+    uint64_t q = cur / D;                    \
+    rem = cur - q * D;                       \
+    limb[i] = q;                             \
+  }
+    switch (start) {
+      case 0: TS_B58_STEP(0) /* fallthrough */
+      case 1: TS_B58_STEP(1) /* fallthrough */
+      case 2: TS_B58_STEP(2) /* fallthrough */
+      case 3: TS_B58_STEP(3) /* fallthrough */
+      case 4: TS_B58_STEP(4) /* fallthrough */
+      case 5: TS_B58_STEP(5) /* fallthrough */
+      case 6: TS_B58_STEP(6) /* fallthrough */
+      default: TS_B58_STEP(7)
+    }
+#undef TS_B58_STEP
+    while (start < 8 && limb[start] == 0) start++;
+    uint64_t q;
+    q = rem / 58; buf[--pos] = digits[rem - q * 58]; rem = q;
+    q = rem / 58; buf[--pos] = digits[rem - q * 58]; rem = q;
+    q = rem / 58; buf[--pos] = digits[rem - q * 58]; rem = q;
+    q = rem / 58; buf[--pos] = digits[rem - q * 58]; rem = q;
+    buf[--pos] = digits[rem];
+  }
+  /* Leading zero digits of the number are not printed; each leading zero byte is a '1'. */
+  while (pos < sizeof(buf) && buf[pos] == '1') pos++;
+  uint64_t zeros = 0;
+  while (zeros < 32 && in[zeros] == 0) zeros++;
+  uint64_t len = sizeof(buf) - pos;
   uint8_t *p;
-  TS_TRY(ts_alloc(a.len + b.len, &p));
-  ts_memcpy(p, a.ptr, a.len);
-  ts_memcpy(p + a.len, b.ptr, b.len);
-  *out = ts_str(p, a.len + b.len);
+  TS_TRY(ts_alloc(zeros + len, &p));
+  for (uint64_t i = 0; i < zeros; i++) p[i] = '1';
+  ts_memcpy(p + zeros, buf + pos, len);
+  *out = ts_str(p, zeros + len);
   return SUCCESS;
 }
 
+/*
+ * `s += …` on a local string: the pieces are copied right after `s` when it ends where the heap's free space starts
+ * (it was the last thing allocated), and `s` grows in place; otherwise `s` and the pieces are joined into a new string.
+ * Other views of the old `s` keep their length, so they still read the same bytes. The bytes written are past the
+ * heap's top, where no view can point (ts_alloc is the only source of heap pointers and never hands out memory past
+ * the top), so no piece is overwritten while it is copied.
+ */
+static uint64_t ts_str_append_parts(TS_Str *s, const TS_Str *parts, uint64_t n) {
+  uint64_t *next = (uint64_t *)HEAP_START_ADDRESS;
+  uint64_t add = 0;
+  for (uint64_t i = 0; i < n; i++) add += parts[i].len;
+  if (*next != 0 && s->len > 0 && (uint64_t)(s->ptr + s->len) == HEAP_START_ADDRESS + *next && *next + add <= TS_HEAP_LENGTH) {
+    for (uint64_t i = 0; i < n; i++) {
+      ts_memcpy((uint8_t *)s->ptr + s->len, parts[i].ptr, parts[i].len);
+      s->len += parts[i].len;
+    }
+    *next += add;
+    return SUCCESS;
+  }
+  uint8_t *p;
+  TS_TRY(ts_alloc(s->len + add, &p));
+  ts_memcpy(p, s->ptr, s->len);
+  uint64_t at = s->len;
+  for (uint64_t i = 0; i < n; i++) {
+    ts_memcpy(p + at, parts[i].ptr, parts[i].len);
+    at += parts[i].len;
+  }
+  *s = ts_str(p, at);
+  return SUCCESS;
+}
+
+/* `s += b` (and `a + b`, with `s` a copy of `a`): the one-piece case of ts_str_append_parts. */
+static uint64_t ts_str_append(TS_Str *s, TS_Str b) {
+  uint64_t *next = (uint64_t *)HEAP_START_ADDRESS;
+  if (*next != 0 && s->len > 0 && (uint64_t)(s->ptr + s->len) == HEAP_START_ADDRESS + *next && *next + b.len <= TS_HEAP_LENGTH) {
+    ts_memcpy((uint8_t *)s->ptr + s->len, b.ptr, b.len);
+    *next += b.len;
+    s->len += b.len;
+    return SUCCESS;
+  }
+  uint8_t *p;
+  TS_TRY(ts_alloc(s->len + b.len, &p));
+  ts_memcpy(p, s->ptr, s->len);
+  ts_memcpy(p + s->len, b.ptr, b.len);
+  *s = ts_str(p, s->len + b.len);
+  return SUCCESS;
+}
+
+/* The pieces of a template literal, joined with one heap allocation and one copy each. */
+static uint64_t ts_str_join(const TS_Str *parts, uint64_t n, TS_Str *out) {
+  uint64_t total = 0;
+  for (uint64_t i = 0; i < n; i++) total += parts[i].len;
+  uint8_t *p;
+  TS_TRY(ts_alloc(total, &p));
+  uint64_t at = 0;
+  for (uint64_t i = 0; i < n; i++) {
+    ts_memcpy(p + at, parts[i].ptr, parts[i].len);
+    at += parts[i].len;
+  }
+  *out = ts_str(p, total);
+  return SUCCESS;
+}
+
+/* `a + b`: a new string (`a` grows in place when it is the newest heap string; its own view keeps its length). */
+static inline uint64_t ts_str_concat(TS_Str a, TS_Str b, TS_Str *out) {
+  *out = a;
+  return ts_str_append(out, b);
+}
+
 /* Decimal text of an integer, on the heap. */
 /* Copy a string's bytes to the heap (a stable value, independent of where the view pointed). */
 static inline uint64_t ts_str_copy(TS_Str a, TS_Str *out) {
@@ -1005,6 +1244,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;