datai-sdk 1.1.2 → 1.1.3

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

@@ -0,0 +1,585 @@
+import { Bytes, TypedMap } from './collections';
+import { json } from './json';
+import { Address, BigDecimal, BigInt } from './numbers';
+
+/**
+ * Enum for supported value types.
+ */
+export enum ValueKind {
+  STRING = 0,
+  INT = 1,
+  BIGDECIMAL = 2,
+  BOOL = 3,
+  ARRAY = 4,
+  NULL = 5,
+  BYTES = 6,
+  BIGINT = 7,
+  INT8 = 8,
+  TIMESTAMP = 9,
+}
+
+const VALUE_KIND_NAMES = [
+  'String',
+  'Int',
+  'BigDecimal',
+  'bool',
+  'Array',
+  'null',
+  'Bytes',
+  'BigInt',
+  'Int8',
+  'Timestamp',
+];
+
+/**
+ * Pointer type for Value data.
+ *
+ * Big enough to fit any pointer or native `this.data`.
+ */
+export type ValuePayload = u64;
+
+/**
+ * A dynamically typed value.
+ */
+export class Value {
+  constructor(
+    public kind: ValueKind,
+    public data: ValuePayload,
+  ) {}
+
+  toAddress(): Address {
+    assert(this.kind == ValueKind.BYTES, 'Value is not an address.');
+    return changetype<Address>(this.data as u32);
+  }
+
+  toBoolean(): boolean {
+    if (this.kind == ValueKind.NULL) {
+      return false;
+    }
+    assert(this.kind == ValueKind.BOOL, 'Value is not a boolean.');
+    return this.data != 0;
+  }
+
+  toBytes(): Bytes {
+    assert(this.kind == ValueKind.BYTES, 'Value is not a byte array.');
+    return changetype<Bytes>(this.data as u32);
+  }
+
+  toI32(): i32 {
+    if (this.kind == ValueKind.NULL) {
+      return 0;
+    }
+    assert(this.kind == ValueKind.INT, 'Value is not an i32.');
+    return this.data as i32;
+  }
+
+  toI64(): i64 {
+    if (this.kind == ValueKind.NULL) {
+      return 0;
+    }
+    assert(this.kind == ValueKind.INT8, 'Value is not an i64.');
+    return this.data as i64;
+  }
+
+  toTimestamp(): i64 {
+    if (this.kind == ValueKind.NULL) {
+      return 0;
+    }
+    assert(this.kind == ValueKind.TIMESTAMP, 'Value is not an i64.');
+    return this.data as i64;
+  }
+
+  toString(): string {
+    assert(this.kind == ValueKind.STRING, 'Value is not a string.');
+    return changetype<string>(this.data as u32);
+  }
+
+  toBigInt(): BigInt {
+    assert(this.kind == ValueKind.BIGINT, 'Value is not a BigInt.');
+    return changetype<BigInt>(this.data as u32);
+  }
+
+  toBigDecimal(): BigDecimal {
+    assert(this.kind == ValueKind.BIGDECIMAL, 'Value is not a BigDecimal.');
+    return changetype<BigDecimal>(this.data as u32);
+  }
+
+  toArray(): Array<Value> {
+    assert(this.kind == ValueKind.ARRAY, 'Value is not an array.');
+    return changetype<Array<Value>>(this.data as u32);
+  }
+
+  toMatrix(): Array<Array<Value>> {
+    const valueArray = this.toArray();
+    const out = new Array<Array<Value>>(valueArray.length);
+    for (let i: i32 = 0; i < valueArray.length; i++) {
+      out[i] = valueArray[i].toArray();
+    }
+    return out;
+  }
+
+  toBooleanArray(): Array<boolean> {
+    const values = this.toArray();
+    const output = new Array<boolean>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      output[i] = values[i].toBoolean();
+    }
+    return output;
+  }
+
+  toBytesArray(): Array<Bytes> {
+    const values = this.toArray();
+    const output = new Array<Bytes>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      output[i] = values[i].toBytes();
+    }
+    return output;
+  }
+
+  toStringArray(): Array<string> {
+    const values = this.toArray();
+    const output = new Array<string>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      output[i] = values[i].toString();
+    }
+    return output;
+  }
+
+  toI32Array(): Array<i32> {
+    const values = this.toArray();
+    const output = new Array<i32>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      output[i] = values[i].toI32();
+    }
+    return output;
+  }
+
+  toI64Array(): Array<i64> {
+    const values = this.toArray();
+    const output = new Array<i64>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      output[i] = values[i].toI32();
+    }
+    return output;
+  }
+
+  toTimestampArray(): Array<i64> {
+    const values = this.toArray();
+    const output = new Array<i64>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      output[i] = values[i].toTimestamp();
+    }
+    return output;
+  }
+
+  toBigIntArray(): Array<BigInt> {
+    const values = this.toArray();
+    const output = new Array<BigInt>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      output[i] = values[i].toBigInt();
+    }
+    return output;
+  }
+
+  toBigDecimalArray(): Array<BigDecimal> {
+    const values = this.toArray();
+    const output = new Array<BigDecimal>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      output[i] = values[i].toBigDecimal();
+    }
+    return output;
+  }
+
+  toBooleanMatrix(): Array<Array<boolean>> {
+    const valueMatrix = this.toMatrix();
+    const out = new Array<Array<boolean>>(valueMatrix.length);
+    for (let i: i32 = 0; i < valueMatrix.length; i++) {
+      out[i] = new Array<boolean>(valueMatrix[i].length);
+      for (let j: i32 = 0; j < valueMatrix[i].length; j++) {
+        out[i][j] = valueMatrix[i][j].toBoolean();
+      }
+    }
+    return out;
+  }
+
+  toBytesMatrix(): Array<Array<Bytes>> {
+    const valueMatrix = this.toMatrix();
+    const out = new Array<Array<Bytes>>(valueMatrix.length);
+    for (let i: i32 = 0; i < valueMatrix.length; i++) {
+      out[i] = new Array<Bytes>(valueMatrix[i].length);
+      for (let j: i32 = 0; j < valueMatrix[i].length; j++) {
+        out[i][j] = valueMatrix[i][j].toBytes();
+      }
+    }
+    return out;
+  }
+
+  toAddressMatrix(): Array<Array<Address>> {
+    const valueMatrix = this.toMatrix();
+    const out = new Array<Array<Address>>(valueMatrix.length);
+    for (let i: i32 = 0; i < valueMatrix.length; i++) {
+      out[i] = new Array<Address>(valueMatrix[i].length);
+      for (let j: i32 = 0; j < valueMatrix[i].length; j++) {
+        out[i][j] = valueMatrix[i][j].toAddress();
+      }
+    }
+    return out;
+  }
+
+  toStringMatrix(): Array<Array<string>> {
+    const valueMatrix = this.toMatrix();
+    const out = new Array<Array<string>>(valueMatrix.length);
+    for (let i: i32 = 0; i < valueMatrix.length; i++) {
+      out[i] = new Array<string>(valueMatrix[i].length);
+      for (let j: i32 = 0; j < valueMatrix[i].length; j++) {
+        out[i][j] = valueMatrix[i][j].toString();
+      }
+    }
+    return out;
+  }
+
+  toI32Matrix(): Array<Array<i32>> {
+    const valueMatrix = this.toMatrix();
+    const out = new Array<Array<i32>>(valueMatrix.length);
+    for (let i: i32 = 0; i < valueMatrix.length; i++) {
+      out[i] = new Array<i32>(valueMatrix[i].length);
+      for (let j: i32 = 0; j < valueMatrix[i].length; j++) {
+        out[i][j] = valueMatrix[i][j].toI32();
+      }
+    }
+    return out;
+  }
+
+  toI64Matrix(): Array<Array<i64>> {
+    const valueMatrix = this.toMatrix();
+    const out = new Array<Array<i64>>(valueMatrix.length);
+
+    for (let i: i32 = 0; i < valueMatrix.length; i++) {
+      out[i] = new Array<i64>(valueMatrix[i].length);
+      for (let j: i32 = 0; j < valueMatrix[i].length; j++) {
+        out[i][j] = valueMatrix[i][j].toI64();
+      }
+    }
+    return out;
+  }
+
+  toBigIntMatrix(): Array<Array<BigInt>> {
+    const valueMatrix = this.toMatrix();
+    const out = new Array<Array<BigInt>>(valueMatrix.length);
+    for (let i: i32 = 0; i < valueMatrix.length; i++) {
+      out[i] = new Array<BigInt>(valueMatrix[i].length);
+      for (let j: i32 = 0; j < valueMatrix[i].length; j++) {
+        out[i][j] = valueMatrix[i][j].toBigInt();
+      }
+    }
+    return out;
+  }
+
+  /** Return a string that indicates the kind of value `this` contains for
+   * logging and error messages */
+  displayKind(): string {
+    if (this.kind >= VALUE_KIND_NAMES.length) {
+      return `Unknown (${this.kind})`;
+    }
+    return VALUE_KIND_NAMES[this.kind];
+  }
+
+  /** Return a string representation of the value of `this` for logging and
+   * error messages */
+  displayData(): string {
+    switch (this.kind) {
+      case ValueKind.STRING:
+        return this.toString();
+      case ValueKind.INT:
+        return this.toI32().toString();
+      case ValueKind.INT8:
+      case ValueKind.TIMESTAMP:
+        return this.toI64().toString();
+      case ValueKind.BIGDECIMAL:
+        return this.toBigDecimal().toString();
+      case ValueKind.BOOL:
+        return this.toBoolean().toString();
+      case ValueKind.ARRAY:
+        // TODO: we need to clean it up. Not sure how `this` works in AssemblyScript so leaving as it is for now
+        // eslint-disable-next-line no-case-declarations
+        const arr = this.toArray();
+        return '[' + arr.map<string>(elt => elt.displayData()).join(', ') + ']';
+      case ValueKind.NULL:
+        return 'null';
+      case ValueKind.BYTES:
+        return this.toBytes().toHexString();
+      case ValueKind.BIGINT:
+        return this.toBigInt().toString();
+      default:
+        return `Unknown data (kind = ${this.kind})`;
+    }
+  }
+
+  static fromBooleanArray(input: Array<boolean>): Value {
+    const output = new Array<Value>(input.length);
+    for (let i: i32 = 0; i < input.length; i++) {
+      output[i] = Value.fromBoolean(input[i]);
+    }
+    return Value.fromArray(output);
+  }
+
+  static fromBytesArray(input: Array<Bytes>): Value {
+    const output = new Array<Value>(input.length);
+    for (let i: i32 = 0; i < input.length; i++) {
+      output[i] = Value.fromBytes(input[i]);
+    }
+    return Value.fromArray(output);
+  }
+
+  static fromI32Array(input: Array<i32>): Value {
+    const output = new Array<Value>(input.length);
+    for (let i: i32 = 0; i < input.length; i++) {
+      output[i] = Value.fromI32(input[i]);
+    }
+    return Value.fromArray(output);
+  }
+
+  static fromBigIntArray(input: Array<BigInt>): Value {
+    const output = new Array<Value>(input.length);
+    for (let i: i32 = 0; i < input.length; i++) {
+      output[i] = Value.fromBigInt(input[i]);
+    }
+    return Value.fromArray(output);
+  }
+
+  static fromBigDecimalArray(input: Array<BigDecimal>): Value {
+    const output = new Array<Value>(input.length);
+    for (let i: i32 = 0; i < input.length; i++) {
+      output[i] = Value.fromBigDecimal(input[i]);
+    }
+    return Value.fromArray(output);
+  }
+
+  static fromStringArray(input: Array<string>): Value {
+    const output = new Array<Value>(input.length);
+    for (let i: i32 = 0; i < input.length; i++) {
+      output[i] = Value.fromString(input[i]);
+    }
+    return Value.fromArray(output);
+  }
+
+  static fromAddressArray(input: Array<Address>): Value {
+    const output = new Array<Value>(input.length);
+    for (let i: i32 = 0; i < input.length; i++) {
+      output[i] = Value.fromAddress(input[i]);
+    }
+    return Value.fromArray(output);
+  }
+
+  static fromArray(input: Array<Value>): Value {
+    return new Value(ValueKind.ARRAY, changetype<u32>(input));
+  }
+
+  static fromBigInt(n: BigInt): Value {
+    return new Value(ValueKind.BIGINT, changetype<u32>(n));
+  }
+
+  static fromBoolean(b: bool): Value {
+    return new Value(ValueKind.BOOL, b ? 1 : 0);
+  }
+
+  static fromBytes(bytes: Bytes): Value {
+    return new Value(ValueKind.BYTES, changetype<u32>(bytes));
+  }
+
+  static fromNull(): Value {
+    return new Value(ValueKind.NULL, 0);
+  }
+
+  static fromI32(n: i32): Value {
+    return new Value(ValueKind.INT, n as u64);
+  }
+
+  static fromI64(n: i64): Value {
+    return new Value(ValueKind.INT8, n as i64);
+  }
+
+  static fromTimestamp(n: i64): Value {
+    return new Value(ValueKind.TIMESTAMP, n as i64);
+  }
+
+  static fromString(s: string): Value {
+    return new Value(ValueKind.STRING, changetype<u32>(s));
+  }
+
+  static fromAddress(s: Address): Value {
+    return new Value(ValueKind.BYTES, changetype<u32>(s));
+  }
+
+  static fromBigDecimal(n: BigDecimal): Value {
+    return new Value(ValueKind.BIGDECIMAL, changetype<u32>(n));
+  }
+
+  static fromMatrix(values: Array<Array<Value>>): Value {
+    const innerOut = new Array<Value>(values.length);
+    for (let i: i32 = 0; i < innerOut.length; i++) {
+      innerOut[i] = Value.fromArray(values[i]);
+    }
+    return Value.fromArray(innerOut);
+  }
+
+  static fromBooleanMatrix(values: Array<Array<boolean>>): Value {
+    const out = new Array<Array<Value>>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      out[i] = new Array<Value>(values[i].length);
+      for (let j: i32 = 0; j < values[i].length; j++) {
+        out[i][j] = Value.fromBoolean(values[i][j]);
+      }
+    }
+    return Value.fromMatrix(out);
+  }
+
+  static fromBytesMatrix(values: Array<Array<Bytes>>): Value {
+    const out = new Array<Array<Value>>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      out[i] = new Array<Value>(values[i].length);
+      for (let j: i32 = 0; j < values[i].length; j++) {
+        out[i][j] = Value.fromBytes(values[i][j]);
+      }
+    }
+    return Value.fromMatrix(out);
+  }
+
+  static fromAddressMatrix(values: Array<Array<Address>>): Value {
+    const out = new Array<Array<Value>>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      out[i] = new Array<Value>(values[i].length);
+      for (let j: i32 = 0; j < values[i].length; j++) {
+        out[i][j] = Value.fromAddress(values[i][j]);
+      }
+    }
+    return Value.fromMatrix(out);
+  }
+
+  static fromStringMatrix(values: Array<Array<string>>): Value {
+    const out = new Array<Array<Value>>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      out[i] = new Array<Value>(values[i].length);
+      for (let j: i32 = 0; j < values[i].length; j++) {
+        out[i][j] = Value.fromString(values[i][j]);
+      }
+    }
+    return Value.fromMatrix(out);
+  }
+
+  static fromI32Matrix(values: Array<Array<i32>>): Value {
+    const out = new Array<Array<Value>>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      out[i] = new Array<Value>(values[i].length);
+      for (let j: i32 = 0; j < values[i].length; j++) {
+        out[i][j] = Value.fromI32(values[i][j]);
+      }
+    }
+    return Value.fromMatrix(out);
+  }
+
+  static fromI64Matrix(values: Array<Array<i64>>): Value {
+    const out = new Array<Array<Value>>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      out[i] = new Array<Value>(values[i].length);
+      for (let j: i32 = 0; j < values[i].length; j++) {
+        out[i][j] = Value.fromI64(values[i][j]);
+      }
+    }
+    return Value.fromMatrix(out);
+  }
+
+  static fromTimestampMatrix(values: Array<Array<i64>>): Value {
+    const out = new Array<Array<Value>>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      out[i] = new Array<Value>(values[i].length);
+      for (let j: i32 = 0; j < values[i].length; j++) {
+        out[i][j] = Value.fromTimestamp(values[i][j]);
+      }
+    }
+    return Value.fromMatrix(out);
+  }
+
+  static fromBigIntMatrix(values: Array<Array<BigInt>>): Value {
+    const out = new Array<Array<Value>>(values.length);
+    for (let i: i32 = 0; i < values.length; i++) {
+      out[i] = new Array<Value>(values[i].length);
+      for (let j: i32 = 0; j < values[i].length; j++) {
+        out[i][j] = Value.fromBigInt(values[i][j]);
+      }
+    }
+    return Value.fromMatrix(out);
+  }
+}
+
+/** Type hint for JSON values. */
+export enum JSONValueKind {
+  NULL = 0,
+  BOOL = 1,
+  NUMBER = 2,
+  STRING = 3,
+  ARRAY = 4,
+  OBJECT = 5,
+}
+
+/**
+ * Pointer type for JSONValue data.
+ *
+ * Big enough to fit any pointer or native `this.data`.
+ */
+export type JSONValuePayload = u64;
+
+export class JSONValue {
+  constructor(
+    public kind: JSONValueKind,
+    public data: JSONValuePayload,
+  ) {}
+
+  isNull(): boolean {
+    return this.kind == JSONValueKind.NULL;
+  }
+
+  toBool(): boolean {
+    assert(this.kind == JSONValueKind.BOOL, 'JSON value is not a boolean.');
+    return this.data != 0;
+  }
+
+  toI64(): i64 {
+    assert(this.kind == JSONValueKind.NUMBER, 'JSON value is not a number.');
+    const decimalString = changetype<string>(this.data as u32);
+    return json.toI64(decimalString);
+  }
+
+  toU64(): u64 {
+    assert(this.kind == JSONValueKind.NUMBER, 'JSON value is not a number.');
+    const decimalString = changetype<string>(this.data as u32);
+    return json.toU64(decimalString);
+  }
+
+  toF64(): f64 {
+    assert(this.kind == JSONValueKind.NUMBER, 'JSON value is not a number.');
+    const decimalString = changetype<string>(this.data as u32);
+    return json.toF64(decimalString);
+  }
+
+  toBigInt(): BigInt {
+    assert(this.kind == JSONValueKind.NUMBER, 'JSON value is not a number.');
+    const decimalString = changetype<string>(this.data as u32);
+    return json.toBigInt(decimalString);
+  }
+
+  toString(): string {
+    assert(this.kind == JSONValueKind.STRING, 'JSON value is not a string.');
+    return changetype<string>(this.data as u32);
+  }
+
+  toArray(): Array<JSONValue> {
+    assert(this.kind == JSONValueKind.ARRAY, 'JSON value is not an array.');
+    return changetype<Array<JSONValue>>(this.data as u32);
+  }
+
+  toObject(): TypedMap<string, JSONValue> {
+    assert(this.kind == JSONValueKind.OBJECT, 'JSON value is not an object.');
+    return changetype<TypedMap<string, JSONValue>>(this.data as u32);
+  }
+}

