datai-sdk 1.0.0

package/@graphprotocol/graph-ts/common/numbers.ts

@@ -0,0 +1,407 @@
+import './eager_offset';
+import { ByteArray, Bytes } from './collections';
+import { typeConversion } from './conversion';
+import { bigInt, bigDecimal } from '../../../API'
+
+export type Int8 = i64;
+export type Timestamp = i64;
+
+/** An Ethereum address (20 bytes). */
+export class Address extends Bytes {
+  static fromString(s: string): Address {
+    return changetype<Address>(typeConversion.stringToH160(s));
+  }
+
+  /** Convert `Bytes` that must be exactly 20 bytes long to an address.
+   * Passing in a value with fewer or more bytes will result in an error */
+  static fromBytes(b: Bytes): Address {
+    if (b.length != 20) {
+      throw new Error(`Bytes of length ${b.length} can not be converted to 20 byte addresses`);
+    }
+    return changetype<Address>(b);
+  }
+
+  static zero(): Address {
+    const self = new ByteArray(20);
+
+    for (let i = 0; i < 20; i++) {
+      self[i] = 0;
+    }
+
+    return changetype<Address>(self);
+  }
+}
+
+/** An arbitrary size integer represented as an array of bytes. */
+export class BigInt extends Uint8Array {
+  static fromI32(x: i32): BigInt {
+    const byteArray = ByteArray.fromI32(x);
+    return BigInt.fromByteArray(byteArray);
+  }
+
+  static fromU32(x: u32): BigInt {
+    const byteArray = ByteArray.fromU32(x);
+    return BigInt.fromUnsignedBytes(byteArray);
+  }
+
+  static fromI64(x: i64): BigInt {
+    const byteArray = ByteArray.fromI64(x);
+    return BigInt.fromByteArray(byteArray);
+  }
+
+  static fromU64(x: u64): BigInt {
+    const byteArray = ByteArray.fromU64(x);
+    return BigInt.fromUnsignedBytes(byteArray);
+  }
+
+  static zero(): BigInt {
+    return BigInt.fromI32(0);
+  }
+
+  /**
+   * `bytes` assumed to be little-endian. If your input is big-endian, call `.reverse()` first.
+   */
+
+  static fromSignedBytes(bytes: Bytes): BigInt {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const byteArray = <ByteArray>bytes;
+    return BigInt.fromByteArray(byteArray);
+  }
+
+  static fromByteArray(byteArray: ByteArray): BigInt {
+    return changetype<BigInt>(byteArray);
+  }
+
+  /**
+   * `bytes` assumed to be little-endian. If your input is big-endian, call `.reverse()` first.
+   */
+
+  static fromUnsignedBytes(bytes: ByteArray): BigInt {
+    const signedBytes = new BigInt(bytes.length + 1);
+    for (let i = 0; i < bytes.length; i++) {
+      signedBytes[i] = bytes[i];
+    }
+    signedBytes[bytes.length] = 0;
+    return signedBytes;
+  }
+
+  toHex(): string {
+    return typeConversion.bigIntToHex(this);
+  }
+
+  toHexString(): string {
+    return typeConversion.bigIntToHex(this);
+  }
+
+  toString(): string {
+    return typeConversion.bigIntToString(this);
+  }
+
+  static fromString(s: string): BigInt {
+    return bigInt.fromString(s);
+  }
+
+  toI32(): i32 {
+    const uint8Array = changetype<Uint8Array>(this);
+    const byteArray = changetype<ByteArray>(uint8Array);
+    return byteArray.toI32();
+  }
+
+  toU32(): u32 {
+    const uint8Array = changetype<Uint8Array>(this);
+    const byteArray = changetype<ByteArray>(uint8Array);
+    return byteArray.toU32();
+  }
+
+  toI64(): i64 {
+    const uint8Array = changetype<Uint8Array>(this);
+    const byteArray = changetype<ByteArray>(uint8Array);
+    return byteArray.toI64();
+  }
+
+  toU64(): u64 {
+    const uint8Array = changetype<Uint8Array>(this);
+    const byteArray = changetype<ByteArray>(uint8Array);
+    return byteArray.toU64();
+  }
+
+  toBigDecimal(): BigDecimal {
+    return new BigDecimal(this);
+  }
+
+  isZero(): boolean {
+    return this == BigInt.fromI32(0);
+  }
+
+  isI32(): boolean {
+    return BigInt.fromI32(i32.MIN_VALUE) <= this && this <= BigInt.fromI32(i32.MAX_VALUE);
+  }
+
+  abs(): BigInt {
+    return this < BigInt.fromI32(0) ? this.neg() : this;
+  }
+
+  sqrt(): BigInt {
+    return bigInt.sqrt(this)
+  }
+
+  // Operators
+
+  @operator('+')
+  plus(other: BigInt): BigInt {
+    return bigInt.plus(this, other);
+  }
+
+  @operator('-')
+  minus(other: BigInt): BigInt {
+    return bigInt.minus(this, other);
+  }
+
+  @operator('*')
+  times(other: BigInt): BigInt {
+    return bigInt.times(this, other);
+  }
+
+  @operator('/')
+  div(other: BigInt): BigInt {
+    return bigInt.dividedBy(this, other);
+  }
+
+  divDecimal(other: BigDecimal): BigDecimal {
+    return bigInt.dividedByDecimal(this, other);
+  }
+
+  @operator('%')
+  mod(other: BigInt): BigInt {
+    return bigInt.mod(this, other);
+  }
+
+  @operator('==')
+  equals(other: BigInt): boolean {
+    return BigInt.compare(this, other) == 0;
+  }
+
+  @operator('!=')
+  notEqual(other: BigInt): boolean {
+    return !(this == other);
+  }
+
+  @operator('<')
+  lt(other: BigInt): boolean {
+    return BigInt.compare(this, other) == -1;
+  }
+
+  @operator('>')
+  gt(other: BigInt): boolean {
+    return BigInt.compare(this, other) == 1;
+  }
+
+  @operator('<=')
+  le(other: BigInt): boolean {
+    return !(this > other);
+  }
+
+  @operator('>=')
+  ge(other: BigInt): boolean {
+    return !(this < other);
+  }
+
+  @operator.prefix('-')
+  neg(): BigInt {
+    return BigInt.fromI32(0).minus(this);
+  }
+
+  @operator('|')
+  bitOr(other: BigInt): BigInt {
+    return bigInt.bitOr(this, other);
+  }
+
+  @operator('&')
+  bitAnd(other: BigInt): BigInt {
+    return bigInt.bitAnd(this, other);
+  }
+
+  @operator('<<')
+  leftShift(bits: u8): BigInt {
+    return bigInt.leftShift(this, bits);
+  }
+
+  @operator('>>')
+  rightShift(bits: u8): BigInt {
+    return bigInt.rightShift(this, bits);
+  }
+
+  /// Limited to a low exponent to discourage creating a huge BigInt.
+  pow(exp: u8): BigInt {
+    return bigInt.pow(this, exp);
+  }
+
+  /**
+   * Returns −1 if a < b, 1 if a > b, and 0 if A == B
+   */
+  static compare(a: BigInt, b: BigInt): i32 {
+    // Check if a and b have the same sign.
+    const aIsNeg = a.length > 0 && a[a.length - 1] >> 7 == 1;
+    const bIsNeg = b.length > 0 && b[b.length - 1] >> 7 == 1;
+
+    if (!aIsNeg && bIsNeg) {
+      return 1;
+    }
+    if (aIsNeg && !bIsNeg) {
+      return -1;
+    }
+
+    // Check how many bytes of a and b are relevant to the magnitude.
+    let aRelevantBytes = a.length;
+    while (
+      aRelevantBytes > 0 &&
+      ((!aIsNeg && a[aRelevantBytes - 1] == 0) || (aIsNeg && a[aRelevantBytes - 1] == 255))
+    ) {
+      aRelevantBytes -= 1;
+    }
+    let bRelevantBytes = b.length;
+    while (
+      bRelevantBytes > 0 &&
+      ((!bIsNeg && b[bRelevantBytes - 1] == 0) || (bIsNeg && b[bRelevantBytes - 1] == 255))
+    ) {
+      bRelevantBytes -= 1;
+    }
+
+    // If a and b are positive then the one with more relevant bytes is larger.
+    // Otherwise the one with less relevant bytes is larger.
+    if (aRelevantBytes > bRelevantBytes) {
+      return aIsNeg ? -1 : 1;
+    }
+    if (bRelevantBytes > aRelevantBytes) {
+      return aIsNeg ? 1 : -1;
+    }
+
+    // We now know that a and b have the same sign and number of relevant bytes.
+    // If a and b are both negative then the one of lesser magnitude is the
+    // largest, however since in two's complement the magnitude is flipped, we
+    // may use the same logic as if a and b are positive.
+    const relevantBytes = aRelevantBytes;
+    for (let i = 1; i <= relevantBytes; i++) {
+      if (a[relevantBytes - i] < b[relevantBytes - i]) {
+        return -1;
+      }
+      if (a[relevantBytes - i] > b[relevantBytes - i]) {
+        return 1;
+      }
+    }
+
+    return 0;
+  }
+}
+
+export class BigDecimal {
+  digits: BigInt;
+  exp: BigInt;
+
+  constructor(bigInt: BigInt) {
+    this.digits = bigInt;
+    this.exp = BigInt.fromI32(0);
+  }
+
+  static fromString(s: string): BigDecimal {
+    return bigDecimal.fromString(s);
+  }
+
+  static zero(): BigDecimal {
+    return new BigDecimal(BigInt.zero());
+  }
+
+  toString(): string {
+    return bigDecimal.toString(this);
+  }
+
+  truncate(decimals: i32): BigDecimal {
+    const digitsRightOfZero = this.digits.toString().length + this.exp.toI32();
+    const newDigitLength = decimals + digitsRightOfZero;
+    const truncateLength = this.digits.toString().length - newDigitLength;
+    if (truncateLength < 0) {
+      return this;
+    }
+    for (let i = 0; i < truncateLength; i++) {
+      this.digits = this.digits.div(BigInt.fromI32(10));
+    }
+    this.exp = BigInt.fromI32(decimals * -1);
+    return this;
+  }
+
+  @operator('+')
+  plus(other: BigDecimal): BigDecimal {
+    return bigDecimal.plus(this, other);
+  }
+
+  @operator('-')
+  minus(other: BigDecimal): BigDecimal {
+    return bigDecimal.minus(this, other);
+  }
+
+  @operator('*')
+  times(other: BigDecimal): BigDecimal {
+    return bigDecimal.times(this, other);
+  }
+
+  @operator('/')
+  div(other: BigDecimal): BigDecimal {
+    return bigDecimal.dividedBy(this, other);
+  }
+
+  @operator('==')
+  equals(other: BigDecimal): boolean {
+    return BigDecimal.compare(this, other) == 0;
+  }
+
+  @operator('!=')
+  notEqual(other: BigDecimal): boolean {
+    return !(this == other);
+  }
+
+  @operator('<')
+  lt(other: BigDecimal): boolean {
+    return BigDecimal.compare(this, other) == -1;
+  }
+
+  @operator('>')
+  gt(other: BigDecimal): boolean {
+    return BigDecimal.compare(this, other) == 1;
+  }
+
+  @operator('<=')
+  le(other: BigDecimal): boolean {
+    return !(this > other);
+  }
+
+  @operator('>=')
+  ge(other: BigDecimal): boolean {
+    return !(this < other);
+  }
+
+  @operator.prefix('-')
+  neg(): BigDecimal {
+    return new BigDecimal(new BigInt(0)).minus(this);
+  }
+
+  /**
+   * Returns −1 if a < b, 1 if a > b, and 0 if A == B
+   */
+  static compare(a: BigDecimal, b: BigDecimal): i32 {
+    const diff = a.minus(b);
+    if (diff.digits.isZero()) {
+      return 0;
+    }
+    return diff.digits > BigInt.fromI32(0) ? 1 : -1;
+  }
+}
+
+/** A type representing Starknet's field element type. */
+export class Felt extends Bytes {
+  /**
+   * Modifies and transforms the object IN-PLACE into `BigInt`.
+   */
+  intoBigInt(): BigInt {
+    return BigInt.fromUnsignedBytes(changetype<ByteArray>(this.reverse()));
+  }
+}