datai-sdk 1.0.0

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

@@ -0,0 +1,156 @@
+// Side-effect to evaluate eagerly the offset of stub AS runtime
+import './common/eager_offset';
+import { ByteArray, Bytes, Entity } from './common/collections';
+import { Value } from './common/value';
+
+// Arweave support
+export * from './chain/arweave';
+// Ethereum support
+export * from './chain/ethereum';
+// NEAR support
+export * from './chain/near';
+// Cosmos support
+export * from './chain/cosmos';
+// Starknet support
+export * from './chain/starknet';
+// Regular re-exports
+export * from './common/collections';
+export * from './common/conversion';
+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';
+
+
+// /** Host IPFS interface */
+// export declare namespace ipfs {
+//   function cat(hash: string): Bytes | null;
+//   function map(hash: string, callback: string, userData: Value, flags: string[]): void;
+// }
+
+// export namespace ipfs {
+//   export function mapJSON(hash: string, callback: string, userData: Value): void {
+//     ipfs.map(hash, callback, userData, ['json']);
+//   }
+// }
+
+// /**
+//  * Special function for ENS name lookups, not meant for general purpose use.
+//  * This function will only be useful if the graph-node instance has additional
+//  * data loaded **
+//  */
+// export declare namespace ens {
+//   function nameByHash(hash: string): string | null;
+// }
+
+function format(fmt: string, args: string[]): string {
+  let out = '';
+  let argIndex = 0;
+  for (let i: i32 = 0, len: i32 = fmt.length; i < len; i++) {
+    if (
+      i < len - 1 &&
+      fmt.charCodeAt(i) == 0x7b /* '{' */ &&
+      fmt.charCodeAt(i + 1) == 0x7d /* '}' */
+    ) {
+      if (argIndex >= args.length) {
+        throw new Error('Too few arguments for format string: ' + fmt);
+      } else {
+        out += args[argIndex++];
+        i++;
+      }
+    } else {
+      out += fmt.charAt(i);
+    }
+  }
+  return out;
+}
+
+export namespace log {
+  export const log = API.log.log;
+
+  export enum Level {
+    CRITICAL = 0,
+    ERROR = 1,
+    WARNING = 2,
+    INFO = 3,
+    DEBUG = 4,
+  }
+
+  /**
+   * Logs a critical message that terminates the subgraph.
+   *
+   * @param msg Format string a la "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function critical(msg: string, args: Array<string>): void {
+    log(Level.CRITICAL, format(msg, args));
+  }
+
+  /**
+   * Logs an error message.
+   *
+   * @param msg Format string a la "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function error(msg: string, args: Array<string>): void {
+    log(Level.ERROR, format(msg, args));
+  }
+
+  /** Logs a warning message.
+   *
+   * @param msg Format string a la "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function warning(msg: string, args: Array<string>): void {
+    log(Level.WARNING, format(msg, args));
+  }
+
+  /** Logs an info message.
+   *
+   * @param msg Format string a la "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function info(msg: string, args: Array<string>): void {
+    log(Level.INFO, format(msg, args));
+  }
+
+  /** Logs a debug message.
+   *
+   * @param msg Format string a la "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function debug(msg: string, args: Array<string>): void {
+    log(Level.DEBUG, format(msg, args));
+  }
+}
+
+/**
+ * Helper functions for Ethereum.
+ */
+export namespace EthereumUtils {
+  /**
+   * Returns the contract address that would result from the given CREATE2 call.
+   * @param from The Ethereum address of the account that is initiating the contract creation.
+   * @param salt A 32-byte value that is used to create a deterministic address for the contract. This can be any arbitrary value, but it should be unique to the contract being created.
+   * @param initCodeHash he compiled code that will be executed when the contract is created. This should be a hex-encoded string that represents the compiled bytecode.
+   * @returns Address of the contract that would be created.
+   */
+  export function getCreate2Address(from: Bytes, salt: Bytes, initCodeHash: Bytes): Bytes {
+    return Bytes.fromHexString(
+      Bytes.fromByteArray(
+        API.crypto.keccak256(
+          Bytes.fromHexString(
+            '0xff' +
+              from.toHexString().slice(2) +
+              salt.toHexString().slice(2) +
+              initCodeHash.toHexString().slice(2),
+          ),
+        ),
+      )
+        .toHexString()
+        .slice(26),
+    );
+  }
+}

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

@@ -0,0 +1,3 @@
+{
+  "ascMain": "index.ts"
+}

package/@graphprotocol/graph-ts/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../../../node_modules/assemblyscript/std/assembly.json",
+  "include": ["index.ts", "helper-functions.ts", "global/global.ts", "test"]
+}

