datai-sdk 1.0.5 → 1.1.0

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

@@ -0,0 +1,71 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v6.33.4
+
+import { Writer, Reader } from "as-proto/assembly";
+
+export class NftItemPb {
+  static encode(message: NftItemPb, writer: Writer): void {
+    writer.uint32(10);
+    writer.bytes(message.collectionIdBytes);
+
+    writer.uint32(18);
+    writer.bytes(message.contractIdBytes);
+
+    writer.uint32(26);
+    writer.bytes(message.tokenIdBytes);
+
+    writer.uint32(34);
+    writer.bytes(message.amountBytes);
+  }
+
+  static decode(reader: Reader, length: i32): NftItemPb {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new NftItemPb();
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.collectionIdBytes = reader.bytes();
+          break;
+
+        case 2:
+          message.contractIdBytes = reader.bytes();
+          break;
+
+        case 3:
+          message.tokenIdBytes = reader.bytes();
+          break;
+
+        case 4:
+          message.amountBytes = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  }
+
+  collectionIdBytes: Uint8Array;
+  contractIdBytes: Uint8Array;
+  tokenIdBytes: Uint8Array;
+  amountBytes: Uint8Array;
+
+  constructor(
+    collectionIdBytes: Uint8Array = new Uint8Array(0),
+    contractIdBytes: Uint8Array = new Uint8Array(0),
+    tokenIdBytes: Uint8Array = new Uint8Array(0),
+    amountBytes: Uint8Array = new Uint8Array(0)
+  ) {
+    this.collectionIdBytes = collectionIdBytes;
+    this.contractIdBytes = contractIdBytes;
+    this.tokenIdBytes = tokenIdBytes;
+    this.amountBytes = amountBytes;
+  }
+}

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

@@ -0,0 +1,142 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v6.33.4
+
+import { Writer, Reader } from "as-proto/assembly";
+import { PerpSide } from "./PerpSide";
+
+export class PerpPositionPb {
+  static encode(message: PerpPositionPb, writer: Writer): void {
+    writer.uint32(10);
+    writer.string(message.baseToken);
+
+    writer.uint32(18);
+    writer.string(message.quoteToken);
+
+    writer.uint32(26);
+    writer.bytes(message.marginTokenAddressBytes);
+
+    writer.uint32(34);
+    writer.bytes(message.marginInitialAmountBytes);
+
+    writer.uint32(42);
+    writer.bytes(message.entryPriceBytes);
+
+    writer.uint32(50);
+    writer.bytes(message.markPriceBytes);
+
+    writer.uint32(58);
+    writer.bytes(message.baseSizeBytes);
+
+    writer.uint32(66);
+    writer.bytes(message.unrealizedPnlBytes);
+
+    writer.uint32(74);
+    writer.bytes(message.currentEquityBytes);
+
+    writer.uint32(82);
+    writer.bytes(message.leverageBytes);
+
+    writer.uint32(88);
+    writer.int32(message.side);
+  }
+
+  static decode(reader: Reader, length: i32): PerpPositionPb {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new PerpPositionPb();
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseToken = reader.string();
+          break;
+
+        case 2:
+          message.quoteToken = reader.string();
+          break;
+
+        case 3:
+          message.marginTokenAddressBytes = reader.bytes();
+          break;
+
+        case 4:
+          message.marginInitialAmountBytes = reader.bytes();
+          break;
+
+        case 5:
+          message.entryPriceBytes = reader.bytes();
+          break;
+
+        case 6:
+          message.markPriceBytes = reader.bytes();
+          break;
+
+        case 7:
+          message.baseSizeBytes = reader.bytes();
+          break;
+
+        case 8:
+          message.unrealizedPnlBytes = reader.bytes();
+          break;
+
+        case 9:
+          message.currentEquityBytes = reader.bytes();
+          break;
+
+        case 10:
+          message.leverageBytes = reader.bytes();
+          break;
+
+        case 11:
+          message.side = reader.int32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  }
+
+  baseToken: string;
+  quoteToken: string;
+  marginTokenAddressBytes: Uint8Array;
+  marginInitialAmountBytes: Uint8Array;
+  entryPriceBytes: Uint8Array;
+  markPriceBytes: Uint8Array;
+  baseSizeBytes: Uint8Array;
+  unrealizedPnlBytes: Uint8Array;
+  currentEquityBytes: Uint8Array;
+  leverageBytes: Uint8Array;
+  side: PerpSide;
+
+  constructor(
+    baseToken: string = "",
+    quoteToken: string = "",
+    marginTokenAddressBytes: Uint8Array = new Uint8Array(0),
+    marginInitialAmountBytes: Uint8Array = new Uint8Array(0),
+    entryPriceBytes: Uint8Array = new Uint8Array(0),
+    markPriceBytes: Uint8Array = new Uint8Array(0),
+    baseSizeBytes: Uint8Array = new Uint8Array(0),
+    unrealizedPnlBytes: Uint8Array = new Uint8Array(0),
+    currentEquityBytes: Uint8Array = new Uint8Array(0),
+    leverageBytes: Uint8Array = new Uint8Array(0),
+    side: PerpSide = 0
+  ) {
+    this.baseToken = baseToken;
+    this.quoteToken = quoteToken;
+    this.marginTokenAddressBytes = marginTokenAddressBytes;
+    this.marginInitialAmountBytes = marginInitialAmountBytes;
+    this.entryPriceBytes = entryPriceBytes;
+    this.markPriceBytes = markPriceBytes;
+    this.baseSizeBytes = baseSizeBytes;
+    this.unrealizedPnlBytes = unrealizedPnlBytes;
+    this.currentEquityBytes = currentEquityBytes;
+    this.leverageBytes = leverageBytes;
+    this.side = side;
+  }
+}

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

