datai-sdk 1.0.0

package/API/v1/ethereum/SmartContractCallPb.ts

@@ -0,0 +1,84 @@
+// 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 { ethereum, Address } from '@graphprotocol/graph-ts/'
+import { ValuesPb } from './ValuesPb'
+
+export namespace SmartContractCallPb {
+  export function encode(
+    message: ethereum.SmartContractCall,
+    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()
+    }
+  }
+
+  export function decode(
+    reader: Reader,
+    length: i32
+  ): ethereum.SmartContractCall {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+
+    let contractName: string | null = null
+    let contractAddress: Address | null = null
+    let functionName: string | null = null
+    let functionSignature: string | null = null
+    let functionParams: Array<ethereum.Value> | null = null
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          contractName = reader.string()
+          break
+
+        case 2:
+          contractAddress = changetype<Address>(reader.bytes())
+          break
+
+        case 3:
+          functionName = reader.string()
+          break
+
+        case 4:
+          functionSignature = reader.string()
+          break
+
+        case 5:
+          functionParams = ValuesPb.decode(reader, reader.uint32())
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return new ethereum.SmartContractCall(
+      contractName!,
+      contractAddress!,
+      functionName!,
+      functionSignature!,
+      functionParams!
+    )
+  }
+}

package/API/v1/ethereum/ValuePb.ts

@@ -0,0 +1,113 @@
+// 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 { Bytes, BigInt, Address, ethereum } from '@graphprotocol/graph-ts/'
+import { ValuesPb } from './ValuesPb'
+
+export namespace ValuePb {
+  export function encode(message: ethereum.Value, writer: Writer): void {
+    writer.uint32(8)
+    writer.int32(message.kind)
+
+    switch (message.kind) {
+      case ethereum.ValueKind.ADDRESS:
+      case ethereum.ValueKind.FIXED_BYTES:
+      case ethereum.ValueKind.BYTES:
+      case ethereum.ValueKind.INT:
+      case ethereum.ValueKind.UINT:
+        writer.uint32(818)
+        writer.bytes(changetype<Bytes>(message.data as u32))
+        break
+
+      case ethereum.ValueKind.BOOL:
+        writer.uint32(840)
+        writer.bool(message.toBoolean())
+        break
+
+      case ethereum.ValueKind.STRING:
+        writer.uint32(850)
+        writer.string(message.toString())
+        break
+
+      case ethereum.ValueKind.FIXED_ARRAY:
+      case ethereum.ValueKind.ARRAY:
+      case ethereum.ValueKind.TUPLE:
+        const arrayData = changetype<Array<ethereum.Value>>(message.data as u32)
+        if (arrayData !== null) {
+          writer.uint32(866)
+          writer.fork()
+          ValuesPb.encode(arrayData, writer)
+          writer.ldelim()
+        }
+        break
+
+      default:
+        throw new Error('Encoding unsupported ethereum value kind')
+    }
+  }
+
+  export function decode(reader: Reader, length: i32): ethereum.Value {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    let kind: ethereum.ValueKind = 0
+    let bytesData: Uint8Array = new Uint8Array(0)
+    let boolData: bool = false
+    let stringData: string = ''
+    let arrayData: ethereum.Value[] | null = null
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          kind = reader.int32()
+          break
+
+        case 102:
+          bytesData = reader.bytes()
+          break
+
+        case 105:
+          boolData = reader.bool()
+          break
+
+        case 106:
+          stringData = reader.string()
+          break
+
+        case 108:
+          arrayData = ValuesPb.decode(reader, reader.uint32())
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    switch (kind) {
+      case ethereum.ValueKind.ADDRESS:
+        return ethereum.Value.fromAddress(changetype<Address>(bytesData))
+      case ethereum.ValueKind.FIXED_BYTES:
+        return ethereum.Value.fromFixedBytes(changetype<Bytes>(bytesData))
+      case ethereum.ValueKind.BYTES:
+        return ethereum.Value.fromBytes(changetype<Bytes>(bytesData))
+      case ethereum.ValueKind.INT:
+        return ethereum.Value.fromSignedBigInt(changetype<BigInt>(bytesData))
+      case ethereum.ValueKind.UINT:
+        return ethereum.Value.fromUnsignedBigInt(changetype<BigInt>(bytesData))
+      case ethereum.ValueKind.BOOL:
+        return ethereum.Value.fromBoolean(boolData == 1)
+      case ethereum.ValueKind.STRING:
+        return ethereum.Value.fromString(stringData)
+      case ethereum.ValueKind.FIXED_ARRAY:
+        return ethereum.Value.fromFixedSizedArray(arrayData!)
+      case ethereum.ValueKind.ARRAY:
+        return ethereum.Value.fromArray(arrayData!)
+      case ethereum.ValueKind.TUPLE:
+        return ethereum.Value.fromTuple(changetype<ethereum.Tuple>(arrayData!))
+      default:
+        throw new Error(`Unsupported kind ${kind}`)
+    }
+  }
+}