package/@graphprotocol/graph-ts/types/tsconfig.base.json

@@ -0,0 +1,3 @@
+{
+  "extends": "assemblyscript/std/assembly"
+}

package/API/index.ts

@@ -0,0 +1 @@
+export * from './v1'

package/API/v1/activePositions/ActivePositionsResult.ts

@@ -0,0 +1,147 @@
+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'
+import { TokenBalance } from './TokenBalance'
+
+export class ActivePositionsResult extends ActivePositionsResultPb {
+  tokenBalance(tokenBalances: Array<TokenBalancePb>, index: i32): TokenBalance {
+    return changetype<TokenBalance>(tokenBalances[index])
+  }
+
+  findTokenBalance(
+    tokenBalances: Array<TokenBalancePb>,
+    tokenAddress: Address,
+    tokenId: BigInt | null = null
+  ): TokenBalance | null {
+    for (let i = 0; i < tokenBalances.length; i++) {
+      const tokenBalance = this.tokenBalance(tokenBalances, i)
+      if (
+        tokenBalance.tokenAddress === tokenAddress &&
+        (!tokenId || tokenBalance.tokenId == tokenId)
+      ) {
+        return tokenBalance
+      }
+    }
+    return null
+  }
+
+  findBalance(
+    tokenBalances: Array<TokenBalancePb>,
+    tokenAddress: Address,
+    tokenId: BigInt | null = null
+  ): BigInt | null {
+    const tokenBalance = this.findTokenBalance(
+      tokenBalances,
+      tokenAddress,
+      tokenId
+    )
+    if (tokenBalance == null) {
+      return null
+    }
+    return tokenBalance.balance
+  }
+
+  setBalance(
+    tokenBalances: Array<TokenBalancePb>,
+    balance: BigInt,
+    tokenAddress: Address,
+    tokenId: BigInt | null = null
+  ): void {
+    let tokenBalance = this.findTokenBalance(
+      tokenBalances,
+      tokenAddress,
+      tokenId
+    )
+    if (tokenBalance === null) {
+      tokenBalance = new TokenBalance()
+      tokenBalances.push(tokenBalance)
+    }
+    tokenBalance.tokenAddress = tokenAddress
+    tokenBalance.balance = balance
+    if (tokenId) tokenBalance.tokenId = tokenId
+  }
+
+  supplyBalance(
+    tokenAddress: Address,
+    tokenId: BigInt | null = null
+  ): BigInt | null {
+    return this.findBalance(this.supplyTokens, tokenAddress, tokenId)
+  }
+
+  setSupplyBalance(
+    tokenAddress: Address,
+    balance: BigInt,
+    tokenId: BigInt | null = null
+  ): void {
+    this.setBalance(this.supplyTokens, balance, tokenAddress, tokenId)
+  }
+
+  borrowBalance(
+    tokenAddress: Address,
+    tokenId: BigInt | null = null
+  ): BigInt | null {
+    return this.findBalance(this.borrowTokens, tokenAddress, tokenId)
+  }
+
+  setBorrowBalance(
+    tokenAddress: Address,
+    balance: BigInt,
+    tokenId: BigInt | null = null
+  ): void {
+    this.setBalance(this.borrowTokens, balance, tokenAddress, tokenId)
+  }
+
+  rewardBalance(
+    tokenAddress: Address,
+    tokenId: BigInt | null = null
+  ): BigInt | null {
+    return this.findBalance(this.rewardTokens, tokenAddress, tokenId)
+  }
+
+  setRewardBalance(
+    tokenAddress: Address,
+    balance: BigInt,
+    tokenId: BigInt | null = null
+  ): void {
+    this.setBalance(this.rewardTokens, balance, tokenAddress, tokenId)
+  }
+
+  set poolAddress(poolAddress: Address) {
+    this.poolAddressBytes = poolAddress
+  }
+
+  get poolAddress(): Address {
+    return changetype<Address>(this.poolAddressBytes)
+  }
+
+  set unlockTime(seconds: i64) {
+    if (seconds == 0) {
+      this.unlockTimestamp = null
+      return
+    }
+    if (!this.unlockTimestamp) {
+      this.unlockTimestamp = new Timestamp()
+    }
+    this.unlockTimestamp!.seconds = seconds
+  }
+
+  get unlockTime(): i64 {
+    if (!this.unlockTimestamp) {
+      return 0
+    }
+    return this.unlockTimestamp.seconds
+  }
+
+  setPositionTokenBalance(
+    tokenAddress: Address,
+    balance: BigInt,
+    tokenId: BigInt | null = null
+  ): void {
+    const positionToken = new TokenBalance()
+    this.positionToken = positionToken
+    positionToken.tokenAddressBytes = tokenAddress
+    positionToken.balanceBytes = balance
+    if (tokenId) positionToken.tokenId = tokenId
+  }
+}