@@ -0,0 +1,10 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v6.33.4
+
+export enum PerpSide {
+  PERP_SIDE_UNSPECIFIED = 0,
+  PERP_SIDE_LONG = 1,
+  PERP_SIDE_SHORT = 2,
+}

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

@@ -0,0 +1,71 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v6.33.4
+
+import { Writer, Reader } 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);
+
+    writer.uint32(34);
+    writer.bytes(message.claimableAmountBytes);
+  }
+
+  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;
+
+        case 4:
+          message.claimableAmountBytes = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  }
+
+  tokenAddressBytes: Uint8Array;
+  tokenIdBytes: Uint8Array;
+  balanceBytes: Uint8Array;
+  claimableAmountBytes: Uint8Array;
+
+  constructor(
+    tokenAddressBytes: Uint8Array = new Uint8Array(0),
+    tokenIdBytes: Uint8Array = new Uint8Array(0),
+    balanceBytes: Uint8Array = new Uint8Array(0),
+    claimableAmountBytes: Uint8Array = new Uint8Array(0)
+  ) {
+    this.tokenAddressBytes = tokenAddressBytes;
+    this.tokenIdBytes = tokenIdBytes;
+    this.balanceBytes = balanceBytes;
+    this.claimableAmountBytes = claimableAmountBytes;
+  }
+}

package/API/v1/proto/activePositions/google/protobuf/Timestamp.ts

@@ -0,0 +1,48 @@
+// Code generated by protoc-gen-as. DO NOT EDIT.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v6.33.4
+
+import { Writer, Reader } from "as-proto/assembly";
+
+export class Timestamp {
+  static encode(message: Timestamp, writer: Writer): void {
+    writer.uint32(8);
+    writer.int64(message.seconds);
+
+    writer.uint32(16);
+    writer.int32(message.nanos);
+  }
+
+  static decode(reader: Reader, length: i32): Timestamp {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new Timestamp();
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.seconds = reader.int64();
+          break;
+
+        case 2:
+          message.nanos = reader.int32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  }
+
+  seconds: i64;
+  nanos: i32;
+
+  constructor(seconds: i64 = 0, nanos: i32 = 0) {
+    this.seconds = seconds;
+    this.nanos = nanos;
+  }
+}

package/API/v1/proto/watcher/WatcherInputPb.ts

@@ -0,0 +1,121 @@
+// Code generated by protoc-gen-as. MODIFIED to use graph-ts Entity.
+// Versions:
+//   protoc-gen-as v1.3.0
+//   protoc        v6.33.4
+
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
+import { Entity } from "@graphprotocol/graph-ts";
+import { EntityPb } from "../../store/EntityPb";
+
+/**
+ * WatcherInputPb - Extended watcher input with external data support.
+ * 
+ * This class wraps the user position (Entity) and optional external API data.
+ * The position field uses graph-ts Entity for compatibility with existing watchers.
+ */
+export class WatcherInputPb {
+  static encode(message: WatcherInputPb, writer: Writer): void {
+    const position = message.position;
+    if (position !== null) {
+      writer.uint32(10);
+      writer.fork();
+      EntityPb.encode(position, writer);
+      writer.ldelim();
+    }
+
+    const externalData = message.externalData;
+    if (externalData !== null) {
+      const externalDataKeys = externalData.keys();
+      for (let i: i32 = 0; i < externalDataKeys.length; ++i) {
+        const externalDataKey = externalDataKeys[i];
+        writer.uint32(18);
+        writer.fork();
+        writer.uint32(10);
+        writer.string(externalDataKey);
+        writer.uint32(18);
+        writer.bytes(externalData.get(externalDataKey));
+        writer.ldelim();
+      }
+    }
+  }
+
+  static decode(reader: Reader, length: i32): WatcherInputPb {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new WatcherInputPb();
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.position = EntityPb.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          let externalDataKey: string = "";
+          let externalDataValue: Uint8Array = new Uint8Array(0);
+          let externalDataHasKey: bool = false;
+          let externalDataHasValue: bool = false;
+          for (
+            const end: usize = reader.ptr + reader.uint32();
+            reader.ptr < end;
+
+          ) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1:
+                externalDataKey = reader.string();
+                externalDataHasKey = true;
+                break;
+
+              case 2:
+                externalDataValue = reader.bytes();
+                externalDataHasValue = true;
+                break;
+
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+            if (message.externalData === null) {
+              message.externalData = new Map<string, Uint8Array>();
+            }
+            const externalData = message.externalData;
+            if (
+              externalData !== null &&
+              externalDataHasKey &&
+              externalDataHasValue
+            ) {
+              externalData.set(externalDataKey, externalDataValue);
+            }
+          }
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  }
+
+  // Position uses graph-ts Entity (decoded via custom EntityPb)
+  position: Entity | null;
+  externalData: Map<string, Uint8Array>;
+
+  constructor(
+    position: Entity | null = null,
+    externalData: Map<string, Uint8Array> = new Map()
+  ) {
+    this.position = position;
+    this.externalData = externalData;
+  }
+}
+
+export function encodeWatcherInputPb(message: WatcherInputPb): Uint8Array {
+  return Protobuf.encode(message, WatcherInputPb.encode);
+}
+
+export function decodeWatcherInputPb(buffer: Uint8Array): WatcherInputPb {
+  return Protobuf.decode<WatcherInputPb>(buffer, WatcherInputPb.decode);
+}

