@typesol/cli 0.24.0 → 0.25.0

package/runtime/typesol_rt.h

@@ -18,6 +18,7 @@
 #define TS_ERR_INSTRUCTION_NOT_FOUND 101   /* InstructionFallbackNotFound */
 #define TS_ERR_INSTRUCTION_DATA 102        /* InstructionDidNotDeserialize */
 #define TS_ERR_NOT_WRITABLE 3006           /* AccountNotMutable */
+#define TS_ERR_CONSTRAINT_MUT 2000         /* ConstraintMut */
 #define TS_ERR_CONSTRAINT 2001             /* ConstraintHasOne */
 #define TS_ERR_NOT_RENT_EXEMPT 2005        /* ConstraintRentExempt */
 #define TS_ERR_CONSTRAINT_SIGNER 2002      /* ConstraintSigner */
@@ -31,6 +32,8 @@
 #define TS_ERR_MINT_AUTHORITY 2016         /* ConstraintMintMintAuthority */
 #define TS_ERR_FREEZE_AUTHORITY 2017       /* ConstraintMintFreezeAuthority */
 #define TS_ERR_MINT_DECIMALS 2018          /* ConstraintMintDecimals */
+#define TS_ERR_TOKEN_TOKEN_PROGRAM 2021    /* ConstraintTokenTokenProgram */
+#define TS_ERR_MINT_TOKEN_PROGRAM 2022     /* ConstraintMintTokenProgram */
 #define TS_ERR_DUPLICATE_MUT 2040          /* ConstraintDuplicateMutableAccount */
 #define TS_ERR_ALREADY_INITIALIZED 3000    /* AccountDiscriminatorAlreadySet */
 #define TS_ERR_DISCRIMINATOR 3002          /* AccountDiscriminatorMismatch */
