datai-sdk 1.0.0 → 1.0.1

package/API/v1/activePositions/ActivePositionsResult.ts

@@ -1,4 +1,4 @@
-import { Address, BigInt } from '../../../@graphprotocol/graph-ts'
+import { Address, BigInt } from '@graphprotocol/graph-ts'
 import { Timestamp } from '../proto/google/protobuf/Timestamp'
 import { ActivePositionsResultPb } from '../proto/activePositions/ActivePositionsResultPb'
 import { TokenBalancePb } from '../proto/activePositions/TokenBalancePb'

package/API/v1/activePositions/TokenBalance.ts

@@ -1,4 +1,4 @@
-import { Address, BigInt } from '../../../@graphprotocol/graph-ts'
+import { Address, BigInt } from '@graphprotocol/graph-ts'
 import { TokenBalancePb } from '../proto/activePositions/TokenBalancePb'
 
 export class TokenBalance extends TokenBalancePb {

package/API/v1/proto/activePositions/ActivePositionsResultPb.ts

@@ -3,108 +3,111 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
-import { TokenBalancePb } from './TokenBalancePb'
-import { Timestamp } from '../google/protobuf/Timestamp'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
+import { TokenBalancePb } from "./TokenBalancePb";
+import { Timestamp } from "../google/protobuf/Timestamp";
 
 export class ActivePositionsResultPb {
   static encode(message: ActivePositionsResultPb, writer: Writer): void {
-    const supplyTokens = message.supplyTokens
+    const supplyTokens = message.supplyTokens;
     for (let i: i32 = 0; i < supplyTokens.length; ++i) {
-      writer.uint32(10)
-      writer.fork()
-      TokenBalancePb.encode(supplyTokens[i], writer)
-      writer.ldelim()
+      writer.uint32(10);
+      writer.fork();
+      TokenBalancePb.encode(supplyTokens[i], writer);
+      writer.ldelim();
     }
 
-    const borrowTokens = message.borrowTokens
+    const borrowTokens = message.borrowTokens;
     for (let i: i32 = 0; i < borrowTokens.length; ++i) {
-      writer.uint32(18)
-      writer.fork()
-      TokenBalancePb.encode(borrowTokens[i], writer)
-      writer.ldelim()
+      writer.uint32(18);
+      writer.fork();
+      TokenBalancePb.encode(borrowTokens[i], writer);
+      writer.ldelim();
     }
 
-    const rewardTokens = message.rewardTokens
+    const rewardTokens = message.rewardTokens;
     for (let i: i32 = 0; i < rewardTokens.length; ++i) {
-      writer.uint32(26)
-      writer.fork()
-      TokenBalancePb.encode(rewardTokens[i], writer)
-      writer.ldelim()
+      writer.uint32(26);
+      writer.fork();
+      TokenBalancePb.encode(rewardTokens[i], writer);
+      writer.ldelim();
     }
 
-    const positionToken = message.positionToken
+    const positionToken = message.positionToken;
     if (positionToken !== null) {
-      writer.uint32(34)
-      writer.fork()
-      TokenBalancePb.encode(positionToken, writer)
-      writer.ldelim()
+      writer.uint32(34);
+      writer.fork();
+      TokenBalancePb.encode(positionToken, writer);
+      writer.ldelim();
     }
 
-    const unlockTimestamp = message.unlockTimestamp
+    const unlockTimestamp = message.unlockTimestamp;
     if (unlockTimestamp !== null) {
-      writer.uint32(42)
-      writer.fork()
-      Timestamp.encode(unlockTimestamp, writer)
-      writer.ldelim()
+      writer.uint32(42);
+      writer.fork();
+      Timestamp.encode(unlockTimestamp, writer);
+      writer.ldelim();
     }
 
-    writer.uint32(50)
-    writer.bytes(message.poolAddressBytes)
+    writer.uint32(50);
+    writer.bytes(message.poolAddressBytes);
   }
 
   static decode(reader: Reader, length: i32): ActivePositionsResultPb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new ActivePositionsResultPb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new ActivePositionsResultPb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.supplyTokens.push(
             TokenBalancePb.decode(reader, reader.uint32())
-          )
-          break
+          );
+          break;
 
         case 2:
           message.borrowTokens.push(
             TokenBalancePb.decode(reader, reader.uint32())
-          )
-          break
+          );
+          break;
 
         case 3:
           message.rewardTokens.push(
             TokenBalancePb.decode(reader, reader.uint32())
-          )
-          break
+          );
+          break;
 
         case 4:
-          message.positionToken = TokenBalancePb.decode(reader, reader.uint32())
-          break
+          message.positionToken = TokenBalancePb.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
 
         case 5:
