datai-sdk 1.0.0

package/API/v1/watcher/watcher.ts

@@ -0,0 +1,33 @@
+import { Protobuf } from 'as-proto/assembly'
+import { WatcherResultPb } from '../proto/watcher/WatcherResultPb'
+import { Any } from '../proto/google/protobuf/Any'
+import { Host } from '@extism/as-pdk'
+import { WatcherInput } from './WatcherInput'
+import { Entity } from '../../../@graphprotocol/graph-ts'
+import { EntityPb } from '../store/EntityPb'
+
+export namespace watcher {
+  export const SCHEDULE_DEFAULT = 'DEFAULT'
+  export const SCHEDULE_LOW_PRIORITY = 'LOW_PRIORITY'
+
+  export function input(): WatcherInput {
+    const position = Protobuf.decode<Entity>(Host.input(), EntityPb.decode)
+    return new WatcherInput(position)
+  }
+
+  export function output(
+    resultTypeUrl: string,
+    resultBytes: Uint8Array,
+    updateTrigger: string
+  ): void {
+    const watcherResult = new WatcherResultPb()
+    const payload = new Any()
+    payload.typeUrl = resultTypeUrl
+    payload.value = resultBytes
+    watcherResult.payload = payload
+    watcherResult.updateTrigger = updateTrigger
+
+    const resultMsg = Protobuf.encode(watcherResult, WatcherResultPb.encode)
+    Host.output(resultMsg)
+  }
+}

package/index.ts

@@ -0,0 +1,5 @@
+export * from './utils/constants'
+export * from './utils/mathUtils'
+export * from './utils/pdk'
+export * from './utils/subgraphUtils'
+export * from './API'

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "datai-sdk",
+  "main": "index.ts",
+  "version": "1.0.0",
+  "description": "Datai SDK which has useful libraries to help building projections",
+  "dependencies": {
+    "@extism/as-pdk": "^1.0.0",
+    "as-proto": "^1.3.0",
+    "@graphprotocol/graph-ts": "^0.34.0"
+  }
+}

package/utils/constants.ts

@@ -0,0 +1,16 @@
+import { BigDecimal, BigInt } from '../@graphprotocol/graph-ts'
+
+// Zero Address
+export const ADDRESS_ZERO = '0x0000000000000000000000000000000000000000'
+
+// BigInt
+export const BI_0 = BigInt.fromI32(0)
+export const BI_1 = BigInt.fromI32(1)
+export const BI_2 = BigInt.fromI32(2)
+export const BI_7 = BigInt.fromI32(7)
+export const BI_9 = BigInt.fromI32(9)
+export const BI_18 = BigInt.fromI32(18)
+
+// BigDecimal
+export const BD_0 = new BigDecimal(BI_0)
+export const BD_1 = new BigDecimal(BI_1)

package/utils/mathUtils.ts

