datai-sdk 1.0.6 → 1.1.1

package/API/v1/activePositions/ActivePositionsResult.ts

@@ -1,8 +1,10 @@
-import { Address, BigInt } from '@graphprotocol/graph-ts'
+import { Address, BigInt, BigDecimal } from '@graphprotocol/graph-ts'
 import { Timestamp } from '../proto/google/protobuf/Timestamp'
-import { ActivePositionsResultPb } from '../proto/activePositions/ActivePositionsResultPb'
-import { TokenBalancePb } from '../proto/activePositions/TokenBalancePb'
+import { ActivePositionsResultPb } from '../proto/activePositions/activePositions/ActivePositionsResultPb'
+import { TokenBalancePb } from '../proto/activePositions/activePositions/TokenBalancePb'
 import { TokenBalance } from './TokenBalance'
+import { NftItem } from './NftItem'
+import { PerpPosition, PerpSide } from './PerpPosition'
 
 export class ActivePositionsResult extends ActivePositionsResultPb {
   tokenBalance(tokenBalances: Array<TokenBalancePb>, index: i32): TokenBalance {
@@ -144,4 +146,220 @@ export class ActivePositionsResult extends ActivePositionsResultPb {
     positionToken.balanceBytes = balance
     if (tokenId) positionToken.tokenId = tokenId
   }
+
+  // ==========================================================================
+  // VESTING / CLAIMABLE METHODS
+  // ==========================================================================
+
+  /**
+   * Set supply balance with claimable amount (for vesting positions)
+   * 
+   * @param tokenAddress - The vesting token address
+   * @param totalBalance - Total vested amount (including locked)
+   * @param claimableAmount - Currently claimable/unlocked amount
+   * @param tokenId - Optional token ID for ERC721/1155
+   * 
+   * @example
+   * ```typescript
+   * output.setSupplyBalanceWithClaimable(
+   *   vestingToken,
+   *   BigInt.fromString("1000000000000000000000"), // 1000 total
+   *   BigInt.fromString("250000000000000000000")   // 250 claimable
+   * )
+   * ```
+   */
+  setSupplyBalanceWithClaimable(
+    tokenAddress: Address,
+    totalBalance: BigInt,
+    claimableAmount: BigInt,
+    tokenId: BigInt = BigInt.fromI32(0)
+  ): void {
+    const token = new TokenBalance()
+    token.tokenAddress = tokenAddress
+    token.balance = totalBalance
+    token.tokenId = tokenId
+    token.claimableAmount = claimableAmount
+    this.supplyTokens.push(token)
+  }
+
+  /**
+   * Get claimable amount for a supply token
+   * 
+   * @param tokenAddress - Token address to look up
+   * @param tokenId - Optional token ID for ERC721/1155
+   * @returns Claimable amount or null if not found/not set
+   */
+  supplyClaimableAmount(
+    tokenAddress: Address,
+    tokenId: BigInt = BigInt.fromI32(0)
+  ): BigInt | null {
+    for (let i = 0; i < this.supplyTokens.length; i++) {
+      const token = changetype<TokenBalance>(this.supplyTokens[i])
+      if (token.tokenAddress.equals(tokenAddress) && token.tokenId.equals(tokenId)) {
+        return token.claimableAmount
+      }
+    }
+    return null
+  }
+
+  // ==========================================================================
+  // NFT STAKED METHODS
+  // ==========================================================================
+
+  /**
+   * Set staked NFTs array
+   * 
+   * @param nfts - Array of NftItem objects representing staked NFTs
+   * 
+   * @example
+   * ```typescript
+   * const nfts: NftItem[] = []
+   * const nft1 = new NftItem()
+   * nft1.collectionId = baycCollection
+   * nft1.contractId = baycContract
+   * nft1.tokenId = BigInt.fromI32(1234)
+   * nft1.amount = BigInt.fromI32(1)
+   * nfts.push(nft1)
+   * 
+   * output.setSupplyNfts(nfts)
+   * ```
+   */
+  setSupplyNfts(nfts: Array<NftItem>): void {
+    this.supplyNfts = nfts
+  }
+
+  /**
+   * Add a single staked NFT (convenience helper)
+   * 
+   * @param collectionId - NFT collection identifier (may differ from contract for wrapped NFTs)
+   * @param contractId - Actual NFT contract address
+   * @param tokenId - NFT token ID
+   * @param amount - Amount (1 for ERC721, variable for ERC1155)
+   * 
+   * @example
+   * ```typescript
+   * output.addSupplyNft(
+   *   baycCollection,   // Collection ID
+   *   baycContract,     // Contract (same for direct staking)
+   *   BigInt.fromI32(1234),
+   *   BigInt.fromI32(1)
+   * )
+   * ```
+   */
+  addSupplyNft(
+    collectionId: Address,
+    contractId: Address,
+    tokenId: BigInt,
+    amount: BigInt = BigInt.fromI32(1)
+  ): void {
+    const nft = new NftItem()
+    nft.collectionId = collectionId
+    nft.contractId = contractId
+    nft.tokenId = tokenId
+    nft.amount = amount
+    this.supplyNfts.push(nft)
+  }
+
+  /**
+   * Get count of staked NFTs
+   */
+  get supplyNftCount(): i32 {
+    return this.supplyNfts.length
+  }
+
+  /**
+   * Get a staked NFT by index
+   * 
+   * @param index - Zero-based index
+   * @returns NftItem or null if index out of bounds
+   */
+  getSupplyNft(index: i32): NftItem | null {
+    if (index < 0 || index >= this.supplyNfts.length) {
+      return null
+    }
+    return changetype<NftItem>(this.supplyNfts[index])
+  }
+
+  // ==========================================================================
+  // PERPETUAL POSITION METHODS
+  // ==========================================================================
+
+  /**
+   * Set perpetual/leveraged position data
+   * 
+   * @param baseToken - Base asset symbol (e.g., "ETH", "BTC")
+   * @param quoteToken - Quote asset symbol (e.g., "USD", "USDC")
+   * @param marginTokenAddress - Margin/collateral token address
+   * @param marginInitialAmount - Initial margin deposited
+   * @param entryPrice - Entry price in quote terms
+   * @param markPrice - Current mark price
+   * @param baseSize - Position size in base terms
+   * @param unrealizedPnl - Unrealized profit/loss
+   * @param currentEquity - Current equity (margin + PnL)
+   * @param leverage - Current leverage ratio
+   * @param side - Position side (LONG or SHORT)
+   * 
+   * @example
+   * ```typescript
+   * output.setPerpPosition(
+   *   "ETH",
+   *   "USD",
+   *   USDC_ADDRESS,
+   *   BigInt.fromString("1000000000"),  // 1000 USDC margin
+   *   BigDecimal.fromString("2500.00"), // Entry
+   *   BigDecimal.fromString("2600.00"), // Mark
+   *   BigDecimal.fromString("0.4"),     // 0.4 ETH
+   *   BigDecimal.fromString("40.00"),   // $40 profit
+   *   BigDecimal.fromString("1040.00"), // $1040 equity
+   *   BigDecimal.fromString("1.0"),     // 1x leverage
+   *   PerpSide.PERP_SIDE_LONG
+   * )
+   * ```
+   */
+  setPerpPosition(
+    baseToken: string,
+    quoteToken: string,
+    marginTokenAddress: Address,
+    marginInitialAmount: BigInt,
+    entryPrice: BigDecimal,
+    markPrice: BigDecimal,
+    baseSize: BigDecimal,
+    unrealizedPnl: BigDecimal,
+    currentEquity: BigDecimal,
+    leverage: BigDecimal,
+    side: PerpSide
+  ): void {
+    const perp = new PerpPosition()
+    perp.baseToken = baseToken
+    perp.quoteToken = quoteToken
+    perp.marginTokenAddress = marginTokenAddress
+    perp.marginInitialAmount = marginInitialAmount
+    perp.entryPrice = entryPrice
+    perp.markPrice = markPrice
+    perp.baseSize = baseSize
+    perp.unrealizedPnl = unrealizedPnl
+    perp.currentEquity = currentEquity
+    perp.leverage = leverage
+    perp.side = side
+    this.perpPosition = perp
+  }
+
+  /**
+   * Get perpetual position (typed)
+   * 
+   * @returns PerpPosition or null if no perp position set
+   */
+  getPerp(): PerpPosition | null {
+    if (this.perpPosition === null) {
+      return null
+    }
+    return changetype<PerpPosition>(this.perpPosition)
+  }
+
+  /**
+   * Check if a perpetual position exists
+   */
+  get hasPerp(): bool {
+    return this.perpPosition !== null
+  }
 }

package/API/v1/activePositions/NftItem.ts

@@ -0,0 +1,63 @@
+import { Address, BigInt } from '@graphprotocol/graph-ts'
+import { NftItemPb } from '../proto/activePositions/activePositions/NftItemPb'
+
+/**
+ * NftItem - Wrapper class for NFT staked positions
+ * 
+ * Represents an NFT that is staked in a protocol (e.g., Unagi, Ape Staking)
+ * 
+ * @example
+ * ```typescript
+ * const nft = new NftItem()
+ * nft.collectionId = Address.fromString("0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D") // BAYC collection
+ * nft.contractId = Address.fromString("0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D")   // Same for direct staking
+ * nft.tokenId = BigInt.fromI32(1234)
+ * nft.amount = BigInt.fromI32(1)  // Always 1 for ERC721
+ * ```
+ */
+export class NftItem extends NftItemPb {
+  /**
+   * Collection identifier
+   * May differ from contractId for wrapped NFTs or when staking through a wrapper contract
+   */
+  get collectionId(): Address {
+    return changetype<Address>(this.collectionIdBytes)
+  }
+  set collectionId(value: Address) {
+    this.collectionIdBytes = value
+  }
+
+  /**
+   * Actual NFT contract address
+   * The on-chain contract that the NFT belongs to
+   */
+  get contractId(): Address {
+    return changetype<Address>(this.contractIdBytes)
+  }
+  set contractId(value: Address) {
+    this.contractIdBytes = value
+  }
+
+  /**
+   * NFT token ID
+   * The unique identifier of the NFT within its collection
+   */
+  get tokenId(): BigInt {
+    return changetype<BigInt>(this.tokenIdBytes)
+  }
+  set tokenId(value: BigInt) {
+    this.tokenIdBytes = value
+  }
+
+  /**
+   * Amount staked
+   * - For ERC721: Always 1
+   * - For ERC1155: Variable quantity
+   */
+  get amount(): BigInt {
+    return changetype<BigInt>(this.amountBytes)
+  }
+  set amount(value: BigInt) {
+    this.amountBytes = value
+  }
+}

package/API/v1/activePositions/PerpPosition.ts

@@ -0,0 +1,129 @@
+import { Address, BigInt, BigDecimal } from '@graphprotocol/graph-ts'
+import { Protobuf } from 'as-proto/assembly'
+import { PerpPositionPb } from '../proto/activePositions/activePositions/PerpPositionPb'
+import { PerpSide } from '../proto/activePositions/activePositions/PerpSide'
+import { BigDecimalPb } from '../bigDecimal/BigDecimalPb'
+
+// Re-export enum for convenience
+export { PerpSide } from '../proto/activePositions/activePositions/PerpSide'
+
+/**
+ * PerpPosition - Wrapper class for perpetual/leveraged trading positions
+ * 
+ * Represents a perpetual futures position with margin, leverage, and PnL tracking
+ * 
+ * @example
+ * ```typescript
+ * const perp = new PerpPosition()
+ * perp.baseToken = "ETH"
+ * perp.quoteToken = "USD"
+ * perp.marginTokenAddress = USDC_ADDRESS
+ * perp.marginInitialAmount = BigInt.fromString("1000000000") // 1000 USDC (6 decimals)
+ * perp.entryPrice = BigDecimal.fromString("2500.50")
+ * perp.markPrice = BigDecimal.fromString("2600.00")
+ * perp.baseSize = BigDecimal.fromString("0.5")
+ * perp.unrealizedPnl = BigDecimal.fromString("49.75")
+ * perp.currentEquity = BigDecimal.fromString("1049.75")
+ * perp.leverage = BigDecimal.fromString("1.25")
+ * perp.side = PerpSide.PERP_SIDE_LONG
+ * ```
+ */
+export class PerpPosition extends PerpPositionPb {
+  // Base/Quote tokens are already strings in proto, no conversion needed
+
+  /**
+   * Margin token contract address
+   * Usually a stablecoin like USDC, USDT, or DAI
+   */
+  get marginTokenAddress(): Address {
+    return changetype<Address>(this.marginTokenAddressBytes)
+  }
+  set marginTokenAddress(value: Address) {
+    this.marginTokenAddressBytes = value
+  }
+
+  /**
+   * Initial margin deposited
+   * The original collateral amount in margin token units (with decimals)
+   */
+  get marginInitialAmount(): BigInt {
+    return changetype<BigInt>(this.marginInitialAmountBytes)
+  }
+  set marginInitialAmount(value: BigInt) {
+    this.marginInitialAmountBytes = value
+  }
+
+  /**
+   * Entry price in quote token terms
+   * The price at which the position was opened
+   */
+  get entryPrice(): BigDecimal {
+    if (this.entryPriceBytes.length == 0) return BigDecimal.zero()
+    return Protobuf.decode<BigDecimal>(this.entryPriceBytes, BigDecimalPb.decode)
+  }
+  set entryPrice(value: BigDecimal) {
+    this.entryPriceBytes = Protobuf.encode(value, BigDecimalPb.encode)
+  }
+
+  /**
+   * Current mark/index price
+   * The current market price used for PnL calculations
+   */
+  get markPrice(): BigDecimal {
+    if (this.markPriceBytes.length == 0) return BigDecimal.zero()
+    return Protobuf.decode<BigDecimal>(this.markPriceBytes, BigDecimalPb.decode)
+  }
+  set markPrice(value: BigDecimal) {
+    this.markPriceBytes = Protobuf.encode(value, BigDecimalPb.encode)
+  }
+
+  /**
+   * Position size in base token terms
+   * e.g., 0.5 ETH for a 0.5 ETH-USD perpetual position
+   */
+  get baseSize(): BigDecimal {
+    if (this.baseSizeBytes.length == 0) return BigDecimal.zero()
+    return Protobuf.decode<BigDecimal>(this.baseSizeBytes, BigDecimalPb.decode)
+  }
+  set baseSize(value: BigDecimal) {
+    this.baseSizeBytes = Protobuf.encode(value, BigDecimalPb.encode)
+  }
+
+  /**
+   * Unrealized PnL in margin token
+   * Can be negative for losing positions
+   */
+  get unrealizedPnl(): BigDecimal {
+    if (this.unrealizedPnlBytes.length == 0) return BigDecimal.zero()
+    return Protobuf.decode<BigDecimal>(this.unrealizedPnlBytes, BigDecimalPb.decode)
+  }
+  set unrealizedPnl(value: BigDecimal) {
+    this.unrealizedPnlBytes = Protobuf.encode(value, BigDecimalPb.encode)
+  }
+
+  /**
+   * Current equity
+   * margin + unrealizedPnl = currentEquity
+   */
+  get currentEquity(): BigDecimal {
+    if (this.currentEquityBytes.length == 0) return BigDecimal.zero()
+    return Protobuf.decode<BigDecimal>(this.currentEquityBytes, BigDecimalPb.decode)
+  }
+  set currentEquity(value: BigDecimal) {
+    this.currentEquityBytes = Protobuf.encode(value, BigDecimalPb.encode)
+  }
+
+  /**
+   * Current leverage ratio
+   * Calculated as notional value / equity
+   */
+  get leverage(): BigDecimal {
+    if (this.leverageBytes.length == 0) return BigDecimal.zero()
+    return Protobuf.decode<BigDecimal>(this.leverageBytes, BigDecimalPb.decode)
+  }
+  set leverage(value: BigDecimal) {
+    this.leverageBytes = Protobuf.encode(value, BigDecimalPb.encode)
+  }
+
+  // side is already enum type from proto, no wrapper needed
+}

package/API/v1/activePositions/TokenBalance.ts

@@ -1,5 +1,5 @@
 import { Address, BigInt } from '@graphprotocol/graph-ts'
-import { TokenBalancePb } from '../proto/activePositions/TokenBalancePb'
+import { TokenBalancePb } from '../proto/activePositions/activePositions/TokenBalancePb'
 
 export class TokenBalance extends TokenBalancePb {
   get tokenAddress(): Address {
@@ -22,4 +22,35 @@ export class TokenBalance extends TokenBalancePb {
   set tokenId(value: BigInt) {
     this.tokenIdBytes = value
   }
+
+  // NEW: Claimable amount for vesting positions
+  /**
+   * Claimable amount for vesting positions
+   * Returns null if not set (non-vesting position)
+   * 
+   * @example
+   * ```typescript
+   * // For vesting positions with claimable tokens
+   * tokenBalance.claimableAmount = BigInt.fromString("500000000000000000000") // 500 tokens
+   * 
+   * // Check if claimable
+   * const claimable = tokenBalance.claimableAmount
+   * if (claimable !== null) {
+   *   // Has claimable amount
+   * }
+   * ```
+   */
+  get claimableAmount(): BigInt | null {
+    if (this.claimableAmountBytes.length == 0) {
+      return null
+    }
+    return changetype<BigInt>(this.claimableAmountBytes)
+  }
+  set claimableAmount(value: BigInt | null) {
+    if (value === null) {
+      this.claimableAmountBytes = new Uint8Array(0)
+    } else {
+      this.claimableAmountBytes = value
+    }
+  }
 }

package/API/v1/activePositions/activePositions.ts

@@ -1,7 +1,7 @@
 import { Protobuf } from 'as-proto/assembly'
 import { watcher } from '../watcher/watcher'
 import { ActivePositionsResult } from './ActivePositionsResult'
-import { ActivePositionsResultPb } from '../proto/activePositions/ActivePositionsResultPb'
+import { ActivePositionsResultPb } from '../proto/activePositions/activePositions/ActivePositionsResultPb'
 
 export namespace activePositions {
   export function inputPosition<T>(): T {
@@ -27,6 +27,13 @@ export namespace activePositions {
       result.rewardTokens.some((token) =>
         token.balanceBytes.some((byte) => byte != 0)
       )
+    
+    // NEW: Check for staked NFTs
+    isActive = isActive || result.supplyNfts.length > 0
+    
+    // NEW: Check for perpetual position
+    isActive = isActive || result.perpPosition !== null
+    
     isActive = isActive && !forceInactive
 
     const resultMsg = Protobuf.encode(

package/API/v1/index.ts

@@ -1,5 +1,7 @@
 export * from './activePositions/activePositions'
 export * from './activePositions/ActivePositionsResult'
+export * from './activePositions/NftItem'
+export * from './activePositions/PerpPosition'
 export * from './store/store'
 export * from './log/log'
 export * from './ethereum/ethereum'
@@ -8,3 +10,7 @@ export * from './bigDecimal/bigDecimal'
 export * from './typeConversion/typeConversion'
 export * from './crypto/crypto'
 export * from './watcher/watcher'
+export * from './watcher/WatcherInput'
+
+// Proto types (for advanced users)
+export { WatcherInputPb } from './proto/watcher/WatcherInputPb'

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

@@ -0,0 +1,159 @@
+// 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 { TokenBalancePb } from "./TokenBalancePb";
+import { Timestamp } from "../google/protobuf/Timestamp";
+import { NftItemPb } from "./NftItemPb";
+import { PerpPositionPb } from "./PerpPositionPb";
+
+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);
+
+    const supplyNfts = message.supplyNfts;
+    for (let i: i32 = 0; i < supplyNfts.length; ++i) {
+      writer.uint32(58);
+      writer.fork();
+      NftItemPb.encode(supplyNfts[i], writer);
+      writer.ldelim();
+    }
+
+    const perpPosition = message.perpPosition;
+    if (perpPosition !== null) {
+      writer.uint32(66);
+      writer.fork();
+      PerpPositionPb.encode(perpPosition, writer);
+      writer.ldelim();
+    }
+  }
+
+  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;
+
+        case 7:
+          message.supplyNfts.push(NftItemPb.decode(reader, reader.uint32()));
+          break;
+
+        case 8:
+          message.perpPosition = PerpPositionPb.decode(reader, reader.uint32());
+          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;
+  supplyNfts: Array<NftItemPb>;
+  perpPosition: PerpPositionPb | null;
+
+  constructor(
+    supplyTokens: Array<TokenBalancePb> = [],
+    borrowTokens: Array<TokenBalancePb> = [],
+    rewardTokens: Array<TokenBalancePb> = [],
+    positionToken: TokenBalancePb | null = null,
+    unlockTimestamp: Timestamp | null = null,
+    poolAddressBytes: Uint8Array = new Uint8Array(0),
+    supplyNfts: Array<NftItemPb> = [],
+    perpPosition: PerpPositionPb | null = null
+  ) {
+    this.supplyTokens = supplyTokens;
+    this.borrowTokens = borrowTokens;
+    this.rewardTokens = rewardTokens;
+    this.positionToken = positionToken;
+    this.unlockTimestamp = unlockTimestamp;
+    this.poolAddressBytes = poolAddressBytes;
+    this.supplyNfts = supplyNfts;
+    this.perpPosition = perpPosition;
+  }
+}