datai-sdk 1.0.6 → 1.1.1

package/API/v1/watcher/watcher.ts

@@ -1,20 +1,170 @@
 import { Protobuf } from 'as-proto/assembly'
 import { WatcherResultPb } from '../proto/watcher/WatcherResultPb'
+import { WatcherInputPb } from '../proto/watcher/WatcherInputPb'
 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'
+import { Bytes } from '@graphprotocol/graph-ts'
 
+// Cached input to avoid re-decoding on multiple calls
+let _cachedInput: WatcherInput | null = null
+
+/**
+ * Watcher namespace providing input/output functions for watcher implementations.
+ * 
+ * @example
+ * ```typescript
+ * import { watcher, activePositions, ActivePositionsResult } from 'datai-sdk'
+ * 
+ * export function GetActivePositions(): void {
+ *   const input = watcher.input()
+ *   const position = activePositions.inputPosition<MyPosition>()
+ *   
+ *   // Check for external data
+ *   if (watcher.hasExternalData('my_key')) {
+ *     const data = watcher.getExternalData('my_key')!
+ *     // Use the data...
+ *   }
+ *   
+ *   const output = new ActivePositionsResult()
+ *   // ... build output
+ *   activePositions.output(output)
+ * }
+ * ```
+ */
 export namespace watcher {
+  /** Default update schedule */
   export const SCHEDULE_DEFAULT = 'DEFAULT'
+  
+  /** Low priority update schedule (less frequent updates) */
   export const SCHEDULE_LOW_PRIORITY = 'LOW_PRIORITY'
 
+  /**
+   * Get the watcher input (position + external data).
+   * Result is cached for the duration of the watcher call.
+   * 
+   * NOTE: This function expects WatcherInputPb format.
+   * Watchers built with this SDK version MUST be configured in the host
+   * to receive the extended format.
+   * 
+   * @returns WatcherInput containing position and optional external data
+   */
   export function input(): WatcherInput {
-    const position = Protobuf.decode<Entity>(Host.input(), EntityPb.decode)
-    return new WatcherInput(position)
+    if (_cachedInput !== null) {
+      return _cachedInput!
+    }
+
+    const rawInput = Host.input()
+    
+    // Decode as WatcherInputPb (new format with external data support)
+    const inputPb = Protobuf.decode<WatcherInputPb>(rawInput, WatcherInputPb.decode)
+    
+    // Convert external data map from Uint8Array to Bytes
+    const externalData = new Map<string, Bytes>()
+    const keys = inputPb.externalData.keys()
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]
+      const value = inputPb.externalData.get(key)
+      externalData.set(key, changetype<Bytes>(value))
+    }
+    
+    // Create WatcherInput with position and external data
+    _cachedInput = new WatcherInput(inputPb.position!, externalData)
+    return _cachedInput!
+  }
+
+  /**
+   * Helper: Get external data by key.
+   * Convenience method that calls input().getExternalData(key).
+   * 
+   * @param key - The external data key to retrieve
+   * @returns The data as Bytes if present, null otherwise
+   * 
+   * @example
+   * ```typescript
+   * const amount = watcher.getExternalData('merkl_amount:0xUser:0xToken')
+   * if (amount !== null) {
+   *   // Process amount...
+   * }
+   * ```
+   */
+  export function getExternalData(key: string): Bytes | null {
+    return input().getExternalData(key)
+  }
+
+  /**
+   * Helper: Check if external data exists for a key.
+   * Convenience method that calls input().hasExternalData(key).
+   * 
+   * @param key - The external data key to check
+   * @returns true if data exists for the key, false otherwise
+   * 
+   * @example
+   * ```typescript
+   * if (watcher.hasExternalData('merkl_proof:0xUser:0xToken')) {
+   *   const proof = watcher.getExternalData('merkl_proof:0xUser:0xToken')!
+   *   // Use proof...
+   * }
+   * ```
+   */
+  export function hasExternalData(key: string): bool {
+    return input().hasExternalData(key)
+  }
+
+  /**
+   * Helper: Get all external data keys.
+   * Convenience method that calls input().getExternalDataKeys().
+   * 
+   * @returns Array of all external data keys
+   * 
+   * @example
+   * ```typescript
+   * const keys = watcher.getExternalDataKeys()
+   * for (let i = 0; i < keys.length; i++) {
+   *   const data = watcher.getExternalData(keys[i])
+   *   // Process data...
+   * }
+   * ```
+   */
+  export function getExternalDataKeys(): string[] {
+    return input().getExternalDataKeys()
+  }
+
+  /**
+   * Helper: Check if any external data was provided.
+   * Convenience method that calls input().hasAnyExternalData().
+   * 
+   * @returns true if at least one external data entry exists
+   * 
+   * @example
+   * ```typescript
+   * if (watcher.hasAnyExternalData()) {
+   *   // External data is available, process it
+   *   const keys = watcher.getExternalDataKeys()
+   *   // ...
+   * }
+   * ```
+   */
+  export function hasAnyExternalData(): bool {
+    return input().hasAnyExternalData()
+  }
+
+  /**
+   * Reset cached input.
+   * Called automatically by the host between watcher invocations.
+   * Watchers should not need to call this directly.
+   */
+  export function resetInput(): void {
+    _cachedInput = null
   }
 
