datai-sdk 1.0.0

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

@@ -0,0 +1,132 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   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'
+
+export class ValuePb {
+  static encode(message: ValuePb, writer: Writer): void {
+    writer.uint32(8)
+    writer.int32(message.kind)
+
+    writer.uint32(802)
+    writer.string(message.stringData)
+
+    writer.uint32(808)
+    writer.int32(message.intData)
+
+    const bigdecimalData = message.bigdecimalData
+    if (bigdecimalData !== null) {
+      writer.uint32(818)
+      writer.fork()
+      BigDecimalPb.encode(bigdecimalData, writer)
+      writer.ldelim()
+    }
+
+    writer.uint32(824)
+    writer.bool(message.boolData)
+
+    const arrayData = message.arrayData
+    if (arrayData !== null) {
+      writer.uint32(834)
+      writer.fork()
+      ValuesPb.encode(arrayData, writer)
+      writer.ldelim()
+    }
+
+    writer.uint32(850)
+    writer.bytes(message.bytesData)
+
+    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()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.kind = reader.int32()
+          break
+
+        case 100:
+          message.stringData = reader.string()
+          break
+
+        case 101:
+          message.intData = reader.int32()
+          break
+
+        case 102:
+          message.bigdecimalData = BigDecimalPb.decode(reader, reader.uint32())
+          break
+
+        case 103:
+          message.boolData = reader.bool()
+          break
+
+        case 104:
+          message.arrayData = ValuesPb.decode(reader, reader.uint32())
+          break
+
+        case 106:
+          message.bytesData = reader.bytes()
+          break
+
+        case 108:
+          message.int8Data = reader.int64()
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  kind: ValueKindPb
+  stringData: string
+  intData: i32
+  bigdecimalData: BigDecimalPb | null
+  boolData: bool
+  arrayData: ValuesPb | null
+  bytesData: Uint8Array
+  int8Data: i64
+
+  constructor(
+    kind: ValueKindPb = 0,
+    stringData: string = '',
+    intData: i32 = 0,
+    bigdecimalData: BigDecimalPb | null = null,
+    boolData: bool = false,
+    arrayData: ValuesPb | null = null,
+    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
+  }
+}
+
+export function encodeValuePb(message: ValuePb): Uint8Array {
+  return Protobuf.encode(message, ValuePb.encode)
+}
+
+export function decodeValuePb(buffer: Uint8Array): ValuePb {
+  return Protobuf.decode<ValuePb>(buffer, ValuePb.decode)
+}

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

@@ -0,0 +1,53 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v3.21.12
+
+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
+    for (let i: i32 = 0; i < values.length; ++i) {
+      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()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.values.push(ValuePb.decode(reader, reader.uint32()))
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  values: Array<ValuePb>
+
+  constructor(values: Array<ValuePb> = []) {
+    this.values = values
+  }
+}
+
+export function encodeValuesPb(message: ValuesPb): Uint8Array {
+  return Protobuf.encode(message, ValuesPb.encode)
+}
+
+export function decodeValuesPb(buffer: Uint8Array): ValuesPb {
+  return Protobuf.decode<ValuesPb>(buffer, ValuesPb.decode)
+}

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

@@ -0,0 +1,62 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v3.21.12
+
+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)
+
+    const payload = message.payload
+    if (payload !== null) {
+      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()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.updateTrigger = reader.string()
+          break
+
+        case 2:
+          message.payload = Any.decode(reader, reader.uint32())
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  updateTrigger: string
+  payload: Any | null
+
+  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)
+}
+
+export function decodeWatcherResultPb(buffer: Uint8Array): WatcherResultPb {
+  return Protobuf.decode<WatcherResultPb>(buffer, WatcherResultPb.decode)
+}

package/API/v1/store/EntitiesPb.ts

