datai-sdk 1.0.6 → 1.1.0

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.0",
   "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/@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,
-    ) {}
-  }
-}

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

@@ -1,426 +0,0 @@
-import '../common/eager_offset';
-import { Bytes } from '../common/collections';
-
-export namespace cosmos {
-  export class Block {
-    constructor(
-      public header: Header,
-      public evidence: EvidenceList,
-      public lastCommit: Commit,
-      public resultBeginBlock: ResponseBeginBlock,
-      public resultEndBlock: ResponseEndBlock,
-      public transactions: Array<TxResult>,
-      public validatorUpdates: Array<Validator>,
-    ) {}
-  }
-
-  export class HeaderOnlyBlock {
-    constructor(public header: Header) {}
-  }
-
-  export class EventData {
-    constructor(
-      public event: Event,
-      public block: HeaderOnlyBlock,
-      public tx: TransactionContext,
-    ) {}
-  }
-
-  export class TransactionData {
-    constructor(
-      public tx: TxResult,
-      public block: HeaderOnlyBlock,
-    ) {}
-  }
-
-  export class MessageData {
-    constructor(
-      public message: Any,
-      public block: HeaderOnlyBlock,
-      public tx: TransactionContext,
-    ) {}
-  }
-
-  export class TransactionContext {
-    constructor(
-      public hash: Bytes,
-      public index: u32,
-      public code: u32,
-      public gasWanted: i64,
-      public gasUsed: i64,
-    ) {}
-  }
-
-  export class Header {
-    constructor(
-      public version: Consensus,
-      public chainId: string,
-      public height: u64,
-      public time: Timestamp,
-      public lastBlockId: BlockID,
-      public lastCommitHash: Bytes,
-      public dataHash: Bytes,
-      public validatorsHash: Bytes,
-      public nextValidatorsHash: Bytes,
-      public consensusHash: Bytes,
-      public appHash: Bytes,
-      public lastResultsHash: Bytes,
-      public evidenceHash: Bytes,
-      public proposerAddress: Bytes,
-      public hash: Bytes,
-    ) {}
-  }
-
-  export class Consensus {
-    constructor(
-      public block: u64,
-      public app: u64,
-    ) {}
-  }
-
-  export class Timestamp {
-    constructor(
-      public seconds: i64,
-      public nanos: i32,
-    ) {}
-  }
-
-  export class BlockID {
-    constructor(
-      public hash: Bytes,
-      public partSetHeader: PartSetHeader,
-    ) {}
-  }
-
-  export class PartSetHeader {
-    constructor(
-      public total: u32,
-      public hash: Bytes,
-    ) {}
-  }
-
-  export class EvidenceList {
-    constructor(public evidence: Array<Evidence>) {}
-  }
-
-  export class Evidence {
-    constructor(
-      public duplicateVoteEvidence: DuplicateVoteEvidence,
-      public lightClientAttackEvidence: LightClientAttackEvidence,
-    ) {}
-  }
-
-  export class DuplicateVoteEvidence {
-    constructor(
-      public voteA: EventVote,
-      public voteB: EventVote,
-      public totalVotingPower: i64,
-      public validatorPower: i64,
-      public timestamp: Timestamp,
-    ) {}
-  }
-
-  export class EventVote {
-    constructor(
-      public eventVoteType: SignedMsgType,
-      public height: u64,
-      public round: i32,
-      public blockId: BlockID,
-      public timestamp: Timestamp,
-      public validatorAddress: Bytes,
-      public validatorIndex: i32,
-      public signature: Bytes,
-    ) {}
-  }
-
-  export enum SignedMsgType {
-    SIGNED_MSG_TYPE_UNKNOWN = 0,
-    SIGNED_MSG_TYPE_PREVOTE = 1,
-    SIGNED_MSG_TYPE_PRECOMMIT = 2,
-    SIGNED_MSG_TYPE_PROPOSAL = 32,
-  }
-
-  export class LightClientAttackEvidence {
-    constructor(
-      public conflictingBlock: LightBlock,
-      public commonHeight: i64,
-      public byzantineValidators: Array<Validator>,
-      public totalVotingPower: i64,
-      public timestamp: Timestamp,
-    ) {}
-  }
-
-  export class LightBlock {
-    constructor(
-      public signedHeader: SignedHeader,
-      public validatorSet: ValidatorSet,
-    ) {}
-  }
-
-  export class SignedHeader {
-    constructor(
-      public header: Header,
-      public commit: Commit,
-    ) {}
-  }
-
-  export class Commit {
-    constructor(
-      public height: i64,
-      public round: i32,
-      public blockId: BlockID,
-      public signatures: Array<CommitSig>,
-    ) {}
-  }
-
-  export class CommitSig {
-    constructor(
-      public blockIdFlag: BlockIDFlag,
-      public validatorAddress: Bytes,
-      public timestamp: Timestamp,
-      public signature: Bytes,
-    ) {}
-  }
-
-  export enum BlockIDFlag {
-    BLOCK_ID_FLAG_UNKNOWN = 0,
-    BLOCK_ID_FLAG_ABSENT = 1,
-    BLOCK_ID_FLAG_COMMIT = 2,
-    BLOCK_ID_FLAG_NIL = 3,
-  }
-
-  export class ValidatorSet {
-    constructor(
-      public validators: Array<Validator>,
-      public proposer: Validator,
-      public totalVotingPower: i64,
-    ) {}
-  }
-
-  export class Validator {
-    constructor(
-      public address: Bytes,
-      public pubKey: PublicKey,
-      public votingPower: i64,
-      public proposerPriority: i64,
-    ) {}
-  }
-
-  export class PublicKey {
-    constructor(
-      public ed25519: Bytes,
-      public secp256k1: Bytes,
-    ) {}
-  }
-
-  export class ResponseBeginBlock {
-    constructor(public events: Array<Event>) {}
-  }
-
-  export class Event {
-    constructor(
-      public eventType: string,
-      public attributes: Array<EventAttribute>,
-    ) {}
-
-    getAttribute(key: string): EventAttribute | null {
-      for (let i = 0; i < this.attributes.length; i++) {
-        if (this.attributes[i].key == key) {
-          return this.attributes[i];
-        }
-      }
-      return null;
-    }
-
-    getAttributeValue(key: string): string {
-      const attribute = this.getAttribute(key);
-      return attribute ? attribute.value : '';
-    }
-  }
-
-  export class EventAttribute {
-    constructor(
-      public key: string,
-      public value: string,
-      public index: bool,
-    ) {}
-  }
-
-  export class ResponseEndBlock {
-    constructor(
-      public validatorUpdates: Array<ValidatorUpdate>,
-      public consensusParamUpdates: ConsensusParams,
-      public events: Array<Event>,
-    ) {}
-  }
-
-  export class ValidatorUpdate {
-    constructor(
-      public address: Bytes,
-      public pubKey: PublicKey,
-      public power: i64,
-    ) {}
-  }
-
-  export class ConsensusParams {
-    constructor(
-      public block: BlockParams,
-      public evidence: EvidenceParams,
-      public validator: ValidatorParams,
-      public version: VersionParams,
-    ) {}
-  }
-
-  export class BlockParams {
-    constructor(
-      public maxBytes: i64,
-      public maxGas: i64,
-    ) {}
-  }
-
-  export class EvidenceParams {
-    constructor(
-      public maxAgeNumBlocks: i64,
-      public maxAgeDuration: Duration,
-      public maxBytes: i64,
-    ) {}
-  }
-
-  export class Duration {
-    constructor(
-      public seconds: i64,
-      public nanos: i32,
-    ) {}
-  }
-
-  export class ValidatorParams {
-    constructor(public pubKeyTypes: Array<string>) {}
-  }
-
-  export class VersionParams {
-    constructor(public appVersion: u64) {}
-  }
-
-  export class TxResult {
-    constructor(
-      public height: u64,
-      public index: u32,
-      public tx: Tx,
-      public result: ResponseDeliverTx,
-      public hash: Bytes,
-    ) {}
-  }
-
-  export class Tx {
-    constructor(
-      public body: TxBody,
-      public authInfo: AuthInfo,
-      public signatures: Array<Bytes>,
-    ) {}
-  }
-
-  export class TxBody {
-    constructor(
-      public messages: Array<Any>,
-      public memo: string,
-      public timeoutHeight: u64,
-      public extensionOptions: Array<Any>,
-      public nonCriticalExtensionOptions: Array<Any>,
-    ) {}
-  }
-
-  export class Any {
-    constructor(
-      public typeUrl: string,
-      public value: Bytes,
-    ) {}
-  }
-
-  export class AuthInfo {
-    constructor(
-      public signerInfos: Array<SignerInfo>,
-      public fee: Fee,
-      public tip: Tip,
-    ) {}
-  }
-
-  export class SignerInfo {
-    constructor(
-      public publicKey: Any,
-      public modeInfo: ModeInfo,
-      public sequence: u64,
-    ) {}
-  }
-
-  export class ModeInfo {
-    constructor(
-      public single: ModeInfoSingle,
-      public multi: ModeInfoMulti,
-    ) {}
-  }
-
-  export class ModeInfoSingle {
-    constructor(public mode: SignMode) {}
-  }
-
-  export enum SignMode {
-    SIGN_MODE_UNSPECIFIED = 0,
-    SIGN_MODE_DIRECT = 1,
-    SIGN_MODE_TEXTUAL = 2,
-    SIGN_MODE_LEGACY_AMINO_JSON = 127,
-  }
-
-  export class ModeInfoMulti {
-    constructor(
-      public bitarray: CompactBitArray,
-      public modeInfos: Array<ModeInfo>,
-    ) {}
-  }
-
-  export class CompactBitArray {
-    constructor(
-      public extraBitsStored: u32,
-      public elems: Bytes,
-    ) {}
-  }
-
-  export class Fee {
-    constructor(
-      public amount: Array<Coin>,
-      public gasLimit: u64,
-      public payer: string,
-      public granter: string,
-    ) {}
-  }
-
-  export class Coin {
-    constructor(
-      public denom: string,
-      public amount: string,
-    ) {}
-  }
-
-  export class Tip {
-    constructor(
-      public amount: Array<Coin>,
-      public tipper: string,
-    ) {}
-  }
-
-  export class ResponseDeliverTx {
-    constructor(
-      public code: u32,
-      public data: Bytes,
-      public log: string,
-      public info: string,
-      public gasWanted: i64,
-      public gasUsed: i64,
-      public events: Array<Event>,
-      public codespace: string,
-    ) {}
-  }
-
-  export class ValidatorSetUpdates {
-    constructor(public validatorUpdates: Array<Validator>) {}
-  }
-}