datai-sdk 1.0.1 → 1.0.2

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

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

@@ -3,54 +3,54 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from "as-proto/assembly";
+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(10)
+    writer.string(message.typeUrl)
 
-    writer.uint32(18);
-    writer.bytes(message.value);
+    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();
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new Any()
 
     while (reader.ptr < end) {
-      const tag = reader.uint32();
+      const tag = reader.uint32()
       switch (tag >>> 3) {
         case 1:
-          message.typeUrl = reader.string();
-          break;
+          message.typeUrl = reader.string()
+          break
 
         case 2:
-          message.value = reader.bytes();
-          break;
+          message.value = reader.bytes()
+          break
 
         default:
-          reader.skipType(tag & 7);
-          break;
+          reader.skipType(tag & 7)
+          break
       }
     }
 
-    return message;
+    return message
   }
 
-  typeUrl: string;
-  value: Uint8Array;
+  typeUrl: string
+  value: Uint8Array
 
-  constructor(typeUrl: string = "", value: Uint8Array = new Uint8Array(0)) {
-    this.typeUrl = typeUrl;
-    this.value = value;
+  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);
+  return Protobuf.encode(message, Any.encode)
 }
 
 export function decodeAny(buffer: Uint8Array): Any {
-  return Protobuf.decode<Any>(buffer, Any.decode);
+  return Protobuf.decode<Any>(buffer, Any.decode)
 }

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

@@ -3,54 +3,54 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from "as-proto/assembly";
+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(8)
+    writer.int64(message.seconds)
 
-    writer.uint32(16);
-    writer.int32(message.nanos);
+    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();
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new Timestamp()
 
     while (reader.ptr < end) {
-      const tag = reader.uint32();
+      const tag = reader.uint32()
       switch (tag >>> 3) {
         case 1:
-          message.seconds = reader.int64();
-          break;
+          message.seconds = reader.int64()
+          break
 
         case 2:
-          message.nanos = reader.int32();
-          break;
+          message.nanos = reader.int32()
+          break
 
         default:
-          reader.skipType(tag & 7);
-          break;
+          reader.skipType(tag & 7)
+          break
       }
     }
 
-    return message;
+    return message
   }
 
-  seconds: i64;
-  nanos: i32;
+  seconds: i64
+  nanos: i32
 
   constructor(seconds: i64 = 0, nanos: i32 = 0) {
-    this.seconds = seconds;
-    this.nanos = nanos;
+    this.seconds = seconds
+    this.nanos = nanos
   }
 }
 
 export function encodeTimestamp(message: Timestamp): Uint8Array {
-  return Protobuf.encode(message, Timestamp.encode);
+  return Protobuf.encode(message, Timestamp.encode)
 }
 
 export function decodeTimestamp(buffer: Uint8Array): Timestamp {
-  return Protobuf.decode<Timestamp>(buffer, Timestamp.decode);
+  return Protobuf.decode<Timestamp>(buffer, Timestamp.decode)
 }

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

@@ -3,51 +3,51 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from "as-proto/assembly";
-import { EntityPb } from "./EntityPb";
+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;
+    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();
+      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();
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new EntitiesPb()
 
     while (reader.ptr < end) {
-      const tag = reader.uint32();
+      const tag = reader.uint32()
       switch (tag >>> 3) {
         case 1:
-          message.items.push(EntityPb.decode(reader, reader.uint32()));
-          break;
+          message.items.push(EntityPb.decode(reader, reader.uint32()))
+          break
 
         default:
-          reader.skipType(tag & 7);
-          break;
+          reader.skipType(tag & 7)
+          break
       }
     }
 
-    return message;
+    return message
   }
 
-  items: Array<EntityPb>;
+  items: Array<EntityPb>
 
   constructor(items: Array<EntityPb> = []) {
-    this.items = items;
+    this.items = items
   }
 }
 
 export function encodeEntitiesPb(message: EntitiesPb): Uint8Array {
-  return Protobuf.encode(message, EntitiesPb.encode);
+  return Protobuf.encode(message, EntitiesPb.encode)
 }
 
 export function decodeEntitiesPb(buffer: Uint8Array): EntitiesPb {
-  return Protobuf.decode<EntitiesPb>(buffer, EntitiesPb.decode);
+  return Protobuf.decode<EntitiesPb>(buffer, EntitiesPb.decode)
 }

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

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

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

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