@graphprotocol/graph-cli 0.23.0 → 0.23.1

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/common/collections.ts

@@ -1,5 +1,5 @@
 import { BigInt, BigDecimal } from './numbers'
-import { JSONValue, Value } from './value'
+import { Value } from './value'
 import { typeConversion } from './conversion'
 
 /**
@@ -18,6 +18,50 @@ export class ByteArray extends Uint8Array {
     return self
   }
 
+  /**
+   * Returns bytes in little-endian order.
+   */
+  static fromU32(x: u32): ByteArray {
+    let self = new ByteArray(4)
+    self[0] = x as u8
+    self[1] = (x >> 8) as u8
+    self[2] = (x >> 16) as u8
+    self[3] = (x >> 24) as u8
+    return self
+  }
+
+  /**
+   * Returns bytes in little-endian order.
+   */
+  static fromI64(x: i64): ByteArray {
+    let self = new ByteArray(8)
+    self[0] = x as u8
+    self[1] = (x >> 8) as u8
+    self[2] = (x >> 16) as u8
+    self[3] = (x >> 24) as u8
+    self[4] = (x >> 32) as u8
+    self[5] = (x >> 40) as u8
+    self[6] = (x >> 48) as u8
+    self[7] = (x >> 56) as u8
+    return self
+  }
+
+  /**
+   * Returns bytes in little-endian order.
+   */
+  static fromU64(x: u64): ByteArray {
+    let self = new ByteArray(8)
+    self[0] = x as u8
+    self[1] = (x >> 8) as u8
+    self[2] = (x >> 16) as u8
+    self[3] = (x >> 24) as u8
+    self[4] = (x >> 32) as u8
+    self[5] = (x >> 40) as u8
+    self[6] = (x >> 48) as u8
+    self[7] = (x >> 56) as u8
+    return self
+  }
+
   static empty(): ByteArray {
     return ByteArray.fromI32(0)
   }