-          message.unlockTimestamp = Timestamp.decode(reader, reader.uint32())
-          break
+          message.unlockTimestamp = Timestamp.decode(reader, reader.uint32());
+          break;
 
         case 6:
-          message.poolAddressBytes = reader.bytes()
-          break
+          message.poolAddressBytes = reader.bytes();
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  supplyTokens: Array<TokenBalancePb>
-  borrowTokens: Array<TokenBalancePb>
-  rewardTokens: Array<TokenBalancePb>
-  positionToken: TokenBalancePb | null
-  unlockTimestamp: Timestamp | null
-  poolAddressBytes: Uint8Array
+  supplyTokens: Array<TokenBalancePb>;
+  borrowTokens: Array<TokenBalancePb>;
+  rewardTokens: Array<TokenBalancePb>;
+  positionToken: TokenBalancePb | null;
+  unlockTimestamp: Timestamp | null;
+  poolAddressBytes: Uint8Array;
 
   constructor(
     supplyTokens: Array<TokenBalancePb> = [],
@@ -114,19 +117,19 @@ export class ActivePositionsResultPb {
     unlockTimestamp: Timestamp | null = null,
     poolAddressBytes: Uint8Array = new Uint8Array(0)
   ) {
-    this.supplyTokens = supplyTokens
-    this.borrowTokens = borrowTokens
-    this.rewardTokens = rewardTokens
-    this.positionToken = positionToken
-    this.unlockTimestamp = unlockTimestamp
-    this.poolAddressBytes = poolAddressBytes
+    this.supplyTokens = supplyTokens;
+    this.borrowTokens = borrowTokens;
+    this.rewardTokens = rewardTokens;
+    this.positionToken = positionToken;
+    this.unlockTimestamp = unlockTimestamp;
+    this.poolAddressBytes = poolAddressBytes;
   }
 }
 
 export function encodeActivePositionsResultPb(
   message: ActivePositionsResultPb
 ): Uint8Array {
-  return Protobuf.encode(message, ActivePositionsResultPb.encode)
+  return Protobuf.encode(message, ActivePositionsResultPb.encode);
 }
 
 export function decodeActivePositionsResultPb(
@@ -135,5 +138,5 @@ export function decodeActivePositionsResultPb(
   return Protobuf.decode<ActivePositionsResultPb>(
     buffer,
     ActivePositionsResultPb.decode
-  )
+  );
 }

package/API/v1/proto/activePositions/TokenBalancePb.ts

@@ -3,67 +3,67 @@
 //   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 TokenBalancePb {
   static encode(message: TokenBalancePb, writer: Writer): void {
-    writer.uint32(10)
-    writer.bytes(message.tokenAddressBytes)
+    writer.uint32(10);
+    writer.bytes(message.tokenAddressBytes);
 
-    writer.uint32(18)
-    writer.bytes(message.tokenIdBytes)
+    writer.uint32(18);
+    writer.bytes(message.tokenIdBytes);
 
-    writer.uint32(26)
-    writer.bytes(message.balanceBytes)
+    writer.uint32(26);
+    writer.bytes(message.balanceBytes);
   }
 
   static decode(reader: Reader, length: i32): TokenBalancePb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new TokenBalancePb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new TokenBalancePb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.tokenAddressBytes = reader.bytes()
-          break
+          message.tokenAddressBytes = reader.bytes();
+          break;
 
         case 2:
-          message.tokenIdBytes = reader.bytes()
-          break
+          message.tokenIdBytes = reader.bytes();
+          break;
 
         case 3:
-          message.balanceBytes = reader.bytes()
-          break
+          message.balanceBytes = reader.bytes();
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  tokenAddressBytes: Uint8Array
-  tokenIdBytes: Uint8Array
-  balanceBytes: Uint8Array
+  tokenAddressBytes: Uint8Array;
+  tokenIdBytes: Uint8Array;
+  balanceBytes: Uint8Array;
 
   constructor(
     tokenAddressBytes: Uint8Array = new Uint8Array(0),
     tokenIdBytes: Uint8Array = new Uint8Array(0),
     balanceBytes: Uint8Array = new Uint8Array(0)
   ) {
-    this.tokenAddressBytes = tokenAddressBytes
-    this.tokenIdBytes = tokenIdBytes
-    this.balanceBytes = balanceBytes
+    this.tokenAddressBytes = tokenAddressBytes;
+    this.tokenIdBytes = tokenIdBytes;
+    this.balanceBytes = balanceBytes;
   }
 }
 
 export function encodeTokenBalancePb(message: TokenBalancePb): Uint8Array {
-  return Protobuf.encode(message, TokenBalancePb.encode)
+  return Protobuf.encode(message, TokenBalancePb.encode);
 }
 
 export function decodeTokenBalancePb(buffer: Uint8Array): TokenBalancePb {
-  return Protobuf.decode<TokenBalancePb>(buffer, TokenBalancePb.decode)
+  return Protobuf.decode<TokenBalancePb>(buffer, TokenBalancePb.decode);
 }

