datai-sdk 1.0.0

package/API/v1/proto/ethereum/SmartContractCallPb.ts

@@ -0,0 +1,102 @@
+// 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 { ValuesPb } from './ValuesPb'
+
+export class SmartContractCallPb {
+  static encode(message: SmartContractCallPb, writer: Writer): void {
+    writer.uint32(10)
+    writer.string(message.contractName)
+
+    writer.uint32(18)
+    writer.bytes(message.contractAddress)
+
+    writer.uint32(26)
+    writer.string(message.functionName)
+
+    writer.uint32(34)
+    writer.string(message.functionSignature)
+
+    const functionParams = message.functionParams
+    if (functionParams !== null) {
+      writer.uint32(42)
+      writer.fork()
+      ValuesPb.encode(functionParams, writer)
+      writer.ldelim()
+    }
+  }
+
+  static decode(reader: Reader, length: i32): SmartContractCallPb {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new SmartContractCallPb()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.contractName = reader.string()
+          break
+
+        case 2:
+          message.contractAddress = reader.bytes()
+          break
+
+        case 3:
+          message.functionName = reader.string()
+          break
+
+        case 4:
+          message.functionSignature = reader.string()
+          break
+
+        case 5:
+          message.functionParams = ValuesPb.decode(reader, reader.uint32())
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  contractName: string
+  contractAddress: Uint8Array
+  functionName: string
+  functionSignature: string
+  functionParams: ValuesPb | null
+
+  constructor(
+    contractName: string = '',
+    contractAddress: Uint8Array = new Uint8Array(0),
+    functionName: string = '',
+    functionSignature: string = '',
+    functionParams: ValuesPb | null = null
+  ) {
+    this.contractName = contractName
+    this.contractAddress = contractAddress
+    this.functionName = functionName
+    this.functionSignature = functionSignature
+    this.functionParams = functionParams
+  }
+}
+
+export function encodeSmartContractCallPb(
+  message: SmartContractCallPb
+): Uint8Array {
+  return Protobuf.encode(message, SmartContractCallPb.encode)
+}
+
+export function decodeSmartContractCallPb(
+  buffer: Uint8Array
+): SmartContractCallPb {
+  return Protobuf.decode<SmartContractCallPb>(
+    buffer,
+    SmartContractCallPb.decode
+  )
+}

package/API/v1/proto/ethereum/ValueKindPb.ts

@@ -0,0 +1,17 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v3.21.12
+
+export enum ValueKindPb {
+  ADDRESS = 0,
+  FIXED_BYTES = 1,
+  BYTES = 2,
+  INT = 3,
+  UINT = 4,
+  BOOL = 5,
+  STRING = 6,
+  FIXED_ARRAY = 7,
+  ARRAY = 8,
+  TUPLE = 9
+}

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

@@ -0,0 +1,96 @@
+// 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 { 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(818)
+    writer.bytes(message.bytesData)
+
+    writer.uint32(840)
+    writer.bool(message.boolData)
+
+    writer.uint32(850)
+    writer.string(message.stringData)
+
+    const arrayData = message.arrayData
+    if (arrayData !== null) {
+      writer.uint32(866)
+      writer.fork()
+      ValuesPb.encode(arrayData, writer)
+      writer.ldelim()
+    }
+  }
+
+  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 102:
+          message.bytesData = reader.bytes()
+          break
+
+        case 105:
+          message.boolData = reader.bool()
+          break
+
+        case 106:
+          message.stringData = reader.string()
+          break
+
+        case 108:
+          message.arrayData = ValuesPb.decode(reader, reader.uint32())
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  kind: ValueKindPb
+  bytesData: Uint8Array
+  boolData: bool
+  stringData: string
+  arrayData: ValuesPb | null
+
+  constructor(
+    kind: ValueKindPb = 0,
+    bytesData: Uint8Array = new Uint8Array(0),
+    boolData: bool = false,
+    stringData: string = '',
+    arrayData: ValuesPb | null = null
+  ) {
+    this.kind = kind
+    this.bytesData = bytesData
+    this.boolData = boolData
+    this.stringData = stringData
+    this.arrayData = arrayData
+  }
+}
+
+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/ethereum/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/google/protobuf/Any.ts