package/API/v1/activePositions/TokenBalance.ts

@@ -0,0 +1,25 @@
+import { Address, BigInt } from '../../../@graphprotocol/graph-ts'
+import { TokenBalancePb } from '../proto/activePositions/TokenBalancePb'
+
+export class TokenBalance extends TokenBalancePb {
+  get tokenAddress(): Address {
+    return changetype<Address>(this.tokenAddressBytes)
+  }
+  set tokenAddress(value: Address) {
+    this.tokenAddressBytes = value
+  }
+
+  get balance(): BigInt {
+    return changetype<BigInt>(this.balanceBytes)
+  }
+  set balance(value: BigInt) {
+    this.balanceBytes = value
+  }
+
+  get tokenId(): BigInt {
+    return changetype<BigInt>(this.tokenIdBytes)
+  }
+  set tokenId(value: BigInt) {
+    this.tokenIdBytes = value
+  }
+}

package/API/v1/activePositions/activePositions.ts

@@ -0,0 +1,37 @@
+import { Protobuf } from 'as-proto/assembly'
+import { watcher } from '../watcher/watcher'
+import { ActivePositionsResult } from './ActivePositionsResult'
+import { ActivePositionsResultPb } from '../proto/activePositions/ActivePositionsResultPb'
+
+export namespace activePositions {
+  export function inputPosition<T>(): T {
+    return changetype<T>(watcher.input().position)
+  }
+
+  const resultTypeUrl = 'API/v1/activePositions/ActivePositionsResultPb'
+
+  export function output(
+    result: ActivePositionsResult,
+    forceInactive: bool = false
+  ): void {
+    let isActive = result.supplyTokens.some((token) =>
+      token.balanceBytes.some((byte) => byte != 0)
+    )
+    isActive =
+      isActive ||
+      result.borrowTokens.some((token) =>
+        token.balanceBytes.some((byte) => byte != 0)
+      )
+    isActive = isActive && !forceInactive
+
+    const resultMsg = Protobuf.encode(
+      result as ActivePositionsResultPb,
+      ActivePositionsResultPb.encode
+    )
+    watcher.output(
+      resultTypeUrl,
+      resultMsg,
+      isActive ? watcher.SCHEDULE_DEFAULT : ''
+    )
+  }
+}

package/API/v1/bigDecimal/BigDecimalPb.ts