@@ -0,0 +1,77 @@
+import { BigDecimal, BigInt, Bytes, Address } from '../@graphprotocol/graph-ts'
+import { BD_0, BD_1 } from './constants'
+
+const MAX_DECIMALS = 77 // max decimals in decimal128 IEEE 754 standard (limitation of thegraph host)
+const MIN_DECIMALS = -18
+
+export function pow(value: BigDecimal, power: i32): BigDecimal {
+  if (power == 0) {
+    return BD_1
+  }
+  const negativePower = power < 0
+  let result = BD_0.plus(value)
+  const powerAbs = Math.abs(power)
+  for (let i = 1; i < powerAbs; i++) {
+    result = result.times(value) //TODO: move to host side
+  }
+
+  if (negativePower) {
+    result = safeDiv(BD_1, result)
+  }
+
+  return result
+}
+
+export function safeDiv(amount0: BigDecimal, amount1: BigDecimal): BigDecimal {
+  if (amount1.equals(BD_0)) {
+    return BD_0
+  } else {
+    return amount0.div(amount1)
+  }
+}
+
+export function exponentToBigInt(decimals: i32): BigInt {
+  assert(decimals <= MAX_DECIMALS && decimals >= 0, 'Decimals out of range')
+  return BigInt.fromI32(10).pow(u8(decimals))
+}
+
+export function exponentToBigDecimal(decimals: i32): BigDecimal {
+  assert(
+    decimals <= MAX_DECIMALS && decimals >= MIN_DECIMALS,
+    'Decimals out of range'
+  )
+  if (decimals >= 0) {
+    return BigInt.fromI32(10).pow(u8(decimals)).toBigDecimal()
+  } else {
+    return BD_1.div(BigInt.fromI32(10).pow(u8(-decimals)).toBigDecimal())
+  }
+}
+
+export function floor(amount: BigDecimal, decimals: i32 = 0): BigInt {
+  assert(decimals <= MAX_DECIMALS && decimals >= 0, 'Decimals out of range')
+  const result = amount.truncate(decimals)
+  return result.digits.times(exponentToBigInt(decimals + result.exp.toI32()))
+}
+
+export function squareRoot(value: BigDecimal, precision: i32 = 9): BigDecimal {
+  assert(
+    precision <= MAX_DECIMALS / 2 && precision >= 0,
+    'Precision out of range'
+  )
+  return floor(value, precision * 2)
+    .sqrt()
+    .toBigDecimal()
+    .div(exponentToBigDecimal(precision))
+}
+
+export function bytesToAddress(bytes: Bytes): Address {
+  if (bytes.length > 20) {
+    bytes = Bytes.fromUint8Array(bytes.slice(bytes.length - 20))
+  }
+
+  return Address.fromBytes(bytes)
+}
+
+export function addressToBytes(address: Address): Bytes {
+  return Bytes.fromHexString(address.toHexString())
+}

package/utils/pdk.ts