package/API/v1/ethereum/ValuesPb.ts

@@ -0,0 +1,39 @@
+// 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 { ValuePb } from './ValuePb'
+import { ethereum } from '@graphprotocol/graph-ts/'
+
+export namespace ValuesPb {
+  export function encode(message: Array<ethereum.Value>, writer: Writer): void {
+    const values = message
+    for (let i: i32 = 0; i < values.length; ++i) {
+      writer.uint32(10)
+      writer.fork()
+      ValuePb.encode(values[i], writer)
+      writer.ldelim()
+    }
+  }
+
+  export function decode(reader: Reader, length: i32): Array<ethereum.Value> {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length
+    const message = new Array<ethereum.Value>()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.push(ValuePb.decode(reader, reader.uint32()))
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+}

package/API/v1/ethereum/ethereum.ts

@@ -0,0 +1,76 @@
+import {
+  ethereum as ethereumBase,
+  Address,
+  BigInt,
+  Bytes
+} from '@graphprotocol/graph-ts/'
+import { SmartContractCallPb } from './SmartContractCallPb'
+import { ValuesPb } from './ValuesPb'
+import { ValuePb } from './ValuePb'
+import {
+  findUint8ArrayOrNull,
+  storeString,
+  storeUint8Array,
+  storeProtobuf,
+  findProtobuOrNull
+} from '../../../utils/pdk'
+
+/** Host Ethereum interface */
+export declare namespace ethereum {
+  function hostCall(call: u64): u64
+  function hostGetBalance(address: u64): u64
+  function hostEncode(token: u64): u64
+  function hostDecode(types: u64, data: u64): u64
+}
+
+export namespace ethereum {
+  export function call(
+    call: ethereumBase.SmartContractCall
+  ): Array<ethereumBase.Value> | null {
+    const callMem = storeProtobuf(call, SmartContractCallPb.encode)
+    const resultOffset = ethereum.hostCall(callMem.offset)
+    callMem.free()
+    return findProtobuOrNull<Array<ethereumBase.Value>>(
+      resultOffset,
+      ValuesPb.decode
+    )
+  }
+
+  export function getBalance(address: Address): BigInt {
+    const addressMem = storeUint8Array(address)
+    const resultOffset = ethereum.hostGetBalance(addressMem.offset)
+    addressMem.free()
+    const result = findUint8ArrayOrNull(resultOffset)
+
+    if (result == null) {
+      return BigInt.zero()
+    }
+
+    return changetype<BigInt>(result)
+  }
+
+  export function encode(token: ethereumBase.Value): Bytes | null {
+    const tokenMem = storeProtobuf(token, ValuePb.encode)
+    const resultOffset = ethereum.hostEncode(tokenMem.offset)
+    tokenMem.free()
+    const resultMsg = findUint8ArrayOrNull(resultOffset)
+
+    if (resultMsg == null) {
+      return null
+    }
+
+    return changetype<Bytes>(resultMsg)
+  }
+
+  export function decode(
+    types: string,
+    data: Bytes
+  ): ethereumBase.Value | null {
+    const typesMem = storeString(types)
+    const dataMem = storeUint8Array(data)
+    const resultOffset = ethereum.hostDecode(typesMem.offset, dataMem.offset)
+    typesMem.free()
+    dataMem.free()
+    return findProtobuOrNull<ethereumBase.Value>(resultOffset, ValuePb.decode)
+  }
+}

package/API/v1/index.ts

@@ -0,0 +1,10 @@
+export * from './activePositions/activePositions'
+export * from './activePositions/ActivePositionsResult'
+export * from './store/store'
+export * from './log/log'
+export * from './ethereum/ethereum'
+export * from './bigInt/bigInt'
+export * from './bigDecimal/bigDecimal'
+export * from './typeConversion/typeConversion'
+export * from './crypto/crypto'
+export * from './watcher/watcher'

package/API/v1/log/log.ts

@@ -0,0 +1,18 @@
+import { LogLevel } from '@extism/as-pdk'
+import { safeLog } from '../../../utils/pdk'
+
+// Host interface for logging
+export namespace log {
+  const levelsMap = [
+    LogLevel.Error,
+    LogLevel.Error,
+    LogLevel.Warn,
+    LogLevel.Info,
+    LogLevel.Debug
+  ]
+
+  // Host export for logging, providing basic logging functionality
+  export function log(level: u32, msg: string): void {
+    safeLog(levelsMap[level], msg)
+  }
+}

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

@@ -0,0 +1,139 @@
+// 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 { TokenBalancePb } from './TokenBalancePb'
+import { Timestamp } from '../google/protobuf/Timestamp'
+
+export class ActivePositionsResultPb {
+  static encode(message: ActivePositionsResultPb, writer: Writer): void {
+    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()
+    }
+
+    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()
+    }
+
+    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()
+    }
+
+    const positionToken = message.positionToken
+    if (positionToken !== null) {
+      writer.uint32(34)
+      writer.fork()
+      TokenBalancePb.encode(positionToken, writer)
+      writer.ldelim()
+    }
+
+    const unlockTimestamp = message.unlockTimestamp
+    if (unlockTimestamp !== null) {
+      writer.uint32(42)
+      writer.fork()
+      Timestamp.encode(unlockTimestamp, writer)
+      writer.ldelim()
+    }
+
+    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()
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32()
+      switch (tag >>> 3) {
+        case 1:
+          message.supplyTokens.push(
+            TokenBalancePb.decode(reader, reader.uint32())
+          )
+          break
+
+        case 2:
+          message.borrowTokens.push(
+            TokenBalancePb.decode(reader, reader.uint32())
+          )
+          break
+
+        case 3:
+          message.rewardTokens.push(
+            TokenBalancePb.decode(reader, reader.uint32())
+          )
+          break
+
+        case 4:
+          message.positionToken = TokenBalancePb.decode(reader, reader.uint32())
+          break
+
+        case 5:
+          message.unlockTimestamp = Timestamp.decode(reader, reader.uint32())
+          break
+
+        case 6:
+          message.poolAddressBytes = reader.bytes()
+          break
+
+        default:
+          reader.skipType(tag & 7)
+          break
+      }
+    }
+
+    return message
+  }
+
+  supplyTokens: Array<TokenBalancePb>
+  borrowTokens: Array<TokenBalancePb>
+  rewardTokens: Array<TokenBalancePb>
+  positionToken: TokenBalancePb | null
+  unlockTimestamp: Timestamp | null
+  poolAddressBytes: Uint8Array
+
+  constructor(
+    supplyTokens: Array<TokenBalancePb> = [],
+    borrowTokens: Array<TokenBalancePb> = [],
+    rewardTokens: Array<TokenBalancePb> = [],
+    positionToken: TokenBalancePb | null = null,
+    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
+  }
+}
+
+export function encodeActivePositionsResultPb(
+  message: ActivePositionsResultPb
+): Uint8Array {
+  return Protobuf.encode(message, ActivePositionsResultPb.encode)
+}
+
+export function decodeActivePositionsResultPb(
+  buffer: Uint8Array
+): ActivePositionsResultPb {
+  return Protobuf.decode<ActivePositionsResultPb>(
+    buffer,
+    ActivePositionsResultPb.decode
+  )
+}

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

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

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