@@ -62,11 +65,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 {                               \
@@ -274,6 +278,7 @@ typedef struct {
   const SolPubkey *program_id;
   TsAccount *ka[TS_MAX_ACCOUNTS];             /* ka_num entries */
   SolAccountInfo infos[TS_MAX_ACCOUNTS];      /* scratch for CPI account lists (ts_invoke) */
+  uint64_t loaded_mut;                        /* bit i: ka[i] loaded with loadAccountMut (zeroed by the entrypoint of a program that uses it) */
 } TsParams;
 
 /*
@@ -409,6 +414,12 @@ static inline uint64_t ts_check_writable(const TsAccount *a) {
   if (!a->is_writable) TS_FAIL(TS_ERR_NOT_WRITABLE, "TypeSOL: account must be writable");
   return SUCCESS;
 }
+/* A Mut<…> parameter passed read-only: Anchor's `#[account(mut)]` (ConstraintMut). ts_check_writable is for accounts
+   the program makes writable at runtime (remaining accounts, CPI metas). */
+static inline uint64_t ts_check_mut(const TsAccount *a) {
+  if (!a->is_writable) TS_FAIL(TS_ERR_CONSTRAINT_MUT, "TypeSOL: account must be writable (mut)");
+  return SUCCESS;
+}
 
 static inline uint64_t ts_check_program_account(const TsAccount *a, const SolPubkey *program_id,
                                                 const uint8_t disc[8], uint64_t size) {
@@ -427,7 +438,7 @@ static inline uint64_t ts_check_vec_len(const TsAccount *a, uint64_t fixed, uint
   return SUCCESS;
 }
 
-/* No other account in the instruction may be the same account (for loadAccountMut). */
+/* No other account in the instruction may be the same account (remaining accounts written in place). */
 static inline uint64_t ts_check_unaliased(const TsParams *params, const TsAccount *a) {
   /* The loader passes each account once and marks repeats as duplicates, which share its record. */
   uint64_t seen = 0;
@@ -436,6 +447,18 @@ static inline uint64_t ts_check_unaliased(const TsParams *params, const TsAccoun
   return SUCCESS;
 }
 
+/* loadAccountMut: unaliased, and not already loaded mutably in this instruction. Two loads of the same slot would be
+   two writable views of one account, as two slots naming it would (read both, write both: the classic drain). */
+static inline uint64_t ts_claim_mut(TsParams *params, const TsAccount *a) {
+  uint64_t seen = 0, at = 0;
+  for (uint64_t i = 0; i < params->ka_num; i++)
+    if (params->ka[i] == a) seen++, at = i;
+  if (seen > 1) TS_FAIL(TS_ERR_DUPLICATE_MUT, "TypeSOL: account passed more than once");
+  if (params->loaded_mut >> at & 1) TS_FAIL(TS_ERR_DUPLICATE_MUT, "TypeSOL: account already loaded with loadAccountMut");
+  params->loaded_mut |= (uint64_t)1 << at;
+  return SUCCESS;
+}
+
 static inline uint64_t ts_check_address(const TsAccount *a, const SolPubkey *expected) {
   if (!ts_key_eq(&a->key, expected)) TS_FAIL(TS_ERR_WRONG_PROGRAM, "TypeSOL: unexpected program address");
   return SUCCESS;
@@ -503,6 +526,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 +586,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;
 }
 
@@ -1424,7 +1488,8 @@ static inline int64_t ts_le_i64(const uint8_t *p) {
 }
 
 /* Like get_price_no_older_than: fully verified, matching feed id, publish_time + max_age >= now. */
-static inline uint64_t ts_pyth_price(const TsAccount *a, const SolPubkey *feed, uint64_t max_age, int64_t *out) {
+/* expo: the exponent the caller scales by; checked when check_expo (a feed's exponent can change). */
+static inline uint64_t ts_pyth_price(const TsAccount *a, const SolPubkey *feed, uint64_t max_age, bool check_expo, int32_t expo, int64_t *out) {
   uint64_t m;
   bool full;
   TS_TRY(ts_pyth_message(a, &m, &full));
@@ -1436,6 +1501,11 @@ static inline uint64_t ts_pyth_price(const TsAccount *a, const SolPubkey *feed,
   int64_t deadline;
   if (__builtin_add_overflow(published, (int64_t)(max_age > INT64_MAX ? INT64_MAX : max_age), &deadline)) deadline = INT64_MAX;
   if (deadline < now) TS_FAIL(TS_ERR_ORACLE, "TypeSOL: Pyth price is too old");
+  if (check_expo) {
+    int32_t e;
+    ts_memcpy(&e, a->data + m + 48, 4);
+    if (e != expo) TS_FAIL(TS_ERR_ORACLE, "TypeSOL: Pyth exponent is not the expected one");
+  }
   *out = ts_le_i64(a->data + m + 32);
   return SUCCESS;
 }
@@ -1461,9 +1531,10 @@ static inline uint64_t ts_check_switchboard(const TsAccount *a, bool devnet) {
  * The feed's current result (an 18-decimal fixed-point i128) scaled to `decimals`, if it has samples
  * and was produced within `max_stale_slots` slots of now.
  */
-static inline uint64_t ts_switchboard_value(const TsAccount *a, uint64_t max_stale_slots, uint8_t decimals, int64_t *out) {
+static inline uint64_t ts_switchboard_value(const TsAccount *a, uint64_t max_stale_slots, uint8_t decimals, uint8_t min_samples, int64_t *out) {
   if (decimals > 18) TS_FAIL(TS_ERR_ORACLE, "TypeSOL: at most 18 decimals");
-  if (a->data[TS_SB_RESULT_SAMPLES] == 0) TS_FAIL(TS_ERR_ORACLE, "TypeSOL: Switchboard feed has no samples");
+  if (a->data[TS_SB_RESULT_SAMPLES] == 0 || a->data[TS_SB_RESULT_SAMPLES] < min_samples)
+    TS_FAIL(TS_ERR_ORACLE, "TypeSOL: Switchboard feed has too few samples");
   uint64_t clock[5] = {0};
   if (sol_get_clock_sysvar(clock) != SUCCESS) TS_FAIL(TS_ERR_SYSVAR, "TypeSOL: clock sysvar unavailable");
   uint64_t slot = (uint64_t)ts_le_i64(a->data + TS_SB_RESULT_SLOT);