@@ -0,0 +1,56 @@
+// 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'
+
+export class Any {
+  static encode(message: Any, writer: Writer): void {
+    writer.uint32(10)
+    writer.string(message.typeUrl)
+
+    writer.uint32(18)
+    writer.bytes(message.value)
+  }
+
+  static decode(reader: Reader, length: i32): Any {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new Any()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.typeUrl = reader.string()
+          break
+
+        case 2:
+          message.value = reader.bytes()
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  typeUrl: string
+  value: Uint8Array
+
+  constructor(typeUrl: string = '', value: Uint8Array = new Uint8Array(0)) {
+    this.typeUrl = typeUrl
+    this.value = value
+  }
+}
+
+export function encodeAny(message: Any): Uint8Array {
+  return Protobuf.encode(message, Any.encode)
+}
+
+export function decodeAny(buffer: Uint8Array): Any {
+  return Protobuf.decode<Any>(buffer, Any.decode)
+}

package/API/v1/proto/google/protobuf/Timestamp.ts

@@ -0,0 +1,56 @@
+// 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'
+
+export class Timestamp {
+  static encode(message: Timestamp, writer: Writer): void {
+    writer.uint32(8)
+    writer.int64(message.seconds)
+
+    writer.uint32(16)
+    writer.int32(message.nanos)
+  }
+
+  static decode(reader: Reader, length: i32): Timestamp {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new Timestamp()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.seconds = reader.int64()
+          break
+
+        case 2:
+          message.nanos = reader.int32()
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  seconds: i64
+  nanos: i32
+
+  constructor(seconds: i64 = 0, nanos: i32 = 0) {
+    this.seconds = seconds
+    this.nanos = nanos
+  }
+}
+
+export function encodeTimestamp(message: Timestamp): Uint8Array {
+  return Protobuf.encode(message, Timestamp.encode)
+}
+
+export function decodeTimestamp(buffer: Uint8Array): Timestamp {
+  return Protobuf.decode<Timestamp>(buffer, Timestamp.decode)
+}

package/API/v1/proto/store/EntitiesPb.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 { EntityPb } from './EntityPb'
+
+export class EntitiesPb {
+  static encode(message: EntitiesPb, writer: Writer): void {
+    const items = message.items
+    for (let i: i32 = 0; i < items.length; ++i) {
+      writer.uint32(10)
+      writer.fork()
+      EntityPb.encode(items[i], writer)
+      writer.ldelim()
+    }
+  }
+
+  static decode(reader: Reader, length: i32): EntitiesPb {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new EntitiesPb()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.items.push(EntityPb.decode(reader, reader.uint32()))
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  items: Array<EntityPb>
+
+  constructor(items: Array<EntityPb> = []) {
+    this.items = items
+  }
+}
+
+export function encodeEntitiesPb(message: EntitiesPb): Uint8Array {
+  return Protobuf.encode(message, EntitiesPb.encode)
+}
+
+export function decodeEntitiesPb(buffer: Uint8Array): EntitiesPb {
+  return Protobuf.decode<EntitiesPb>(buffer, EntitiesPb.decode)
+}

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

@@ -0,0 +1,99 @@
+// 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 EntityPb {
+  static encode(message: EntityPb, writer: Writer): void {
+    const entries = message.entries
+    if (entries !== null) {
+      const entriesKeys = entries.keys()
+      for (let i: i32 = 0; i < entriesKeys.length; ++i) {
+        const entriesKey = entriesKeys[i]
+        writer.uint32(10)
+        writer.fork()
+        writer.uint32(10)
+        writer.string(entriesKey)
+        writer.uint32(18)
+        writer.fork()
+        ValuePb.encode(entries.get(entriesKey), writer)
+        writer.ldelim()
+        writer.ldelim()
+      }
+    }
+  }
+
+  static decode(reader: Reader, length: i32): EntityPb {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new EntityPb()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          let entriesKey: string = ''
+          let entriesValue: ValuePb | 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 (message.entries === null) {
+              message.entries = new Map<string, ValuePb>()
+            }
+            const entries = message.entries
+            if (
+              entries !== null &&
+              entriesHasKey &&
+              entriesHasValue &&
+              entriesValue !== null
+            ) {
+              entries.set(entriesKey, entriesValue)
+            }
+          }
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  entries: Map<string, ValuePb>
+
+  constructor(entries: Map<string, ValuePb> = new Map()) {
+    this.entries = entries
+  }
+}
+
+export function encodeEntityPb(message: EntityPb): Uint8Array {
+  return Protobuf.encode(message, EntityPb.encode)
+}
+
+export function decodeEntityPb(buffer: Uint8Array): EntityPb {
+  return Protobuf.decode<EntityPb>(buffer, EntityPb.decode)
+}

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

@@ -0,0 +1,75 @@
+// 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 { EntityPb } from './EntityPb'
+
+export class EntityWithMetaPb {
+  static encode(message: EntityWithMetaPb, writer: Writer): void {
+    const entity = message.entity
+    if (entity !== null) {
+      writer.uint32(10)
+      writer.fork()
+      EntityPb.encode(entity, writer)
+      writer.ldelim()
+    }
+
+    writer.uint32(18)
+    writer.string(message.idField)
+
+    writer.uint32(24)
+    writer.bool(message.isImmutable)
+  }
+
+  static decode(reader: Reader, length: i32): EntityWithMetaPb {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new EntityWithMetaPb()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.entity = EntityPb.decode(reader, reader.uint32())
+          break
+
+        case 2:
+          message.idField = reader.string()
+          break
+
+        case 3:
+          message.isImmutable = reader.bool()
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  entity: EntityPb | null
+  idField: string
+  isImmutable: bool
+
+  constructor(
+    entity: EntityPb | null = null,
+    idField: string = '',
+    isImmutable: bool = false
+  ) {
+    this.entity = entity
+    this.idField = idField
+    this.isImmutable = isImmutable
+  }
+}
+
+export function encodeEntityWithMetaPb(message: EntityWithMetaPb): Uint8Array {
+  return Protobuf.encode(message, EntityWithMetaPb.encode)
+}
+
+export function decodeEntityWithMetaPb(buffer: Uint8Array): EntityWithMetaPb {
+  return Protobuf.decode<EntityWithMetaPb>(buffer, EntityWithMetaPb.decode)
+}

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

@@ -0,0 +1,17 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v3.21.12
+
+export enum ValueKindPb {
+  STRING = 0,
+  INT = 1,
+  BIGDECIMAL = 2,
+  BOOL = 3,
+  ARRAY = 4,
+  NULL = 5,
+  BYTES = 6,
+  BIGINT = 7,
+  INT8 = 8,
+  TIMESTAMP = 9
+}