package/@graphprotocol/graph-ts/global/global.ts

@@ -0,0 +1,4 @@
+export function allocate(size: usize): usize {
+  // @ts-expect-error We do not want to expose __alloc, hence why we just ignore the error
+  return __alloc(size);
+}

package/@graphprotocol/graph-ts/helper-functions.ts

@@ -0,0 +1,79 @@
+import { ByteArray } from './index';
+
+/**
+ * Takes 2 ByteArrays and concatenates them
+ * @param a - 1st ByteArray
+ * @param b - 2nd ByteArray
+ * @returns A concatenated ByteArray
+ */
+export function concat(a: ByteArray, b: ByteArray): ByteArray {
+  const out = new Uint8Array(a.length + b.length);
+  for (let i = 0; i < a.length; i++) {
+    out[i] = a[i];
+  }
+  for (let j = 0; j < b.length; j++) {
+    out[a.length + j] = b[j];
+  }
+  return changetype<ByteArray>(out);
+}
+
+/**
+ * Used for parseCSV() below
+ */
+enum CSVState {
+  BETWEEN = 0,
+  UNQUOTED_VALUE = 1,
+  QUOTED_VALUE = 2,
+}
+
+/**
+ * Parses a CSV string into an array of strings.
+ * @param csv CSV string.
+ * @returns Array of strings.
+ */
+export function parseCSV(csv: string): Array<string> {
+  const values = new Array<string>();
+  let valueStart = 0;
+  let state = CSVState.BETWEEN;
+
+  for (let i: i32 = 0; i < csv.length; i++) {
+    if (state == CSVState.BETWEEN) {
+      if (csv.charAt(i) != ',') {
+        if (csv.charAt(i) == '"') {
+          state = CSVState.QUOTED_VALUE;
+          valueStart = i + 1;
+        } else {
+          state = CSVState.UNQUOTED_VALUE;
+          valueStart = i;
+        }
+      }
+    } else if (state == CSVState.UNQUOTED_VALUE) {
+      if (csv.charAt(i) == ',') {
+        values.push(csv.substr(valueStart, i - valueStart));
+        state = CSVState.BETWEEN;
+      }
+    } else if (state == CSVState.QUOTED_VALUE && csv.charAt(i) == '"') {
+      values.push(csv.substr(valueStart, i - valueStart));
+      state = CSVState.BETWEEN;
+    }
+  }
+
+  return values;
+}
+
+/**
+ * Adds 0x1220 to the front of a ByteArray. This can be used when an IPFS hash is stored in an Ethereum Bytes32 type.
+ * The IPFS hash will fit in a Bytes32 when 0x1220 is removed. Since 0x1220 is currently in front of every single IPFS
+ * hash, this works. But it is possible in the future that IPFS will update their spec.
+ * @param a - The ByteArray without 0x1220 prefixed
+ * @returns - The ByteArray with 0x1220 prefixed
+ */
+export function addQm(a: ByteArray): ByteArray {
+  const out = new Uint8Array(34);
+  out[0] = 0x12;
+  out[1] = 0x20;
+  for (let i = 0; i < 32; i++) {
+    out[i + 2] = a[i];
+  }
+  return changetype<ByteArray>(out);
+}