@@ -0,0 +1,39 @@
+// Code is NOT generated
+// but the generated code from proto folder was used as reference
+// it is done this way to directly encode/decode into graph-ts types
+
+import { Writer, Reader } from 'as-proto/assembly'
+import { EntityPb } from './EntityPb'
+import { Entity } from '@graphprotocol/graph-ts/'
+
+export namespace EntitiesPb {
+  export function encode(message: Array<Entity>, writer: Writer): void {
+    const items = message
+    for (let i: i32 = 0; i < items.length; ++i) {
+      writer.uint32(10)
+      writer.fork()
+      EntityPb.encode(items[i], writer)
+      writer.ldelim()
+    }
+  }
+
+  export function decode(reader: Reader, length: i32): Array<Entity> {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new Array<Entity>()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.push(EntityPb.decode(reader, reader.uint32()))
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+}

package/API/v1/store/EntityPb.ts

@@ -0,0 +1,75 @@
+// Code is NOT generated
+// but the generated code from proto folder was used as reference
+// it is done this way to directly encode/decode into graph-ts types
+
+import { Writer, Reader } from 'as-proto/assembly'
+import { ValuePb } from './ValuePb'
+import { Value, Entity } from '@graphprotocol/graph-ts/'
+
+export namespace EntityPb {
+  export function encode(message: Entity, writer: Writer): void {
+    const entries = message.entries
+    if (entries !== null) {
+      for (let i: i32 = 0; i < entries.length; ++i) {
+        writer.uint32(10)
+        writer.fork()
+        writer.uint32(10)
+        writer.string(entries[i].key)
+        writer.uint32(18)
+        writer.fork()
+        ValuePb.encode(entries[i].value, writer)
+        writer.ldelim()
+        writer.ldelim()
+      }
+    }
+  }
+
+  export function decode(reader: Reader, length: i32): Entity {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new Entity()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          let entriesKey: string = ''
+          let entriesValue: Value | null = null
+          let entriesHasKey: bool = false
+          let entriesHasValue: bool = false
+          for (
+            const end: usize = reader.ptr + reader.uint32();
+            reader.ptr < end;
+
+          ) {
+            const tag = reader.uint32()
+            switch (tag >>> 3) {
+              case 1:
+                entriesKey = reader.string()
+                entriesHasKey = true
+                break
+
+              case 2:
+                entriesValue = ValuePb.decode(reader, reader.uint32())
+                entriesHasValue = true
+                break
+
+              default:
+                reader.skipType(tag & 7)
+                break
+            }
+
+            if (entriesHasKey && entriesHasValue && entriesValue !== null) {
+              message.set(entriesKey, entriesValue)
+            }
+          }
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+}

package/API/v1/store/ValuePb.ts

@@ -0,0 +1,154 @@
+// Code is NOT generated
+// but the generated code from proto folder was used as reference
+// it is done this way to directly encode/decode into graph-ts types
+
+import { Writer, Reader } from 'as-proto/assembly'
+import { BigDecimalPb } from '../bigDecimal/BigDecimalPb'
+import { ValuesPb } from './ValuesPb'
+import {
+  Value,
+  Bytes,
+  BigInt,
+  ValueKind,
+  BigDecimal,
+  ByteArray
+} from '@graphprotocol/graph-ts/'
+
+export namespace ValuePb {
+  export function encode(message: Value, writer: Writer): void {
+    writer.uint32(8)
+    writer.int32(message.kind)
+
+    switch (message.kind) {
+      case ValueKind.STRING:
+        writer.uint32(802)
+        writer.string(message.toString())
+        break
+
+      case ValueKind.INT:
+        writer.uint32(808)
+        writer.int32(message.toI32())
+        break
+
+      case ValueKind.BIGDECIMAL:
+        const bigdecimalData = message.toBigDecimal()
+        writer.uint32(818)
+        writer.fork()
+        BigDecimalPb.encode(bigdecimalData, writer)
+        writer.ldelim()
+        break
+
+      case ValueKind.BOOL:
+        writer.uint32(824)
+        writer.bool(message.toBoolean())
+        break
+
+      case ValueKind.ARRAY:
+        const arrayData = message.toArray()
+        if (arrayData !== null) {
+          writer.uint32(834)
+          writer.fork()
+          ValuesPb.encode(arrayData, writer)
+          writer.ldelim()
+        }
+        break
+
+      case ValueKind.NULL:
+        // write nothing
+        break
+
+      case ValueKind.BYTES:
+      case ValueKind.BIGINT:
+        writer.uint32(850)
+        writer.bytes(changetype<Bytes>(message.data as u32))
+        break
+
+      case ValueKind.INT8:
+      case ValueKind.TIMESTAMP:
+        writer.uint32(864)
+        writer.int64(message.data as i64)
+        break
+
+      default:
+        throw new Error('Encoding unsupported common value kind')
+    }
+  }
+
+  export function decode(reader: Reader, length: i32): Value {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    let kind: ValueKind = 0
+    let stringData: string = ''
+    let intData: i32 = 0
+    let bigdecimalData: BigDecimal | null = null
+    let boolData: bool = false
+    let arrayData: Value[] | null = null
+    let bytesData: Uint8Array = new Uint8Array(0)
+    let int8Data: i64 = 0
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          kind = reader.int32()
+          break
+
+        case 100:
+          stringData = reader.string()
+          break
+
+        case 101:
+          intData = reader.int32()
+          break
+
+        case 102:
+          bigdecimalData = BigDecimalPb.decode(reader, reader.uint32())
+          break
+
+        case 103:
+          boolData = reader.bool()
+          break
+
+        case 104:
+          arrayData = ValuesPb.decode(reader, reader.uint32())
+          break
+
+        case 106:
+          bytesData = reader.bytes()
+          break
+
+        case 108:
+          int8Data = reader.int64()
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    switch (kind) {
+      case ValueKind.STRING:
+        return Value.fromString(stringData)
+      case ValueKind.INT:
+        return Value.fromI32(intData)
+      case ValueKind.BIGDECIMAL:
+        return Value.fromBigDecimal(bigdecimalData!)
+      case ValueKind.BOOL:
+        return Value.fromBoolean(boolData)
+      case ValueKind.ARRAY:
+        return Value.fromArray(arrayData!)
+      case ValueKind.NULL:
+        return Value.fromNull()
+      case ValueKind.BYTES:
+        return Value.fromBytes(changetype<Bytes>(bytesData))
+      case ValueKind.BIGINT:
+        return Value.fromBigInt(changetype<BigInt>(bytesData))
+      case ValueKind.INT8:
+        return Value.fromI64(int8Data)
+      case ValueKind.TIMESTAMP:
+        return Value.fromTimestamp(int8Data)
+      default:
+        throw new Error(`Unsupported kind ${kind}`)
+    }
+  }
+}

package/API/v1/store/ValuesPb.ts

@@ -0,0 +1,39 @@
+// Code is NOT generated
+// but the generated code from proto folder was used as reference
+// it is done this way to directly encode/decode into graph-ts types
+
+import { Writer, Reader } from 'as-proto/assembly'
+import { ValuePb } from './ValuePb'
+import { Value } from '@graphprotocol/graph-ts/'
+
+export namespace ValuesPb {
+  export function encode(message: Array<Value>, writer: Writer): void {
+    const values = message
+    for (let i: i32 = 0; i < values.length; ++i) {
+      writer.uint32(10)
+      writer.fork()
+      ValuePb.encode(values[i], writer)
+      writer.ldelim()
+    }
+  }
+
+  export function decode(reader: Reader, length: i32): Array<Value> {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new Array<Value>()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.push(ValuePb.decode(reader, reader.uint32()))
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+}

package/API/v1/store/store.ts

@@ -0,0 +1,78 @@
+import { EntityPb } from './EntityPb'
+import { EntitiesPb } from './EntitiesPb'
+import { Entity } from '@graphprotocol/graph-ts/'
+import {
+  findProtobuOrNull,
+  storeString,
+  storeProtobuf
+} from '../../../utils/pdk'
+
+/**
+ * Host store interface.
+ */
+export declare namespace store {
+  function hostGet(entity: u64, id: u64): u64
+  function hostGet_in_block(entity: u64, id: u64): u64
+  function hostLoadRelated(entity: u64, id: u64, field: u64): u64
+  function hostSet(entity: u64, id: u64, data: u64): void
+  function hostRemove(entity: u64, id: u64): void
+}
+
+export namespace store {
+  export function get(entity: string, id: string): Entity | null {
+    const entityMem = storeString(entity)
+    const idMem = storeString(id)
+    const resultOffset = store.hostGet(entityMem.offset, idMem.offset)
+    entityMem.free()
+    idMem.free()
+    return findProtobuOrNull<Entity>(resultOffset, EntityPb.decode)
+  }
+
+  export function get_in_block(entity: string, id: string): Entity | null {
+    const entityMem = storeString(entity)
+    const idMem = storeString(id)
+    const resultOffset = store.hostGet_in_block(entityMem.offset, idMem.offset)
+    entityMem.free()
+    idMem.free()
+    return findProtobuOrNull<Entity>(resultOffset, EntityPb.decode)
+  }
+
+  export function loadRelated(
+    entity: string,
+    id: string,
+    field: string
+  ): Array<Entity> {
+    const entityMem = storeString(entity)
+    const idMem = storeString(id)
+    const fieldMem = storeString(field)
+
+    const resultOffset = store.hostLoadRelated(
+      entityMem.offset,
+      idMem.offset,
+      fieldMem.offset
+    )
+
+    entityMem.free()
+    idMem.free()
+    fieldMem.free()
+    return findProtobuOrNull(resultOffset, EntitiesPb.decode) || []
+  }
+
+  export function set(entity: string, id: string, data: Entity): void {
+    const entityMem = storeString(entity)
+    const idMem = storeString(id)
+    const dataMem = storeProtobuf(data, EntityPb.encode)
+    store.hostSet(entityMem.offset, idMem.offset, dataMem.offset)
+    entityMem.free()
+    idMem.free()
+    dataMem.free()
+  }
+
+  export function remove(entity: string, id: string): void {
+    const entityMem = storeString(entity)
+    const idMem = storeString(id)
+    store.hostRemove(entityMem.offset, idMem.offset)
+    entityMem.free()
+    idMem.free()
+  }
+}

package/API/v1/typeConversion/typeConversion.ts

@@ -0,0 +1,57 @@
+import { Bytes } from '@graphprotocol/graph-ts/'
+import {
+  findUint8Array,
+  findString,
+  storeString,
+  storeUint8Array,
+  findStringOrNull
+} from '../../../utils/pdk'
+
+/** Host type conversion interface */
+export declare namespace typeConversion {
+  function hostBytesToString(bytes: u64): u64
+  function hostBytesToHex(bytes: u64): u64
+  function hostBigIntToString(bigInt: u64): u64
+  function hostBigIntToHex(bigInt: u64): u64
+  function hostStringToH160(s: u64): u64
+  function hostBytesToBase58(n: u64): u64
+}
+
+export namespace typeConversion {
+  export function bytesToString(bytes: Uint8Array): string {
+    const bytesMem = storeUint8Array(bytes)
+    const resultOffset = typeConversion.hostBytesToString(bytesMem.offset)
+    bytesMem.free()
+    return findStringOrNull(resultOffset) || ''
+  }
+  export function bytesToHex(bytes: Uint8Array): string {
+    const bytesMem = storeUint8Array(bytes)
+    const resultOffset = typeConversion.hostBytesToHex(bytesMem.offset)
+    bytesMem.free()
+    return findString(resultOffset)
+  }
+  export function bigIntToString(bigInt: Uint8Array): string {
+    const bigIntMem = storeUint8Array(bigInt)
+    const resultOffset = typeConversion.hostBigIntToString(bigIntMem.offset)
+    bigIntMem.free()
+    return findString(resultOffset)
+  }
+  export function bigIntToHex(bigInt: Uint8Array): string {
+    const bigIntMem = storeUint8Array(bigInt)
+    const resultOffset = typeConversion.hostBigIntToHex(bigIntMem.offset)
+    bigIntMem.free()
+    return findString(resultOffset)
+  }
+  export function stringToH160(s: string): Bytes {
+    const sMem = storeString(s)
+    const resultOffset = typeConversion.hostStringToH160(sMem.offset)
+    sMem.free()
+    return changetype<Bytes>(findUint8Array(resultOffset))
+  }
+  export function bytesToBase58(n: Uint8Array): string {
+    const nMem = storeUint8Array(n)
+    const resultOffset = typeConversion.hostBytesToBase58(nMem.offset)
+    nMem.free()
+    return findStringOrNull(resultOffset) || ''
+  }
+}

package/API/v1/watcher/WatcherInput.ts

@@ -0,0 +1,9 @@
+import { Entity } from '../../../@graphprotocol/graph-ts'
+
+export class WatcherInput {
+  position: Entity
+
+  constructor(position: Entity) {
+    this.position = position
+  }
+}