@@ -0,0 +1,40 @@
+// 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 { BigDecimal, BigInt } from '@graphprotocol/graph-ts/'
+
+export namespace BigDecimalPb {
+  export function encode(message: BigDecimal, writer: Writer): void {
+    writer.uint32(10)
+    writer.bytes(message.digits)
+
+    writer.uint32(16)
+    writer.int32(message.exp.toI32())
+  }
+
+  export function decode(reader: Reader, length: i32): BigDecimal {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new BigDecimal(BigInt.zero())
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.digits = changetype<BigInt>(reader.bytes())
+          break
+
+        case 2:
+          message.exp = BigInt.fromI32(reader.int32())
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+}

package/API/v1/bigDecimal/bigDecimal.ts

@@ -0,0 +1,75 @@
+import { BigDecimal } from '@graphprotocol/graph-ts/'
+import {
+  findString,
+  storeString,
+  storeProtobuf,
+  findProtobuf
+} from '../../../utils/pdk'
+import { BigDecimalPb } from '../bigDecimal/BigDecimalPb'
+
+/** Host interface for BigDecimal */
+export declare namespace bigDecimal {
+  function hostPlus(x: u64, y: u64): u64
+  function hostMinus(x: u64, y: u64): u64
+  function hostTimes(x: u64, y: u64): u64
+  function hostDividedBy(x: u64, y: u64): u64
+  function hostCompare(x: u64, y: u64): u32
+  function hostToString(bigDecimal: u64): u64
+  function hostFromString(s: u64): u64
+}
+
+export namespace bigDecimal {
+  export function plus(x: BigDecimal, y: BigDecimal): BigDecimal {
+    const xMem = storeProtobuf(x, BigDecimalPb.encode)
+    const yMem = storeProtobuf(y, BigDecimalPb.encode)
+    const resultOffset = bigDecimal.hostPlus(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return findProtobuf<BigDecimal>(resultOffset, BigDecimalPb.decode)
+  }
+  export function minus(x: BigDecimal, y: BigDecimal): BigDecimal {
+    const xMem = storeProtobuf(x, BigDecimalPb.encode)
+    const yMem = storeProtobuf(y, BigDecimalPb.encode)
+    const resultOffset = bigDecimal.hostMinus(xMem.offset, yMem.offset)
+    return findProtobuf<BigDecimal>(resultOffset, BigDecimalPb.decode)
+  }
+  export function times(x: BigDecimal, y: BigDecimal): BigDecimal {
+    const xMem = storeProtobuf(x, BigDecimalPb.encode)
+    const yMem = storeProtobuf(y, BigDecimalPb.encode)
+    const resultOffset = bigDecimal.hostTimes(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return findProtobuf<BigDecimal>(resultOffset, BigDecimalPb.decode)
+  }
+  export function dividedBy(x: BigDecimal, y: BigDecimal): BigDecimal {
+    const xMem = storeProtobuf(x, BigDecimalPb.encode)
+    const yMem = storeProtobuf(y, BigDecimalPb.encode)
+    const resultOffset = bigDecimal.hostDividedBy(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return findProtobuf<BigDecimal>(resultOffset, BigDecimalPb.decode)
+  }
+  export function compare(x: BigDecimal, y: BigDecimal): i32 {
+    const xMem = storeProtobuf(x, BigDecimalPb.encode)
+    const yMem = storeProtobuf(y, BigDecimalPb.encode)
+    const result = bigDecimal.hostCompare(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return result
+  }
+  export function equals(x: BigDecimal, y: BigDecimal): boolean {
+    return compare(x, y) == 0
+  }
+  export function toString(n: BigDecimal): string {
+    const nMem = storeProtobuf(n, BigDecimalPb.encode)
+    const resultOffset = bigDecimal.hostToString(nMem.offset)
+    nMem.free()
+    return findString(resultOffset)
+  }
+  export function fromString(s: string): BigDecimal {
+    const sMem = storeString(s)
+    const resultOffset = bigDecimal.hostFromString(sMem.offset)
+    sMem.free()
+    return findProtobuf<BigDecimal>(resultOffset, BigDecimalPb.decode)
+  }
+}

package/API/v1/bigInt/bigInt.ts

@@ -0,0 +1,123 @@
+import { BigInt, BigDecimal } from '@graphprotocol/graph-ts/'
+import {
+  findUint8Array,
+  storeString,
+  storeUint8Array,
+  storeProtobuf,
+  findProtobuf
+} from '../../../utils/pdk'
+import { BigDecimalPb } from '../bigDecimal/BigDecimalPb'
+
+/** Host interface for BigInt arithmetic */
+export declare namespace bigInt {
+  function hostPlus(x: u64, y: u64): u64
+  function hostMinus(x: u64, y: u64): u64
+  function hostTimes(x: u64, y: u64): u64
+  function hostDividedBy(x: u64, y: u64): u64
+  function hostDividedByDecimal(x: u64, y: u64): u64
+  function hostMod(x: u64, y: u64): u64
+  function hostPow(x: u64, exp: u32): u64
+  function hostFromString(s: u64): u64
+  function hostBitOr(x: u64, y: u64): u64
+  function hostBitAnd(x: u64, y: u64): u64
+  function hostLeftShift(x: u64, bits: u32): u64
+  function hostRightShift(x: u64, bits: u32): u64
+  function hostSqrt(x: u64): u64
+}
+
+export namespace bigInt {
+  export function plus(x: BigInt, y: BigInt): BigInt {
+    const xMem = storeUint8Array(x)
+    const yMem = storeUint8Array(y)
+    const resultOffset = bigInt.hostPlus(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function minus(x: BigInt, y: BigInt): BigInt {
+    const xMem = storeUint8Array(x)
+    const yMem = storeUint8Array(y)
+    const resultOffset = bigInt.hostMinus(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function times(x: BigInt, y: BigInt): BigInt {
+    const xMem = storeUint8Array(x)
+    const yMem = storeUint8Array(y)
+    const resultOffset = bigInt.hostTimes(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function dividedBy(x: BigInt, y: BigInt): BigInt {
+    const xMem = storeUint8Array(x)
+    const yMem = storeUint8Array(y)
+    const resultOffset = bigInt.hostDividedBy(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function dividedByDecimal(x: BigInt, y: BigDecimal): BigDecimal {
+    const xMem = storeUint8Array(x)
+    const yMem = storeProtobuf(y, BigDecimalPb.encode)
+    const resultOffset = bigInt.hostMod(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return findProtobuf(resultOffset, BigDecimalPb.decode)
+  }
+  export function mod(x: BigInt, y: BigInt): BigInt {
+    const xMem = storeUint8Array(x)
+    const yMem = storeUint8Array(y)
+    const resultOffset = bigInt.hostMod(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function pow(x: BigInt, exp: u8): BigInt {
+    const xMem = storeUint8Array(x)
+    const resultOffset = bigInt.hostPow(xMem.offset, exp)
+    xMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function fromString(s: string): BigInt {
+    const sMem = storeString(s)
+    const resultOffset = bigInt.hostFromString(sMem.offset)
+    sMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function bitOr(x: BigInt, y: BigInt): BigInt {
+    const xMem = storeUint8Array(x)
+    const yMem = storeUint8Array(y)
+    const resultOffset = bigInt.hostBitOr(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function bitAnd(x: BigInt, y: BigInt): BigInt {
+    const xMem = storeUint8Array(x)
+    const yMem = storeUint8Array(y)
+    const resultOffset = bigInt.hostBitAnd(xMem.offset, yMem.offset)
+    xMem.free()
+    yMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function leftShift(x: BigInt, bits: u8): BigInt {
+    const xMem = storeUint8Array(x)
+    const resultOffset = bigInt.hostLeftShift(xMem.offset, bits)
+    xMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function rightShift(x: BigInt, bits: u8): BigInt {
+    const xMem = storeUint8Array(x)
+    const resultOffset = bigInt.hostRightShift(xMem.offset, bits)
+    xMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+  export function sqrt(x: BigInt): BigInt {
+    const xMem = storeUint8Array(x)
+    const resultOffset = bigInt.hostSqrt(xMem.offset)
+    xMem.free()
+    return changetype<BigInt>(findUint8Array(resultOffset))
+  }
+}

package/API/v1/crypto/crypto.ts

@@ -0,0 +1,16 @@
+import { ByteArray } from '@graphprotocol/graph-ts/'
+import { findUint8Array, storeUint8Array } from '../../../utils/pdk'
+
+/** Host crypto utilities interface */
+export declare namespace crypto {
+  function hostKeccak256(input: u64): u64
+}
+
+export namespace crypto {
+  export function keccak256(input: ByteArray): ByteArray {
+    const inputMem = storeUint8Array(input)
+    const resultOffset = crypto.hostKeccak256(inputMem.offset)
+    inputMem.free()
+    return changetype<ByteArray>(findUint8Array(resultOffset))
+  }
+}