toilscript 0.0.1

package/std/assembly/date.ts

@@ -0,0 +1,375 @@
+import { E_INVALIDDATE } from "util/error";
+import { Date as Date_binding } from "./bindings/dom";
+
+// @ts-ignore: decorator
+@inline const
+  MILLIS_PER_DAY    = 1000 * 60 * 60 * 24,
+  MILLIS_PER_HOUR   = 1000 * 60 * 60,
+  MILLIS_PER_MINUTE = 1000 * 60,
+  MILLIS_PER_SECOND = 1000,
+
+  YEARS_PER_EPOCH = 400,
+  DAYS_PER_EPOCH = 146097,
+  EPOCH_OFFSET = 719468, // Jan 1, 1970
+  MILLIS_LIMIT = 8640000000000000;
+
+// ymdFromEpochDays returns values via globals to avoid allocations
+// @ts-ignore: decorator
+@lazy let _month: i32, _day: i32;
+
+export class Date {
+  private year: i32 = 0;
+  private month: i32 = 0;
+  private day: i32 = 0;
+
+  @inline static UTC(
+    year: i32,
+    month: i32 = 0,
+    day: i32 = 1,
+    hour: i32 = 0,
+    minute: i32 = 0,
+    second: i32 = 0,
+    millisecond: i32 = 0
+  ): i64 {
+    if (year >= 0 && year <= 99) year += 1900;
+    let ms = epochMillis(year, month + 1, day, hour, minute, second, millisecond);
+    if (invalidDate(ms)) throw new RangeError(E_INVALIDDATE);
+    return ms;
+  }
+
+  @inline static now(): i64 {
+    return <i64>Date_binding.now();
+  }
+
+  // It can parse only ISO 8601 inputs like YYYY-MM-DDTHH:MM:SS.000Z
+  @inline static parse(dateString: string): Date {
+    return this.fromString(dateString);
+  }
+
+  static fromString(dateTimeString: string): Date {
+    if (!dateTimeString.length) throw new RangeError(E_INVALIDDATE);
+    var
+      hour: i32 = 0,
+      min: i32 = 0,
+      sec: i32 = 0,
+      ms: i32 = 0,
+      offsetMs: i32 = 0;
+
+    let dateString = dateTimeString;
+    let posT = dateTimeString.indexOf("T");
+    if (~posT) {
+      // includes a time component
+      let timeString: string;
+      dateString = dateTimeString.substring(0, posT);
+      timeString = dateTimeString.substring(posT + 1);
+      
+      // might end with an offset ("Z", "+05:30", "-08:00", etc.)
+      for (let i = timeString.length - 1; i >= 0; i--) {
+        let c = timeString.charCodeAt(i);
+        if (c == 90) { // Z
+          timeString = timeString.substring(0, i);
+          break;
+        } else if (c == 43 || c == 45) { // + or -
+          if (i == timeString.length - 1) {
+            throw new RangeError(E_INVALIDDATE);
+          }
+
+          let posColon = timeString.indexOf(":", i + 1);
+          if (~posColon) {
+            let offsetHours = i32.parse(timeString.substring(i + 1, posColon));
+            let offsetMinutes = i32.parse(timeString.substring(posColon + 1));
+            offsetMs = (offsetHours * 60 + offsetMinutes) * MILLIS_PER_MINUTE;
+          } else {
+            let offsetHours = i32.parse(timeString.substring(i + 1));
+            offsetMs = offsetHours * MILLIS_PER_HOUR;
+          }    
+    
+          if (c == 45) offsetMs = -offsetMs; // negative offset
+          timeString = timeString.substring(0, i);
+          break;
+        }
+      }
+
+      // parse the HH:MM:SS component
+      let timeParts = timeString.split(":");
+      let len = timeParts.length;
+      if (len <= 1) throw new RangeError(E_INVALIDDATE);
+
+      hour = i32.parse(timeParts[0]);
+      min  = i32.parse(timeParts[1]);
+      if (len >= 3) {
+        let secAndFrac = timeParts[2];
+        let posDot = secAndFrac.indexOf(".");
+        if (~posDot) {
+          // includes fractional seconds (truncate to milliseconds)
+          sec = i32.parse(secAndFrac.substring(0, posDot));
+          ms  = i32.parse(secAndFrac.substr(posDot + 1, 3).padEnd(3, "0"));
+        } else {
+          sec = i32.parse(secAndFrac);
+        }
+      }
+    }
+
+    // parse the YYYY-MM-DD component
+    let parts = dateString.split("-");
+    let year = i32.parse(parts[0]);
+    let month = 1, day = 1;
+    let len = parts.length;
+    if (len >= 2) {
+      month = i32.parse(parts[1]);
+      if (len >= 3) {
+        day = i32.parse(parts[2]);
+      }
+    }
+
+    return new Date(epochMillis(year, month, day, hour, min, sec, ms) - offsetMs);
+  }
+
+  constructor(private epochMillis: i64) {
+    // this differs from JavaScript which prefer return NaN or "Invalid Date" string
+    // instead throwing exception.
+    if (invalidDate(epochMillis)) throw new RangeError(E_INVALIDDATE);
+
+    this.year = dateFromEpoch(epochMillis);
+    this.month = _month;
+    this.day = _day;
+  }
+
+  @inline getTime(): i64 {
+    return this.epochMillis;
+  }
+
+  setTime(time: i64): i64 {
+    if (invalidDate(time)) throw new RangeError(E_INVALIDDATE);
+
+    this.epochMillis = time;
+    this.year = dateFromEpoch(time);
+    this.month = _month;
+    this.day = _day;
+
+    return time;
+  }
+
+  @inline getUTCFullYear(): i32 {
+    return this.year;
+  }
+
+  @inline getUTCMonth(): i32 {
+    return this.month - 1;
+  }
+
+  @inline getUTCDate(): i32 {
+    return this.day;
+  }
+
+  @inline getUTCDay(): i32 {
+    return dayOfWeek(this.year, this.month, this.day);
+  }
+
+  getUTCHours(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_DAY)) / MILLIS_PER_HOUR;
+  }
+
+  getUTCMinutes(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_HOUR)) / MILLIS_PER_MINUTE;
+  }
+
+  getUTCSeconds(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_MINUTE)) / MILLIS_PER_SECOND;
+  }
+
+  getUTCMilliseconds(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_SECOND));
+  }
+
+  setUTCMilliseconds(millis: i32): void {
+    this.setTime(this.epochMillis + (millis - this.getUTCMilliseconds()));
+  }
+
+  setUTCSeconds(seconds: i32): void {
+    this.setTime(this.epochMillis + (seconds - this.getUTCSeconds()) * MILLIS_PER_SECOND);
+  }
+
+  setUTCMinutes(minutes: i32): void {
+    this.setTime(this.epochMillis + (minutes - this.getUTCMinutes()) * MILLIS_PER_MINUTE);
+  }
+
+  setUTCHours(hours: i32): void {
+    this.setTime(this.epochMillis + (hours - this.getUTCHours()) * MILLIS_PER_HOUR);
+  }
+
+  setUTCDate(day: i32): void {
+    if (this.day == day) return;
+    this.setTime(join(this.year, this.month, day, this.epochMillis));
+  }
+
+  setUTCMonth(month: i32, day: i32 = this.day): void {
+    if (this.month == month + 1) return;
+    this.setTime(join(this.year, month + 1, day, this.epochMillis));
+  }
+
+  setUTCFullYear(year: i32): void {
+    if (this.year == year) return;
+    this.setTime(join(year, this.month, this.day, this.epochMillis));
+  }
+
+  toISOString(): string {
+    // TODO: add more low-level helper which combine toString and padStart without extra allocation
+
+    let yr = this.year;
+    let isNeg = yr < 0;
+    let year = (isNeg || yr >= 10000)
+      ? (isNeg ? "-" : "+") + stringify(abs(yr), 6)
+      : stringify(yr, 4);
+    let month = stringify(this.month, 2);
+    let day = stringify(this.day);
+    let hours = stringify(this.getUTCHours());
+    let mins = stringify(this.getUTCMinutes());
+    let secs = stringify(this.getUTCSeconds());
+    let ms = stringify(this.getUTCMilliseconds(), 3);
+
+    return `${year}-${month}-${day}T${hours}:${mins}:${secs}.${ms}Z`;
+  }
+
+  toUTCString(): string {
+    const
+      weeks: StaticArray<string> = [
+        "Sun, ", "Mon, ", "Tue, ", "Wed, ", "Thu, ", "Fri, ", "Sat, "
+      ],
+      months: StaticArray<string> = [
+        " Jan ", " Feb ", " Mar ", " Apr ", " May ", " Jun ",
+        " Jul ", " Aug ", " Sep ", " Oct ", " Nov ", " Dec "
+      ];
+
+    let mo = this.month;
+    let da = this.day;
+    let yr = this.year;
+    let wd = dayOfWeek(yr, mo, da);
+    let year = stringify(abs(yr), 4);
+    let month = unchecked(months[mo - 1]);
+    let week = unchecked(weeks[wd]);
+    let day = stringify(da);
+    let hours = stringify(this.getUTCHours());
+    let mins = stringify(this.getUTCMinutes());
+    let secs = stringify(this.getUTCSeconds());
+
+    return `${week}${day}${month}${yr < 0 ? "-" : ""}${year} ${hours}:${mins}:${secs} GMT`;
+  }
+
+  toDateString(): string {
+    // TODO: use u64 static data instead 4 chars
+    // also use stream itoa variants.
+    const
+      weeks: StaticArray<string> = [
+        "Sun ", "Mon ", "Tue ", "Wed ", "Thu ", "Fri ", "Sat "
+      ],
+      months: StaticArray<string> = [
+        "Jan ", "Feb ", "Mar ", "Apr ", "May ", "Jun ",
+        "Jul ", "Aug ", "Sep ", "Oct ", "Nov ", "Dec "
+      ];
+
+    let mo = this.month;
+    let da = this.day;
+    let yr = this.year;
+    let wd = dayOfWeek(yr, mo, da);
+    let year = stringify(abs(yr), 4);
+    let month = unchecked(months[mo - 1]);
+    let week = unchecked(weeks[wd]);
+    let day = stringify(da);
+
+    return `${week}${month}${day}${yr < 0 ? " -" : " "}${year}`;
+  }
+
+  // Note: it uses UTC time instead local time (without timezone offset)
+  toTimeString(): string {
+    let hours = stringify(this.getUTCHours());
+    let mins = stringify(this.getUTCMinutes());
+    let secs = stringify(this.getUTCSeconds());
+    // TODO: add timezone
+    return `${hours}:${mins}:${secs}`;
+  }
+
+  // Note: it uses UTC datetime instead local datetime (without timezone offset)
+  toString(): string {
+    return `${this.toDateString()} ${this.toTimeString()}`;
+  }
+}
+
+function epochMillis(
+  year: i32,
+  month: i32,
+  day: i32,
+  hour: i32,
+  minute: i32,
+  second: i32,
+  milliseconds: i32
+): i64 {
+  return (
+    daysSinceEpoch(year, month, day) * MILLIS_PER_DAY +
+    hour * MILLIS_PER_HOUR +
+    minute * MILLIS_PER_MINUTE +
+    second * MILLIS_PER_SECOND +
+    milliseconds
+  );
+}
+
+// @ts-ignore: decorator
+@inline function floorDiv<T extends number>(a: T, b: T): T {
+  return (a - (a < 0 ? b - 1 : 0)) / b as T;
+}
+
+// @ts-ignore: decorator
+@inline function euclidRem<T extends number>(a: T, b: T): T {
+  let m = a % b;
+  return m + (m < 0 ? b : 0) as T;
+}
+
+function invalidDate(millis: i64): bool {
+  // @ts-ignore
+  return (millis < -MILLIS_LIMIT) | (millis > MILLIS_LIMIT);
+}
+
+// Based on "Euclidean Affine Functions and Applications to Calendar Algorithms"
+// Paper: https://arxiv.org/pdf/2102.06959.pdf
+function dateFromEpoch(ms: i64): i32 {
+  let da = (<i32>floorDiv(ms, MILLIS_PER_DAY) * 4 + EPOCH_OFFSET * 4) | 3;
+  let q0 = floorDiv(da, DAYS_PER_EPOCH); // [0, 146096]
+  let r1 = <u32>da - q0 * DAYS_PER_EPOCH;
+  let u1 = u64(r1 | 3) * 2939745;
+  let dm1 = <u32>u1 / 11758980;
+  let n1 = 2141 * dm1 + 197913;
+  let year = 100 * q0 + i32(u1 >>> 32);
+  let mo = n1 >>> 16;
+  _day = (n1 & 0xFFFF) / 2141 + 1; // [1, 31]
+  if (dm1 >= 306) { mo -= 12; ++year; }
+  _month = mo; // [1, 12]
+  return year;
+}
+
+// http://howardhinnant.github.io/date_algorithms.html#days_from_civil
+function daysSinceEpoch(y: i32, m: i32, d: i32): i64 {
+  y -= i32(m <= 2);
+  let era = <u32>floorDiv(y, YEARS_PER_EPOCH);
+  let yoe = <u32>y - era * YEARS_PER_EPOCH; // [0, 399]
+  let doy = <u32>(153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1; // [0, 365]
+  let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; // [0, 146096]
+  return <i64><i32>(era * 146097 + doe - EPOCH_OFFSET);
+}
+
+// TomohikoSakamoto algorithm from https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week
+function dayOfWeek(year: i32, month: i32, day: i32): i32 {
+  const tab = memory.data<u8>([0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4]);
+
+  year -= i32(month < 3);
+  year += floorDiv(year, 4) - floorDiv(year, 100) + floorDiv(year, YEARS_PER_EPOCH);
+  month = <i32>load<u8>(tab + month - 1);
+  return euclidRem(year + month + day, 7);
+}
+
+function stringify(value: i32, padding: i32 = 2): string {
+  return value.toString().padStart(padding, "0");
+}
+
+function join(year: i32, month: i32, day: i32, ms: i64): i64 {
+  return daysSinceEpoch(year, month, day) * MILLIS_PER_DAY + euclidRem(ms, MILLIS_PER_DAY);
+}

package/std/assembly/diagnostics.ts

@@ -0,0 +1,11 @@
+// @ts-ignore: decorator
+@builtin
+export declare function ERROR(message?: string): void;
+
+// @ts-ignore: decorator
+@builtin
+export declare function WARNING(message?: string): void;
+
+// @ts-ignore: decorator
+@builtin
+export declare function INFO(message?: string): void;

package/std/assembly/encoding.ts

@@ -0,0 +1,151 @@
+import { Pointer } from "./pointer";
+
+// Hex and varint encoding utilities.
+// Inline functions for zero-overhead encoding/decoding.
+
+export namespace Encoding {
+
+  export namespace Hex {
+    /** Encode bytes at `src` (length `srcLen`) to hex chars at `dst`. Returns chars written (srcLen * 2). */
+    @inline export function encode(src: usize, srcLen: i32, dst: usize): i32 {
+      for (let i: i32 = 0; i < srcLen; ++i) {
+        encodeByte(load<u8>(src + <usize>i), dst + <usize>(i << 1));
+      }
+      return srcLen << 1;
+    }
+
+    /** Decode hex chars at `src` (length `srcLen`, must be even) to bytes at `dst`. Returns bytes written, or -1 on error. */
+    @inline export function decode(src: usize, srcLen: i32, dst: usize): i32 {
+      if (srcLen & 1) return -1; // odd length
+      let outLen = srcLen >> 1;
+      for (let i: i32 = 0; i < outLen; ++i) {
+        let b = decodeByte(src + <usize>(i << 1));
+        if (b < 0) return -1;
+        store<u8>(dst + <usize>i, <u8>b);
+      }
+      return outLen;
+    }
+
+    /** Encode a single byte to 2 hex chars at `dst`. */
+    @inline export function encodeByte(value: u8, dst: usize): void {
+      let hi = (value >>> 4) & 0x0F;
+      let lo = value & 0x0F;
+      store<u8>(dst, hi < 10 ? hi + 48 : hi + 87);      // '0'-'9' or 'a'-'f'
+      store<u8>(dst + 1, lo < 10 ? lo + 48 : lo + 87);
+    }
+
+    /** Decode 2 hex chars at `src` to a byte value. Returns -1 on invalid input. */
+    @inline export function decodeByte(src: usize): i32 {
+      let hi = decodeNibble(load<u8>(src));
+      let lo = decodeNibble(load<u8>(src + 1));
+      if ((hi | lo) < 0) return -1;
+      return (hi << 4) | lo;
+    }
+
+    // Internal nibble decoder
+    @inline function decodeNibble(c: u8): i32 {
+      if (c >= 48 && c <= 57) return <i32>(c - 48);       // '0'-'9'
+      if (c >= 97 && c <= 102) return <i32>(c - 87);      // 'a'-'f'
+      if (c >= 65 && c <= 70) return <i32>(c - 55);       // 'A'-'F'
+      return -1;
+    }
+  }
+
+  export namespace Varint {
+    /** Encode a u32 as unsigned LEB128 at `dst`. Returns bytes written. */
+    @inline export function encodeU32(value: u32, dst: usize): i32 {
+      let i: i32 = 0;
+      while (value >= 0x80) {
+        store<u8>(dst + <usize>i, <u8>((value & 0x7F) | 0x80));
+        value >>= 7;
+        ++i;
+      }
+      store<u8>(dst + <usize>i, <u8>value);
+      return i + 1;
+    }
+
+    /** Encode a u64 as unsigned LEB128 at `dst`. Returns bytes written. */
+    @inline export function encodeU64(value: u64, dst: usize): i32 {
+      let i: i32 = 0;
+      while (value >= 0x80) {
+        store<u8>(dst + <usize>i, <u8>((<u32>(value & 0x7F)) | 0x80));
+        value >>= 7;
+        ++i;
+      }
+      store<u8>(dst + <usize>i, <u8><u32>value);
+      return i + 1;
+    }
+
+    /** Decode an unsigned LEB128-encoded u32 from `src`. Writes bytes consumed to `bytesRead`. Max 5 bytes. */
+    @inline export function decodeU32(src: usize, bytesRead: Pointer<i32>): u32 {
+      let result: u32 = 0;
+      let shift: u32 = 0;
+      let i: i32 = 0;
+      let b: u8;
+      do {
+        b = load<u8>(src + <usize>i);
+        result |= <u32>(b & 0x7F) << shift;
+        shift += 7;
+        ++i;
+        if (i >= 5) break; // u32 needs at most 5 LEB128 bytes
+      } while (b & 0x80);
+      bytesRead.value = i;
+      return result;
+    }
+
+    /** Decode an unsigned LEB128-encoded u64 from `src`. Writes bytes consumed to `bytesRead`. Max 10 bytes. */
+    @inline export function decodeU64(src: usize, bytesRead: Pointer<i32>): u64 {
+      let result: u64 = 0;
+      let shift: u64 = 0;
+      let i: i32 = 0;
+      let b: u8;
+      do {
+        b = load<u8>(src + <usize>i);
+        result |= <u64>(b & 0x7F) << shift;
+        shift += 7;
+        ++i;
+        if (i >= 10) break; // u64 needs at most 10 LEB128 bytes
+      } while (b & 0x80);
+      bytesRead.value = i;
+      return result;
+    }
+
+    /** Encode a u64 as Bitcoin CompactSize at `dst`. Returns bytes written. */
+    @inline export function encodeCompact(value: u64, dst: usize): i32 {
+      if (value < 0xFD) {
+        store<u8>(dst, <u8><u32>value);
+        return 1;
+      } else if (value <= 0xFFFF) {
+        store<u8>(dst, 0xFD);
+        store<u16>(dst + 1, <u16><u32>value); // LE
+        return 3;
+      } else if (value <= 0xFFFFFFFF) {
+        store<u8>(dst, 0xFE);
+        store<u32>(dst + 1, <u32>value); // LE
+        return 5;
+      } else {
+        store<u8>(dst, 0xFF);
+        store<u64>(dst + 1, value); // LE
+        return 9;
+      }
+    }
+
+    /** Decode a Bitcoin CompactSize from `src`. Writes bytes consumed to `bytesRead`. */
+    @inline export function decodeCompact(src: usize, bytesRead: Pointer<i32>): u64 {
+      let first = load<u8>(src);
+      if (first < 0xFD) {
+        bytesRead.value = 1;
+        return <u64>first;
+      } else if (first == 0xFD) {
+        bytesRead.value = 3;
+        return <u64>load<u16>(src + 1);
+      } else if (first == 0xFE) {
+        bytesRead.value = 5;
+        return <u64>load<u32>(src + 1);
+      } else {
+        bytesRead.value = 9;
+        return load<u64>(src + 1);
+      }
+    }
+  }
+}

package/std/assembly/endian.ts

@@ -0,0 +1,45 @@
+// Zero-overhead endian conversion utilities.
+// Wasm is little-endian; protocols (Bitcoin, networking) often need big-endian.
+
+export namespace Endian {
+
+  /** Load a value from memory in big-endian byte order. */
+  @inline export function loadBE<T>(ptr: usize, offset: usize = 0): T {
+    return bswap<T>(load<T>(ptr + offset));
+  }
+
+  /** Store a value to memory in big-endian byte order. */
+  @inline export function storeBE<T>(ptr: usize, value: T, offset: usize = 0): void {
+    store<T>(ptr + offset, bswap<T>(value));
+  }
+
+  /** Load a value from memory in little-endian byte order (identity on wasm). */
+  @inline export function loadLE<T>(ptr: usize, offset: usize = 0): T {
+    return load<T>(ptr + offset);
+  }
+
+  /** Store a value to memory in little-endian byte order (identity on wasm). */
+  @inline export function storeLE<T>(ptr: usize, value: T, offset: usize = 0): void {
+    store<T>(ptr + offset, value);
+  }
+
+  /** Convert a value to big-endian byte order (bswap on wasm). */
+  @inline export function toBE<T>(value: T): T {
+    return bswap<T>(value);
+  }
+
+  /** Convert a value from big-endian byte order (bswap on wasm). */
+  @inline export function fromBE<T>(value: T): T {
+    return bswap<T>(value);
+  }
+
+  /** Convert a value to little-endian byte order (identity on wasm). */
+  @inline export function toLE<T>(value: T): T {
+    return value;
+  }
+
+  /** Convert a value from little-endian byte order (identity on wasm). */
+  @inline export function fromLE<T>(value: T): T {
+    return value;
+  }
+}

package/std/assembly/error.ts

@@ -0,0 +1,44 @@
+export class Error {
+
+  name: string  = "Error";
+  stack: string = ""; // TODO
+
+  constructor(
+    public message: string = ""
+  ) {}
+
+  toString(): string {
+    let message = this.message;
+    return message.length
+      ? this.name + ": " + message
+      : this.name;
+  }
+}
+
+export class RangeError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "RangeError";
+  }
+}
+
+export class TypeError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "TypeError";
+  }
+}
+
+export class SyntaxError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "SyntaxError";
+  }
+}
+
+export class URIError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "URIError";
+  }
+}