datai-sdk 1.0.1 → 1.0.2

package/@graphprotocol/graph-ts/chain/ethereum.ts

@@ -1,7 +1,7 @@
 import '../common/eager_offset';
 import { Bytes, Wrapped } from '../common/collections';
 import { Address, BigInt } from '../common/numbers';
-import * as API from '../../../API'
+import * as API from '../../../../API'
 
 export namespace ethereum {
   export const call = API.ethereum.call

package/@graphprotocol/graph-ts/common/conversion.ts

@@ -1,3 +1,3 @@
 import './eager_offset';
 
-export { typeConversion } from '../../../API';
+export { typeConversion } from '../../../../API';

package/@graphprotocol/graph-ts/common/numbers.ts

@@ -1,7 +1,7 @@
 import './eager_offset';
 import { ByteArray, Bytes } from './collections';
 import { typeConversion } from './conversion';
-import { bigInt, bigDecimal } from '../../../API'
+import { bigInt, bigDecimal } from '../../../../API'
 
 export type Int8 = i64;
 export type Timestamp = i64;

package/@graphprotocol/graph-ts/index.ts

@@ -20,8 +20,8 @@ export * from './common/datasource';
 export * from './common/json';
 export * from './common/numbers';
 export * from './common/value';
-import * as API from '../../API'
-export { store, crypto } from '../../API';
+import * as API from '../../../API'
+export { store, crypto } from '../../../API';
 
 
 // /** Host IPFS interface */

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

@@ -3,111 +3,108 @@
 //   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> = [],
@@ -117,19 +114,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(
@@ -138,5 +135,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
 }