+  /**
+   * Output the watcher result to the host.
+   * 
+   * @param resultTypeUrl - The protobuf type URL for the result
+   * @param resultBytes - The serialized result bytes
+   * @param updateTrigger - The update trigger/schedule for next update
+   */
   export function output(
     resultTypeUrl: string,
     resultBytes: Uint8Array,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "datai-sdk",
   "main": "index.ts",
-  "version": "1.0.6",
+  "version": "1.1.1",
   "description": "Datai SDK which has useful libraries to help building projections",
   "scripts": {
     "postinstall": "node postinstall-script.js"
@@ -9,5 +9,8 @@
   "dependencies": {
     "@extism/as-pdk": "^1.0.0",
     "as-proto": "^1.3.0"
+  },
+  "devDependencies": {
+    "as-proto-gen": "^1.3.0"
   }
-}
+}

package/postinstall-script.js

@@ -9,9 +9,11 @@ const destinationFolder = path.resolve(
 );
 
 // Check if the source folder exists
+// If it doesn't exist, the script was likely already run or this is an npm install
+// In either case, we can safely exit without error
 if (!fs.existsSync(sourceFolder)) {
-  console.error(`Source folder "${sourceFolder}" does not exist.`);
-  process.exit(1);
+  console.log(`Source folder "${sourceFolder}" does not exist. Skipping postinstall (already configured or installed from npm).`);
+  process.exit(0);
 }
 
 // Create node_modules folder if it doesn't exist

package/@graphprotocol/graph-ts/README.md

@@ -1,13 +0,0 @@
-# The Graph TypeScript Library (graph-ts) adapted to Extism PDK
-
-## License
-
-Copyright © 2018 Graph Protocol, Inc. and contributors.
-
-The Graph TypeScript library is dual-licensed under the [MIT license](LICENSE-MIT) and the
-[Apache License, Version 2.0](LICENSE-APACHE).
-
-Unless required by applicable law or agreed to in writing, software distributed under the License is
-distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-implied. See the License for the specific language governing permissions and limitations under the
-License.

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

@@ -1,82 +0,0 @@
-import '../common/eager_offset';
-import { Bytes } from '../common/collections';
-
-// Most types from this namespace are direct mappings or adaptations from:
-// https://github.com/ChainSafe/firehose-arweave/blob/master/proto/sf/arweave/type/v1/type.proto
-export namespace arweave {
-  /**
-   * A key-value pair for arbitrary metadata
-   */
-  export class Tag {
-    constructor(
-      public name: Bytes,
-      public value: Bytes,
-    ) {}
-  }
-
-  export class ProofOfAccess {
-    constructor(
-      public option: string,
-      public txPath: Bytes,
-      public dataPath: Bytes,
-      public chunk: Bytes,
-    ) {}
-  }
-
-  /**
-   * An Arweave block.
-   */
-  export class Block {
-    constructor(
-      public timestamp: u64,
-      public lastRetarget: u64,
-      public height: u64,
-      public indepHash: Bytes,
-      public nonce: Bytes,
-      public previousBlock: Bytes,
-      public diff: Bytes,
-      public hash: Bytes,
-      public txRoot: Bytes,
-      public txs: Bytes[],
-      public walletList: Bytes,
-      public rewardAddr: Bytes,
-      public tags: Tag[],
-      public rewardPool: Bytes,
-      public weaveSize: Bytes,
-      public blockSize: Bytes,
-      public cumulativeDiff: Bytes,
-      public hashListMerkle: Bytes,
-      public poa: ProofOfAccess,
-    ) {}
-  }
-
-  /**
-   * An Arweave transaction
-   */
-  export class Transaction {
-    constructor(
-      public format: u32,
-      public id: Bytes,
-      public lastTx: Bytes,
-      public owner: Bytes,
-      public tags: Tag[],
-      public target: Bytes,
-      public quantity: Bytes,
-      public data: Bytes,
-      public dataSize: Bytes,
-      public dataRoot: Bytes,
-      public signature: Bytes,
-      public reward: Bytes,
-    ) {}
-  }
-
-  /**
-   * An Arweave transaction with block ptr
-   */
-  export class TransactionWithBlockPtr {
-    constructor(
-      public tx: Transaction,
-      public block: Block,
-    ) {}
-  }
-}