@@ -28,7 +72,7 @@ export class ByteArray extends Uint8Array {
   static fromHexString(hex: string): ByteArray {
     assert(hex.length % 2 == 0, 'input ' + hex + ' has odd length')
     // Skip possible `0x` prefix.
-    if (hex.length >= 2 && hex[0] == '0' && hex[1] == 'x') {
+    if (hex.length >= 2 && hex.charAt(0) == '0' && hex.charAt(1) == 'x') {
       hex = hex.substr(2)
     }
     let output = new Bytes(hex.length / 2)
@@ -38,8 +82,7 @@ export class ByteArray extends Uint8Array {
     return output
   }
 
-  static fromUTF8(str: String): ByteArray {
-    // AssemblyScript counts a null terminator, we don't want that.
+  static fromUTF8(str: string): ByteArray {
     let utf8 = String.UTF8.encode(str)
     return changetype<ByteArray>(ByteArray.wrap(utf8))
   }
@@ -122,6 +165,80 @@ export class ByteArray extends Uint8Array {
     return x
   }
 
+  /**
+   * Interprets the byte array as a little-endian I64.
+   * Throws in case of overflow.
+   */
+
+  toI64(): i64 {
+    let isNeg = this.length > 0 && this[this.length - 1] >> 7 == 1
+    let padding = isNeg ? 255 : 0
+    for (let i = 8; i < this.length; i++) {
+      if (this[i] != padding) {
+        assert(false, 'overflow converting ' + this.toHexString() + ' to i64')
+      }
+    }
+    let paddedBytes = new Bytes(8)
+    paddedBytes[0] = padding
+    paddedBytes[1] = padding
+    paddedBytes[2] = padding
+    paddedBytes[3] = padding
+    paddedBytes[4] = padding
+    paddedBytes[5] = padding
+    paddedBytes[6] = padding
+    paddedBytes[7] = padding
+    let minLen = paddedBytes.length < this.length ? paddedBytes.length : this.length
+    for (let i = 0; i < minLen; i++) {
+      paddedBytes[i] = this[i]
+    }
+    let x: i64 = 0
+    x = (x | paddedBytes[7]) << 8
+    x = (x | paddedBytes[6]) << 8
+    x = (x | paddedBytes[5]) << 8
+    x = (x | paddedBytes[4]) << 8
+    x = (x | paddedBytes[3]) << 8
+    x = (x | paddedBytes[2]) << 8
+    x = (x | paddedBytes[1]) << 8
+    x = x | paddedBytes[0]
+    return x
+  }
+
+  /**
+   * Interprets the byte array as a little-endian U64.
+   * Throws in case of overflow.
+   */
+
+  toU64(): u64 {
+    for (let i = 8; i < this.length; i++) {
+      if (this[i] != 0) {
+        assert(false, 'overflow converting ' + this.toHexString() + ' to u64')
+      }
+    }
+    let paddedBytes = new Bytes(8)
+    paddedBytes[0] = 0
+    paddedBytes[1] = 0
+    paddedBytes[2] = 0
+    paddedBytes[3] = 0
+    paddedBytes[4] = 0
+    paddedBytes[5] = 0
+    paddedBytes[6] = 0
+    paddedBytes[7] = 0
+    let minLen = paddedBytes.length < this.length ? paddedBytes.length : this.length
+    for (let i = 0; i < minLen; i++) {
+      paddedBytes[i] = this[i]
+    }
+    let x: u64 = 0
+    x = (x | paddedBytes[7]) << 8
+    x = (x | paddedBytes[6]) << 8
+    x = (x | paddedBytes[5]) << 8
+    x = (x | paddedBytes[4]) << 8
+    x = (x | paddedBytes[3]) << 8
+    x = (x | paddedBytes[2]) << 8
+    x = (x | paddedBytes[1]) << 8
+    x = x | paddedBytes[0]
+    return x
+  }
+
   @operator('==')
   equals(other: ByteArray): boolean {
     if (this.length != other.length) {
@@ -151,6 +268,10 @@ export class Bytes extends ByteArray {
     return changetype<Bytes>(uint8Array)
   }
 
+  static fromUTF8(str: string): Bytes {
+    return Bytes.fromByteArray(ByteArray.fromUTF8(str))
+  }
+
   static empty(): Bytes {
     return changetype<Bytes>(ByteArray.empty())
   }

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/common/eager_offset.ts

@@ -38,4 +38,5 @@
 // # Reference
 // - Runtimes in AS: https://www.assemblyscript.org/garbage-collection.html#runtime-variants
 // - `offset` variable in question: https://github.com/AssemblyScript/assemblyscript/blob/f4091b8f3b6b029d30cd917cf84d97421faadeeb/std/assembly/rt/stub.ts#L9
-__alloc(0);
+// @ts-ignore We do not want to expose __alloc, hence why we just ignore the error
+__alloc(0)

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/common/json.ts

@@ -12,3 +12,17 @@ export declare namespace json {
   function toF64(decimal: string): f64
   function toBigInt(decimal: string): BigInt
 }
+
+export namespace json {
+  function fromString(data: string): JSONValue {
+    let bytes = Bytes.fromUTF8(data)
+
+    return json.fromBytes(bytes)
+  }
+
+  function try_fromString(data: string): Result<JSONValue, boolean> {
+    let bytes = Bytes.fromUTF8(data)
+
+    return json.try_fromBytes(bytes)
+  }
+}

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/common/numbers.ts

@@ -53,6 +53,21 @@ export class BigInt extends Uint8Array {
     return BigInt.fromByteArray(byteArray)
   }
 
+  static fromU32(x: u32): BigInt {
+    let byteArray = ByteArray.fromU32(x)
+    return BigInt.fromUnsignedBytes(byteArray)
+  }
+
+  static fromI64(x: i64): BigInt {
+    let byteArray = ByteArray.fromI64(x)
+    return BigInt.fromByteArray(byteArray)
+  }
+
+  static fromU64(x: u64): BigInt {
+    let byteArray = ByteArray.fromU64(x)
+    return BigInt.fromUnsignedBytes(byteArray)
+  }
+
   static zero(): BigInt {
     return BigInt.fromI32(0)
   }
@@ -74,7 +89,7 @@ export class BigInt extends Uint8Array {
    * `bytes` assumed to be little-endian. If your input is big-endian, call `.reverse()` first.
    */
 
-  static fromUnsignedBytes(bytes: Bytes): BigInt {
+  static fromUnsignedBytes(bytes: ByteArray): BigInt {
     let signedBytes = new BigInt(bytes.length + 1)
     for (let i = 0; i < bytes.length; i++) {
       signedBytes[i] = bytes[i]
@@ -105,6 +120,24 @@ export class BigInt extends Uint8Array {
     return byteArray.toI32()
   }
 
+  toU32(): u32 {
+    let uint8Array = changetype<Uint8Array>(this)
+    let byteArray = changetype<ByteArray>(uint8Array)
+    return byteArray.toU32()
+  }
+
+  toI64(): i64 {
+    let uint8Array = changetype<Uint8Array>(this)
+    let byteArray = changetype<ByteArray>(uint8Array)
+    return byteArray.toI64()
+  }
+
+  toU64(): u64 {
+    let uint8Array = changetype<Uint8Array>(this)
+    let byteArray = changetype<ByteArray>(uint8Array)
+    return byteArray.toU64()
+  }
+
   toBigDecimal(): BigDecimal {
     return new BigDecimal(this)
   }
@@ -118,11 +151,11 @@ export class BigInt extends Uint8Array {
   }
 
   abs(): BigInt {
-    return this < BigInt.fromI32(0) ? -this : this
+    return this < BigInt.fromI32(0) ? this.neg() : this
   }
 
   sqrt(): BigInt {
-    let x = this
+    let x: BigInt = this
     let z = x.plus(BigInt.fromI32(1)).div(BigInt.fromI32(2))
     let y = x
     while (z < y) {
@@ -137,25 +170,25 @@ export class BigInt extends Uint8Array {
 
   @operator('+')
   plus(other: BigInt): BigInt {
-    assert(this !== null, "Failed to sum BigInts because left hand side is 'null'");
+    assert(this !== null, "Failed to sum BigInts because left hand side is 'null'")
     return bigInt.plus(this, other)
   }
 
   @operator('-')
   minus(other: BigInt): BigInt {
-    assert(this !== null, "Failed to subtract BigInts because left hand side is 'null'");
+    assert(this !== null, "Failed to subtract BigInts because left hand side is 'null'")
     return bigInt.minus(this, other)
   }
 
   @operator('*')
   times(other: BigInt): BigInt {
-    assert(this !== null, "Failed to multiply BigInts because left hand side is 'null'");
+    assert(this !== null, "Failed to multiply BigInts because left hand side is 'null'")
     return bigInt.times(this, other)
   }
 
   @operator('/')
   div(other: BigInt): BigInt {
-    assert(this !== null, "Failed to divide BigInts because left hand side is 'null'");
+    assert(this !== null, "Failed to divide BigInts because left hand side is 'null'")
     return bigInt.dividedBy(this, other)
   }
 
@@ -165,7 +198,10 @@ export class BigInt extends Uint8Array {
 
   @operator('%')
   mod(other: BigInt): BigInt {
-    assert(this !== null, "Failed to apply module to BigInt because left hand side is 'null'");
+    assert(
+      this !== null,
+      "Failed to apply module to BigInt because left hand side is 'null'",
+    )
     return bigInt.mod(this, other)
   }
 
@@ -201,7 +237,7 @@ export class BigInt extends Uint8Array {
 
   @operator.prefix('-')
   neg(): BigInt {
-    return BigInt.fromI32(0) - this
+    return BigInt.fromI32(0).minus(this)
   }
 
   @operator('|')
@@ -324,25 +360,31 @@ export class BigDecimal {
 
   @operator('+')
   plus(other: BigDecimal): BigDecimal {
-    assert(this !== null, "Failed to sum BigDecimals because left hand side is 'null'");
+    assert(this !== null, "Failed to sum BigDecimals because left hand side is 'null'")
     return bigDecimal.plus(this, other)
   }
 
   @operator('-')
   minus(other: BigDecimal): BigDecimal {
-    assert(this !== null, "Failed to subtract BigDecimals because left hand side is 'null'");
+    assert(
+      this !== null,
+      "Failed to subtract BigDecimals because left hand side is 'null'",
+    )
     return bigDecimal.minus(this, other)
   }
 
   @operator('*')
   times(other: BigDecimal): BigDecimal {
-    assert(this !== null, "Failed to multiply BigDecimals because left hand side is 'null'");
+    assert(
+      this !== null,
+      "Failed to multiply BigDecimals because left hand side is 'null'",
+    )
     return bigDecimal.times(this, other)
   }
 
   @operator('/')
   div(other: BigDecimal): BigDecimal {
-    assert(this !== null, "Failed to divide BigDecimals because left hand side is 'null'");
+    assert(this !== null, "Failed to divide BigDecimals because left hand side is 'null'")
     return bigDecimal.dividedBy(this, other)
   }
 
@@ -378,15 +420,15 @@ export class BigDecimal {
 
   @operator.prefix('-')
   neg(): BigDecimal {
-    assert(this !== null, "Failed to negate BigDecimal because the value of it is 'null'");
-    return new BigDecimal(new BigInt(0)) - this
+    assert(this !== null, "Failed to negate BigDecimal because the value of it is 'null'")
+    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 {
-    let diff = a - b
+    let diff = a.minus(b)
     if (diff.digits.isZero()) {
       return 0
     }

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/common/value.ts

@@ -27,10 +27,7 @@ export type ValuePayload = u64
  * A dynamically typed value.
  */
 export class Value {
-  constructor(
-    public kind: ValueKind,
-    public data: ValuePayload,
-  ) {}
+  constructor(public kind: ValueKind, public data: ValuePayload) {}
 
   toAddress(): Address {
     assert(this.kind == ValueKind.BYTES, 'Value is not an address.')
@@ -196,7 +193,7 @@ export class Value {
     return new Value(ValueKind.BIGINT, changetype<u32>(n))
   }
 
-  static fromBoolean(b: boolean): Value {
+  static fromBoolean(b: bool): Value {
     return new Value(ValueKind.BOOL, b ? 1 : 0)
   }
 

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/global/global.ts

@@ -2,6 +2,7 @@ import { BigDecimal } from '../common/numbers'
 import { TypedMapEntry, Entity, TypedMap, Result, Wrapped } from '../common/collections'
 import { JSONValue, Value } from '../common/value'
 import { ethereum } from '../chain/ethereum'
+import { near } from '../chain/near'
 
 export enum TypeId {
   String = 0,
@@ -56,6 +57,41 @@ export enum TypeId {
   ArrayF32 = 49,
   ArrayF64 = 50,
   ArrayBigDecimal = 51,
+  NearArrayDataReceiver = 52,
+  NearArrayCryptoHash = 53,
+  NearArrayActionValue = 54,
+  NearMerklePath = 55, // or NearArrayMerklePathItem
+  NearArrayValidatorStake = 56,
+  NearArraySlashedValidator = 57,
+  NearArraySignature = 58,
+  NearArrayChunkHeader = 59,
+  NearAccessKeyPermissionValue = 60,
+  NearActionValue = 61,
+  NearDirection = 62, // not used in graph-node, could be removed
+  NearPublicKey = 63,
+  NearSignature = 64,
+  NearFunctionCallPermission = 65,
+  NearFullAccessPermission = 66,
+  NearAccessKey = 67,
+  NearDataReceiver = 68,
+  NearCreateAccountAction = 69,
+  NearDeployContractAction = 70,
+  NearFunctionCallAction = 71,
+  NearTransferAction = 72,
+  NearStakeAction = 73,
+  NearAddKeyAction = 74,
+  NearDeleteKeyAction = 75,
+  NearDeleteAccountAction = 76,
+  NearActionReceipt = 77,
+  NearSuccessStatus = 78,
+  NearMerklePathItem = 79,
+  NearExecutionOutcome = 80,
+  NearSlashedValidator = 81,
+  NearBlockHeader = 82,
+  NearValidatorStake = 83,
+  NearChunkHeader = 84,
+  NearBlock = 85,
+  NearReceiptWithOutcome = 86,
 }
 
 export function id_of_type(typeId: TypeId): usize {
@@ -164,11 +200,83 @@ export function id_of_type(typeId: TypeId): usize {
       return idof<Array<f64>>()
     case TypeId.ArrayBigDecimal:
       return idof<Array<BigDecimal>>()
+    case TypeId.NearArrayDataReceiver:
+      return idof<Array<near.DataReceiver>>()
+    case TypeId.NearArrayCryptoHash:
+      return idof<Array<near.CryptoHash>>()
+    case TypeId.NearArrayActionValue:
+      return idof<Array<near.ActionValue>>()
+    case TypeId.NearMerklePath:
+      return idof<near.MerklePath>()
+    case TypeId.NearArrayValidatorStake:
+      return idof<Array<near.ValidatorStake>>()
+    case TypeId.NearArraySlashedValidator:
+      return idof<Array<near.SlashedValidator>>()
+    case TypeId.NearArraySignature:
+      return idof<Array<near.Signature>>()
+    case TypeId.NearArrayChunkHeader:
+      return idof<Array<near.ChunkHeader>>()
+    case TypeId.NearAccessKeyPermissionValue:
+      return idof<near.AccessKeyPermissionValue>()
+    case TypeId.NearActionValue:
+      return idof<near.ActionValue>()
+    // Commented out because it's an enum, there's no type_id
+    // case TypeId.NearDirection:
+    //   return idof<near.Direction>()
+    case TypeId.NearPublicKey:
+      return idof<near.PublicKey>()
+    case TypeId.NearSignature:
+      return idof<near.Signature>()
+    case TypeId.NearFunctionCallPermission:
+      return idof<near.FunctionCallPermission>()
+    case TypeId.NearFullAccessPermission:
+      return idof<near.FullAccessPermission>()
+    case TypeId.NearAccessKey:
+      return idof<near.AccessKeyPermissionValue>()
+    case TypeId.NearDataReceiver:
+      return idof<near.DataReceiver>()
+    case TypeId.NearCreateAccountAction:
+      return idof<near.CreateAccountAction>()
+    case TypeId.NearDeployContractAction:
+      return idof<near.DeployContractAction>()
+    case TypeId.NearFunctionCallAction:
+      return idof<near.FunctionCallAction>()
+    case TypeId.NearTransferAction:
+      return idof<near.TransferAction>()
+    case TypeId.NearStakeAction:
+      return idof<near.StakeAction>()
+    case TypeId.NearAddKeyAction:
+      return idof<near.AddKeyAction>()
+    case TypeId.NearDeleteKeyAction:
+      return idof<near.DeleteKeyAction>()
+    case TypeId.NearDeleteAccountAction:
+      return idof<near.DeleteAccountAction>()
+    case TypeId.NearActionReceipt:
+      return idof<near.ActionReceipt>()
+    case TypeId.NearSuccessStatus:
+      return idof<near.SuccessStatus>()
+    case TypeId.NearMerklePathItem:
+      return idof<near.MerklePathItem>()
+    case TypeId.NearExecutionOutcome:
+      return idof<near.ExecutionOutcome>()
+    case TypeId.NearSlashedValidator:
+      return idof<near.SlashedValidator>()
+    case TypeId.NearBlockHeader:
+      return idof<near.BlockHeader>()
+    case TypeId.NearValidatorStake:
+      return idof<near.ValidatorStake>()
+    case TypeId.NearChunkHeader:
+      return idof<near.ChunkHeader>()
+    case TypeId.NearBlock:
+      return idof<near.Block>()
+    case TypeId.NearReceiptWithOutcome:
+      return idof<near.ReceiptWithOutcome>()
     default:
       return 0
   }
 }
 
 export function allocate(size: usize): usize {
+  // @ts-ignore We do not want to expose __alloc, hence why we just ignore the error
   return __alloc(size)
 }

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/helper-functions.ts

@@ -1,4 +1,4 @@
-import { ByteArray, BigInt } from './index'
+import { ByteArray } from './index'
 
 /**
  * Takes 2 ByteArrays and concatenates them
@@ -38,8 +38,8 @@ export function parseCSV(csv: string): Array<string> {
 
   for (let i: i32 = 0; i < csv.length; i++) {
     if (state == CSVState.BETWEEN) {
-      if (csv[i] != ',') {
-        if (csv[i] == '"') {
+      if (csv.charAt(i) != ',') {
+        if (csv.charAt(i) == '"') {
           state = CSVState.QUOTED_VALUE
           valueStart = i + 1
         } else {
@@ -48,12 +48,12 @@ export function parseCSV(csv: string): Array<string> {
         }
       }
     } else if (state == CSVState.UNQUOTED_VALUE) {
-      if (csv[i] == ',') {
+      if (csv.charAt(i) == ',') {
         values.push(csv.substr(valueStart, i - valueStart))
         state = CSVState.BETWEEN
       }
     } else if (state == CSVState.QUOTED_VALUE) {
-      if (csv[i] == '"') {
+      if (csv.charAt(i) == '"') {
         values.push(csv.substr(valueStart, i - valueStart))
         state = CSVState.BETWEEN
       }

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/index.ts

@@ -2,6 +2,8 @@
 import './common/eager_offset'
 // Ethereum support
 export * from './chain/ethereum'
+// NEAR support
+export * from './chain/near'
 // Regular re-exports
 export * from './common/numbers'
 export * from './common/collections'
@@ -10,19 +12,8 @@ export * from './common/conversion'
 export * from './common/json'
 export * from './common/datasource'
 
-import {
-  Address,
-  BigInt,
-  BigDecimal,
-} from './common/numbers'
-import {
-  Bytes,
-  ByteArray,
-  Result,
-  TypedMap,
-  Entity,
-} from './common/collections'
-import { JSONValue, Value } from './common/value'
+import { Bytes, ByteArray, Entity } from './common/collections'
+import { Value } from './common/value'
 
 /**
  * Host store interface.
@@ -69,13 +60,13 @@ function format(fmt: string, args: string[]): string {
       fmt.charCodeAt(i + 1) == 0x7d /* '}' */
     ) {
       if (argIndex >= args.length) {
-        throw Error('Too few arguments for format string: ' + fmt)
+        throw new Error('Too few arguments for format string: ' + fmt)
       } else {
         out += args[argIndex++]
         i++
       }
     } else {
-      out += fmt[i]
+      out += fmt.charAt(i)
     }
   }
   return out

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@graphprotocol/graph-ts",
   "description": "TypeScript/AssemblyScript library for writing subgraph mappings for The Graph",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "module": "index.ts",
   "types": "index.ts",
   "main": "index.ts",
@@ -9,9 +9,12 @@
     "assemblyscript": "0.19.10"
   },
   "devDependencies": {
-    "glob": "^7.1.2"
+    "glob": "^7.1.2",
+    "prettier": "^2.4.1"
   },
   "scripts": {
+    "lint": "prettier -c **/*.{js,ts}",
+    "build": "asc --explicitStart --exportRuntime --runtime stub index.ts helper-functions.ts --lib graph-ts -b index.wasm",
     "test": "node test/test.js",
     "release:patch": "npm version patch && npm publish && git push origin master && git push --tags",
     "release:minor": "npm version minor && npm publish && git push origin master && git push --tags",