@@ -0,0 +1,171 @@
+import { Memory, Host, LogLevel, Var } from '@extism/as-pdk'
+import { length } from '@extism/as-pdk/lib/env'
+import { Protobuf, Writer, Reader } from 'as-proto/assembly'
+
+export declare namespace pdk {
+  export function hostAbort(
+    w0: u64,
+    w1: u64,
+    w2: u64,
+    w3: u64,
+    w4: u64,
+    w5: u64,
+    w6: u64,
+    w7: u64,
+    w8: u64,
+    w9: u64
+  ): void
+}
+
+// eslint-disable-next-line unused-imports/no-unused-vars
+function abortHandler(
+  message: string | null,
+  fileName: string | null,
+  lineNumber: u32,
+  columnNumber: u32
+): void {
+  message = `${fileName || ''} (${lineNumber}:${columnNumber}): ${message || '[Error]'}`
+  message = message.padEnd(10 * 8, '\u0000') // min 10 words of 64 bytes
+  const bytes = String.UTF8.encode(message)
+  const memory = Memory.allocate(bytes.byteLength)
+  if (memory.offset > 0) {
+    memory.store(Uint8Array.wrap(bytes))
+    Host.logMemory(LogLevel.Error, memory)
+    const abortFlag = Uint8Array.wrap(String.UTF8.encode('true'))
+    Var.set('isAbort', abortFlag)
+  } else {
+    // memory cannot be allocated, use stack-based fallback
+    const w = Uint64Array.wrap(bytes, 0, 10)
+    pdk.hostAbort(w[0], w[1], w[2], w[3], w[4], w[5], w[6], w[7], w[8], w[9])
+  }
+}
+
+// eslint-disable-next-line unused-imports/no-unused-vars
+namespace consoleHandler {
+  export function assert<T>(assertion: T, message?: string): void {
+    if (!assertion) {
+      safeLog(LogLevel.Error, message || '')
+    }
+  }
+
+  export function log(message?: string): void {
+    safeLog(LogLevel.Info, message || '')
+  }
+
+  export function debug(message?: string): void {
+    safeLog(LogLevel.Debug, message || '')
+  }
+
+  export function info(message?: string): void {
+    safeLog(LogLevel.Info, message || '')
+  }
+
+  export function warn(message?: string): void {
+    safeLog(LogLevel.Error, message || '')
+  }
+
+  export function error(message?: string): void {
+    safeLog(LogLevel.Error, message || '')
+  }
+}
+
+export function storeUint8Array(data: Uint8Array): Memory {
+  const memory = Memory.allocate(data.length)
+  if (memory.offset == 0 && data.length > 0) {
+    throw new Error('Out of extism memory')
+  }
+  memory.store(data)
+  return memory
+}
+
+export function storeString(data: string): Memory {
+  const buffer = String.UTF8.encode(data)
+  const bytes = Uint8Array.wrap(buffer)
+
+  return storeUint8Array(bytes)
+}
+
+export function storeProtobuf<TMessage>(
+  message: TMessage,
+  encoder: (message: TMessage, writer: Writer) => void
+): Memory {
+  const msg = Protobuf.encode(message, encoder)
+  return storeUint8Array(msg)
+}
+
+export function safeLog(level: LogLevel, s: string): void {
+  const memory = storeString(s)
+  Host.logMemory(level, memory)
+  memory.free()
+}
+
+export function findMemory(
+  offset: u64,
+  allowNull: bool = false
+): Memory | null {
+  if (offset == 0) {
+    if (allowNull) return null
+    throw new Error('Empty memory offset')
+  }
+
+  const len = length(offset)
+  if (len == 0) {
+    if (allowNull) return null
+    throw new Error('Zero memory length')
+  }
+
+  return new Memory(offset, len)
+}
+
+export function findUint8Array(offset: u64): Uint8Array {
+  return findUint8ArrayOrNull(offset, false)!
+}
+
+export function findUint8ArrayOrNull(
+  offset: u64,
+  allowNull: bool = true
+): Uint8Array | null {
+  const memory = findMemory(offset, allowNull)
+  if (memory === null) {
+    return null
+  }
+  const result = memory.toUint8Array()
+  memory.free()
+  return result
+}
+
+export function findString(offset: u64): string {
+  return findStringOrNull(offset, false)!
+}
+
+export function findStringOrNull(
+  offset: u64,
+  allowNull: bool = true
+): string | null {
+  const memory = findMemory(offset, allowNull)
+  if (memory === null) {
+    return null
+  }
+  const result = memory.toString()
+  memory.free()
+  return result
+}
+
+export function findProtobuOrNull<TMessage>(
+  offset: u64,
+  decoder: (reader: Reader, length: i32) => TMessage,
+  allowNull: bool = true
+): TMessage | null {
+  const data = findUint8ArrayOrNull(offset, allowNull)
+  if (data == null) {
+    return null
+  }
+  return Protobuf.decode<TMessage>(data, decoder)
+}
+
+export function findProtobuf<TMessage>(
+  offset: u64,
+  decoder: (reader: Reader, length: i32) => TMessage
+): TMessage {
+  return findProtobuOrNull<TMessage>(offset, decoder)!
+}

package/utils/subgraphUtils.ts

@@ -0,0 +1,27 @@
+import { Entity, store } from '@graphprotocol/graph-ts'
+import { watcher } from '../API'
+
+export function registerUser(userId: string): void {
+  let user = store.get('User', userId)
+
+  if (user == null) {
+    user = new Entity()
+    user.setString('id', userId)
+    store.set('User', userId, user)
+  }
+}
+
+export function ensureUpdateTrigger(
+  userPositionId: string,
+  updateTriggerId: string = watcher.SCHEDULE_DEFAULT
+): bool {
+  const updateTrigger = store.get('PositionUpdateTrigger', userPositionId)
+  if (updateTrigger == null) {
+    const updateTrigger = new Entity()
+    updateTrigger.setString('id', userPositionId)
+    updateTrigger.setString('updateTrigger', updateTriggerId)
+    store.set('PositionUpdateTrigger', userPositionId, updateTrigger)
+    return false
+  }
+  return true
+}