package/API/v1/proto/bigDecimal/BigDecimalPb.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 BigDecimalPb {
   static encode(message: BigDecimalPb, writer: Writer): void {
-    writer.uint32(10)
-    writer.bytes(message.digits)
+    writer.uint32(10);
+    writer.bytes(message.digits);
 
-    writer.uint32(16)
-    writer.int32(message.exp)
+    writer.uint32(16);
+    writer.int32(message.exp);
   }
 
   static decode(reader: Reader, length: i32): BigDecimalPb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new BigDecimalPb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new BigDecimalPb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.digits = reader.bytes()
-          break
+          message.digits = reader.bytes();
+          break;
 
         case 2:
-          message.exp = reader.int32()
-          break
+          message.exp = reader.int32();
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  digits: Uint8Array
-  exp: i32
+  digits: Uint8Array;
+  exp: i32;
 
   constructor(digits: Uint8Array = new Uint8Array(0), exp: i32 = 0) {
-    this.digits = digits
-    this.exp = exp
+    this.digits = digits;
+    this.exp = exp;
   }
 }
 
 export function encodeBigDecimalPb(message: BigDecimalPb): Uint8Array {
-  return Protobuf.encode(message, BigDecimalPb.encode)
+  return Protobuf.encode(message, BigDecimalPb.encode);
 }
 
 export function decodeBigDecimalPb(buffer: Uint8Array): BigDecimalPb {
-  return Protobuf.decode<BigDecimalPb>(buffer, BigDecimalPb.decode)
+  return Protobuf.decode<BigDecimalPb>(buffer, BigDecimalPb.decode);
 }

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

@@ -3,93 +3,93 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
-import { ValuesPb } from './ValuesPb'
+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(10);
+    writer.string(message.contractName);
 
-    writer.uint32(18)
-    writer.bytes(message.contractAddress)
+    writer.uint32(18);
+    writer.bytes(message.contractAddress);
 
-    writer.uint32(26)
-    writer.string(message.functionName)
+    writer.uint32(26);
+    writer.string(message.functionName);
 
-    writer.uint32(34)
-    writer.string(message.functionSignature)
+    writer.uint32(34);
+    writer.string(message.functionSignature);
 
-    const functionParams = message.functionParams
+    const functionParams = message.functionParams;
     if (functionParams !== null) {
-      writer.uint32(42)
-      writer.fork()
-      ValuesPb.encode(functionParams, writer)
-      writer.ldelim()
+      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()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new SmartContractCallPb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.contractName = reader.string()
-          break
+          message.contractName = reader.string();
+          break;
 
         case 2:
-          message.contractAddress = reader.bytes()
-          break
+          message.contractAddress = reader.bytes();
+          break;
 
         case 3:
-          message.functionName = reader.string()
-          break
+          message.functionName = reader.string();
+          break;
 
         case 4:
-          message.functionSignature = reader.string()
-          break
+          message.functionSignature = reader.string();
+          break;
 
         case 5:
-          message.functionParams = ValuesPb.decode(reader, reader.uint32())
-          break
+          message.functionParams = ValuesPb.decode(reader, reader.uint32());
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  contractName: string
-  contractAddress: Uint8Array
-  functionName: string
-  functionSignature: string
-  functionParams: ValuesPb | null
+  contractName: string;
+  contractAddress: Uint8Array;
+  functionName: string;
+  functionSignature: string;
+  functionParams: ValuesPb | null;
 
   constructor(
-    contractName: string = '',
+    contractName: string = "",
     contractAddress: Uint8Array = new Uint8Array(0),
-    functionName: string = '',
-    functionSignature: string = '',
+    functionName: string = "",
+    functionSignature: string = "",
     functionParams: ValuesPb | null = null
   ) {
-    this.contractName = contractName
-    this.contractAddress = contractAddress
-    this.functionName = functionName
-    this.functionSignature = functionSignature
-    this.functionParams = functionParams
+    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)
+  return Protobuf.encode(message, SmartContractCallPb.encode);
 }
 
 export function decodeSmartContractCallPb(
@@ -98,5 +98,5 @@ export function decodeSmartContractCallPb(
   return Protobuf.decode<SmartContractCallPb>(
     buffer,
     SmartContractCallPb.decode
-  )
+  );
 }

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

@@ -13,5 +13,5 @@ export enum ValueKindPb {
   STRING = 6,
   FIXED_ARRAY = 7,
   ARRAY = 8,
-  TUPLE = 9
+  TUPLE = 9,
 }

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);
 }