package/API/v1/watcher/WatcherInput.ts

@@ -1,9 +1,107 @@
-import { Entity } from '@graphprotocol/graph-ts'
+import { Entity, Bytes } from '@graphprotocol/graph-ts'
 
+/**
+ * Input data provided to a watcher by the host.
+ * 
+ * For watchers using the extended format (WatcherInputPb), this includes:
+ * - position: The user position entity from the subgraph
+ * - externalData: Optional map of pre-fetched external API data
+ * 
+ * For legacy watchers, only position is populated and externalData is empty.
+ * 
+ * @example
+ * ```typescript
+ * const input = watcher.input()
+ * const position = input.position
+ * 
+ * // Check for external data
+ * if (input.hasExternalData('merkl_amount:0x...')) {
+ *   const data = input.getExternalData('merkl_amount:0x...')!
+ *   // Process data...
+ * }
+ * ```
+ */
 export class WatcherInput {
+  /**
+   * The user position entity from the subgraph.
+   * Contains the on-chain position data indexed by the subgraph.
+   */
   position: Entity
+  
+  /**
+   * Optional map of pre-fetched external API data.
+   * Keys follow the convention: "{provider}_{dataType}:{identifier}"
+   * Values are raw bytes that the watcher must decode.
+   * 
+   * Examples of keys:
+   * - "merkl_amount:0xUserAddr:0xTokenAddr" - Merkl claimable amount
+   * - "merkl_proof:0xUserAddr:0xTokenAddr" - Merkl Merkle proof
+   * - "aster_pnl:0xUserAddr" - Aster unrealized PnL
+   */
+  externalData: Map<string, Bytes>
 
-  constructor(position: Entity) {
+  constructor(
+    position: Entity,
+    externalData: Map<string, Bytes> = new Map<string, Bytes>()
+  ) {
     this.position = position
+    this.externalData = externalData
+  }
+
+  /**
+   * Check if external data is available for a given key.
+   * 
+   * @param key - The external data key to check
+   * @returns true if data exists for the key, false otherwise
+   * 
+   * @example
+   * ```typescript
+   * if (input.hasExternalData('merkl_amount:0xUser:0xToken')) {
+   *   // Data is available
+   * }
+   * ```
+   */
+  hasExternalData(key: string): bool {
+    return this.externalData.has(key)
+  }
+
+  /**
+   * Get external data by key.
+   * 
+   * @param key - The external data key to retrieve
+   * @returns The data as Bytes if present, null otherwise
+   * 
+   * @example
+   * ```typescript
+   * const data = input.getExternalData('merkl_amount:0xUser:0xToken')
+   * if (data !== null) {
+   *   const amount = BigInt.fromUnsignedBytes(data)
+   * }
+   * ```
+   */
+  getExternalData(key: string): Bytes | null {
+    if (this.externalData.has(key)) {
+      return changetype<Bytes>(this.externalData.get(key))
+    }
+    return null
+  }
+
+  /**
+   * Get all external data keys available.
+   * Useful for debugging or iterating over all external data.
+   * 
+   * @returns Array of all external data keys
+   */
+  getExternalDataKeys(): string[] {
+    return this.externalData.keys()
+  }
+
+  /**
+   * Check if any external data was provided.
+   * 
+   * @returns true if at least one external data entry exists
+   */
+  hasAnyExternalData(): bool {
+    return this.externalData.size > 0
   }
 }