datai-sdk 1.0.0 → 1.0.1

package/API/v1/proto/store/ValuePb.ts

@@ -3,108 +3,108 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
-import { BigDecimalPb } from '../bigDecimal/BigDecimalPb'
-import { ValuesPb } from './ValuesPb'
-import { ValueKindPb } from './ValueKindPb'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
+import { BigDecimalPb } from "../bigDecimal/BigDecimalPb";
+import { ValuesPb } from "./ValuesPb";
+import { ValueKindPb } from "./ValueKindPb";
 
 export class ValuePb {
   static encode(message: ValuePb, writer: Writer): void {
-    writer.uint32(8)
-    writer.int32(message.kind)
+    writer.uint32(8);
+    writer.int32(message.kind);
 
-    writer.uint32(802)
-    writer.string(message.stringData)
+    writer.uint32(802);
+    writer.string(message.stringData);
 
-    writer.uint32(808)
-    writer.int32(message.intData)
+    writer.uint32(808);
+    writer.int32(message.intData);
 
-    const bigdecimalData = message.bigdecimalData
+    const bigdecimalData = message.bigdecimalData;
     if (bigdecimalData !== null) {
-      writer.uint32(818)
-      writer.fork()
-      BigDecimalPb.encode(bigdecimalData, writer)
-      writer.ldelim()
+      writer.uint32(818);
+      writer.fork();
+      BigDecimalPb.encode(bigdecimalData, writer);
+      writer.ldelim();
     }
 
-    writer.uint32(824)
-    writer.bool(message.boolData)
+    writer.uint32(824);
+    writer.bool(message.boolData);
 
-    const arrayData = message.arrayData
+    const arrayData = message.arrayData;
     if (arrayData !== null) {
-      writer.uint32(834)
-      writer.fork()
-      ValuesPb.encode(arrayData, writer)
-      writer.ldelim()
+      writer.uint32(834);
+      writer.fork();
+      ValuesPb.encode(arrayData, writer);
+      writer.ldelim();
     }
 
-    writer.uint32(850)
-    writer.bytes(message.bytesData)
+    writer.uint32(850);
+    writer.bytes(message.bytesData);
 
-    writer.uint32(864)
-    writer.int64(message.int8Data)
+    writer.uint32(864);
+    writer.int64(message.int8Data);
   }
 
   static decode(reader: Reader, length: i32): ValuePb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new ValuePb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new ValuePb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.kind = reader.int32()
-          break
+          message.kind = reader.int32();
+          break;
 
         case 100:
-          message.stringData = reader.string()
-          break
+          message.stringData = reader.string();
+          break;
 
         case 101:
-          message.intData = reader.int32()
-          break
+          message.intData = reader.int32();
+          break;
 
         case 102:
-          message.bigdecimalData = BigDecimalPb.decode(reader, reader.uint32())
-          break
+          message.bigdecimalData = BigDecimalPb.decode(reader, reader.uint32());
+          break;
 
         case 103:
-          message.boolData = reader.bool()
-          break
+          message.boolData = reader.bool();
+          break;
 
         case 104:
-          message.arrayData = ValuesPb.decode(reader, reader.uint32())
-          break
+          message.arrayData = ValuesPb.decode(reader, reader.uint32());
+          break;
 
         case 106:
-          message.bytesData = reader.bytes()
-          break
+          message.bytesData = reader.bytes();
+          break;
 
         case 108:
-          message.int8Data = reader.int64()
-          break
+          message.int8Data = reader.int64();
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  kind: ValueKindPb
-  stringData: string
-  intData: i32
-  bigdecimalData: BigDecimalPb | null
-  boolData: bool
-  arrayData: ValuesPb | null
-  bytesData: Uint8Array
-  int8Data: i64
+  kind: ValueKindPb;
+  stringData: string;
+  intData: i32;
+  bigdecimalData: BigDecimalPb | null;
+  boolData: bool;
+  arrayData: ValuesPb | null;
+  bytesData: Uint8Array;
+  int8Data: i64;
 
   constructor(
     kind: ValueKindPb = 0,
-    stringData: string = '',
+    stringData: string = "",
     intData: i32 = 0,
     bigdecimalData: BigDecimalPb | null = null,
     boolData: bool = false,
@@ -112,21 +112,21 @@ export class ValuePb {
     bytesData: Uint8Array = new Uint8Array(0),
     int8Data: i64 = 0
   ) {
-    this.kind = kind
-    this.stringData = stringData
-    this.intData = intData
-    this.bigdecimalData = bigdecimalData
-    this.boolData = boolData
-    this.arrayData = arrayData
-    this.bytesData = bytesData
-    this.int8Data = int8Data
+    this.kind = kind;
+    this.stringData = stringData;
+    this.intData = intData;
+    this.bigdecimalData = bigdecimalData;
+    this.boolData = boolData;
+    this.arrayData = arrayData;
+    this.bytesData = bytesData;
+    this.int8Data = int8Data;
   }
 }
 
 export function encodeValuePb(message: ValuePb): Uint8Array {
-  return Protobuf.encode(message, ValuePb.encode)
+  return Protobuf.encode(message, ValuePb.encode);
 }
 
 export function decodeValuePb(buffer: Uint8Array): ValuePb {
-  return Protobuf.decode<ValuePb>(buffer, ValuePb.decode)
+  return Protobuf.decode<ValuePb>(buffer, ValuePb.decode);
 }

package/API/v1/proto/store/ValuesPb.ts

@@ -3,51 +3,51 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
-import { ValuePb } from './ValuePb'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
+import { ValuePb } from "./ValuePb";
 
 export class ValuesPb {
   static encode(message: ValuesPb, writer: Writer): void {
-    const values = message.values
+    const values = message.values;
     for (let i: i32 = 0; i < values.length; ++i) {
-      writer.uint32(10)
-      writer.fork()
-      ValuePb.encode(values[i], writer)
-      writer.ldelim()
+      writer.uint32(10);
+      writer.fork();
+      ValuePb.encode(values[i], writer);
+      writer.ldelim();
     }
   }
 
   static decode(reader: Reader, length: i32): ValuesPb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new ValuesPb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new ValuesPb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.values.push(ValuePb.decode(reader, reader.uint32()))
-          break
+          message.values.push(ValuePb.decode(reader, reader.uint32()));
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  values: Array<ValuePb>
+  values: Array<ValuePb>;
 
   constructor(values: Array<ValuePb> = []) {
-    this.values = values
+    this.values = values;
   }
 }
 
 export function encodeValuesPb(message: ValuesPb): Uint8Array {
-  return Protobuf.encode(message, ValuesPb.encode)
+  return Protobuf.encode(message, ValuesPb.encode);
 }
 
 export function decodeValuesPb(buffer: Uint8Array): ValuesPb {
-  return Protobuf.decode<ValuesPb>(buffer, ValuesPb.decode)
+  return Protobuf.decode<ValuesPb>(buffer, ValuesPb.decode);
 }

package/API/v1/proto/watcher/WatcherResultPb.ts

@@ -3,60 +3,60 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
-import { Any } from '../google/protobuf/Any'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
+import { Any } from "../google/protobuf/Any";
 
 export class WatcherResultPb {
   static encode(message: WatcherResultPb, writer: Writer): void {
-    writer.uint32(10)
-    writer.string(message.updateTrigger)
+    writer.uint32(10);
+    writer.string(message.updateTrigger);
 
-    const payload = message.payload
+    const payload = message.payload;
     if (payload !== null) {
-      writer.uint32(18)
-      writer.fork()
-      Any.encode(payload, writer)
-      writer.ldelim()
+      writer.uint32(18);
+      writer.fork();
+      Any.encode(payload, writer);
+      writer.ldelim();
     }
   }
 
   static decode(reader: Reader, length: i32): WatcherResultPb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new WatcherResultPb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new WatcherResultPb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.updateTrigger = reader.string()
-          break
+          message.updateTrigger = reader.string();
+          break;
 
         case 2:
-          message.payload = Any.decode(reader, reader.uint32())
-          break
+          message.payload = Any.decode(reader, reader.uint32());
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  updateTrigger: string
-  payload: Any | null
+  updateTrigger: string;
+  payload: Any | null;
 
-  constructor(updateTrigger: string = '', payload: Any | null = null) {
-    this.updateTrigger = updateTrigger
-    this.payload = payload
+  constructor(updateTrigger: string = "", payload: Any | null = null) {
+    this.updateTrigger = updateTrigger;
+    this.payload = payload;
   }
 }
 
 export function encodeWatcherResultPb(message: WatcherResultPb): Uint8Array {
-  return Protobuf.encode(message, WatcherResultPb.encode)
+  return Protobuf.encode(message, WatcherResultPb.encode);
 }
 
 export function decodeWatcherResultPb(buffer: Uint8Array): WatcherResultPb {
-  return Protobuf.decode<WatcherResultPb>(buffer, WatcherResultPb.decode)
+  return Protobuf.decode<WatcherResultPb>(buffer, WatcherResultPb.decode);
 }

package/API/v1/watcher/WatcherInput.ts

@@ -1,4 +1,4 @@
-import { Entity } from '../../../@graphprotocol/graph-ts'
+import { Entity } from '@graphprotocol/graph-ts'
 
 export class WatcherInput {
   position: Entity

package/API/v1/watcher/watcher.ts

@@ -3,7 +3,7 @@ import { WatcherResultPb } from '../proto/watcher/WatcherResultPb'
 import { Any } from '../proto/google/protobuf/Any'
 import { Host } from '@extism/as-pdk'
 import { WatcherInput } from './WatcherInput'
-import { Entity } from '../../../@graphprotocol/graph-ts'
+import { Entity } from '@graphprotocol/graph-ts'
 import { EntityPb } from '../store/EntityPb'
 
 export namespace watcher {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "datai-sdk",
   "main": "index.ts",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Datai SDK which has useful libraries to help building projections",
   "dependencies": {
     "@extism/as-pdk": "^1.0.0",

package/utils/constants.ts

@@ -1,4 +1,4 @@
-import { BigDecimal, BigInt } from '../@graphprotocol/graph-ts'
+import { BigDecimal, BigInt } from '@graphprotocol/graph-ts'
 
 // Zero Address
 export const ADDRESS_ZERO = '0x0000000000000000000000000000000000000000'

package/utils/mathUtils.ts

@@ -1,4 +1,4 @@
-import { BigDecimal, BigInt, Bytes, Address } from '../@graphprotocol/graph-ts'
+import { BigDecimal, BigInt, Bytes, Address } from '@graphprotocol/graph-ts'
 import { BD_0, BD_1 } from './constants'
 
 const MAX_DECIMALS = 77 // max decimals in decimal128 IEEE 754 standard (limitation of thegraph host)