datai-sdk 1.1.3 → 1.2.0

package/API/v1/activePositions/ActivePositionsResult.ts

@@ -5,6 +5,8 @@ import { TokenBalancePb } from '../proto/activePositions/activePositions/TokenBa
 import { TokenBalance } from './TokenBalance'
 import { NftItem } from './NftItem'
 import { PerpPosition, PerpSide } from './PerpPosition'
+import { OptionPosition } from './OptionPosition'
+import { Prediction } from './Prediction'
 
 export class ActivePositionsResult extends ActivePositionsResultPb {
   tokenBalance(tokenBalances: Array<TokenBalancePb>, index: i32): TokenBalance {
@@ -362,4 +364,78 @@ export class ActivePositionsResult extends ActivePositionsResultPb {
   get hasPerp(): bool {
     return this.perpPosition !== null
   }
+
+  // ==========================================================================
+  // OPTION POSITION METHODS
+  // ==========================================================================
+
+  /**
+   * Set options position data (buyer/long or seller/short).
+   *
+   * @param option - An OptionPosition with scalar fields + token legs set
+   *
+   * @example
+   * ```typescript
+   * const opt = new OptionPosition()
+   * opt.optionType = OptionType.OPTION_TYPE_CALL
+   * opt.style = OptionStyle.OPTION_STYLE_EUROPEAN
+   * opt.side = OptionSide.OPTION_SIDE_SELLER
+   * opt.setUnderlying(weth, underlyingAmount)
+   * opt.setStrike(usdc, strikeNotional)
+   * opt.addCollateral(weth, collateralAmount)
+   * output.setOptionPosition(opt)
+   * ```
+   */
+  setOptionPosition(option: OptionPosition): void {
+    this.optionPosition = option
+  }
+
+  /**
+   * Get options position (typed)
+   *
+   * @returns OptionPosition or null if no option position set
+   */
+  getOption(): OptionPosition | null {
+    if (this.optionPosition === null) {
+      return null
+    }
+    return changetype<OptionPosition>(this.optionPosition)
+  }
+
+  /**
+   * Check if an options position exists
+   */
+  get hasOption(): bool {
+    return this.optionPosition !== null
+  }
+
+  // ==========================================================================
+  // PREDICTION-MARKET METHODS
+  // ==========================================================================
+
+  /**
+   * Add a prediction-market position (a user may hold several).
+   *
+   * @param prediction - A Prediction with its fields set
+   */
+  addPrediction(prediction: Prediction): void {
+    this.predictions.push(prediction)
+  }
+
+  /**
+   * Get count of prediction positions
+   */
+  get predictionCount(): i32 {
+    return this.predictions.length
+  }
+
+  /**
+   * Get a prediction position by index (typed)
+   */
+  getPrediction(index: i32): Prediction | null {
+    if (index < 0 || index >= this.predictions.length) {
+      return null
+    }
+    return changetype<Prediction>(this.predictions[index])
+  }
 }

package/API/v1/activePositions/OptionPosition.ts

@@ -0,0 +1,78 @@
+import { Address, BigInt, BigDecimal } from '@graphprotocol/graph-ts'
+import { Protobuf } from 'as-proto/assembly'
+import { OptionPositionPb } from '../proto/activePositions/activePositions/OptionPositionPb'
+import { BigDecimalPb } from '../bigDecimal/BigDecimalPb'
+import { TokenBalance } from './TokenBalance'
+
+// Re-export enums for convenience
+export { OptionType } from '../proto/activePositions/activePositions/OptionType'
+export { OptionStyle } from '../proto/activePositions/activePositions/OptionStyle'
+export { OptionSide } from '../proto/activePositions/activePositions/OptionSide'
+
+/**
+ * OptionPosition - wrapper for options positions (long/buyer or short/seller).
+ *
+ * Canonical host shape: Type=PUT|CALL, Side=short|long, StrikePrice={Value,
+ * QuoteToken:{addr:wei}}, UnderlyingToken/CollateralTokens/SpreadHedgeTokens as
+ * {addr:wei} maps. Token amounts are wei; strikePriceValue is a decimal ratio.
+ *
+ * @example
+ * ```typescript
+ * const opt = new OptionPosition()
+ * opt.optionType = OptionType.OPTION_TYPE_PUT
+ * opt.style = OptionStyle.OPTION_STYLE_EUROPEAN
+ * opt.side = OptionSide.OPTION_SIDE_SELLER
+ * opt.isAutoExercise = true
+ * opt.exerciseStartAt = 1625011200
+ * opt.exerciseEndAt = 1625011200
+ * opt.expiryAt = 1625011200
+ * opt.strikePriceValue = BigDecimal.fromString("0.98")
+ * opt.setStrike(usdc, strikeNotionalWei)   // StrikePrice.QuoteToken
+ * opt.setUnderlying(aUSDC, underlyingWei)
+ * opt.addCollateral(weth, collateralWei)    // short only
+ * opt.addSpreadHedge(weth, hedgeWei)        // short only
+ * output.setOptionPosition(opt)
+ * ```
+ */
+export class OptionPosition extends OptionPositionPb {
+  /** Strike price ratio (quote per underlying) — a decimal, NOT a token amount. */
+  get strikePriceValue(): BigDecimal {
+    if (this.strikePriceValueBytes.length == 0) return BigDecimal.zero()
+    return Protobuf.decode<BigDecimal>(this.strikePriceValueBytes, BigDecimalPb.decode)
+  }
+  set strikePriceValue(value: BigDecimal) {
+    this.strikePriceValueBytes = Protobuf.encode(value, BigDecimalPb.encode)
+  }
+
+  /** Set the underlying token leg (address + amount in wei). */
+  setUnderlying(tokenAddress: Address, amount: BigInt): void {
+    const tb = new TokenBalance()
+    tb.tokenAddress = tokenAddress
+    tb.balance = amount
+    this.underlyingToken = tb
+  }
+
+  /** Set the strike QuoteToken leg (address + notional amount in wei). */
+  setStrike(tokenAddress: Address, amount: BigInt): void {
+    const tb = new TokenBalance()
+    tb.tokenAddress = tokenAddress
+    tb.balance = amount
+    this.strikeToken = tb
+  }
+
+  /** Add a collateral token entry (short positions only). */
+  addCollateral(tokenAddress: Address, amount: BigInt): void {
+    const tb = new TokenBalance()
+    tb.tokenAddress = tokenAddress
+    tb.balance = amount
+    this.collateralTokens.push(tb)
+  }
+
+  /** Add a spread-hedge token entry (short positions only). */
+  addSpreadHedge(tokenAddress: Address, amount: BigInt): void {
+    const tb = new TokenBalance()
+    tb.tokenAddress = tokenAddress
+    tb.balance = amount
+    this.spreadHedgeTokens.push(tb)
+  }
+}

package/API/v1/activePositions/Prediction.ts

@@ -0,0 +1,82 @@
+import { Address, BigInt, BigDecimal, Bytes } from '@graphprotocol/graph-ts'
+import { Protobuf } from 'as-proto/assembly'
+import { PredictionPositionPb } from '../proto/activePositions/activePositions/PredictionPositionPb'
+import { BigDecimalPb } from '../bigDecimal/BigDecimalPb'
+
+/**
+ * Prediction - wrapper for a prediction-market position (e.g. Polymarket CTF).
+ *
+ * shares / maxPayout are wei (raw). payoutPerShare / currentPrice are decimal
+ * ratios (0..1) in collateral units. Scalar fields (outcomeIndex,
+ * collateralDecimals, status, expiryAt, negativeRisk, market* strings) are set
+ * directly on the object.
+ *
+ * @example
+ * ```typescript
+ * const p = new Prediction()
+ * p.conditionId = conditionIdBytes
+ * p.positionId = positionIdBytes
+ * p.outcomeIndex = 1
+ * p.shares = sharesWei
+ * p.collateralTokenAddress = pUSD
+ * p.collateralDecimals = 6
+ * p.maxPayout = sharesWei
+ * p.status = "active"
+ * p.currentPrice = BigDecimal.fromString("0.475")
+ * p.negativeRisk = false
+ * p.marketTitle = "..."
+ * output.addPrediction(p)
+ * ```
+ */
+export class Prediction extends PredictionPositionPb {
+  get conditionId(): Bytes {
+    return changetype<Bytes>(this.conditionIdBytes)
+  }
+  set conditionId(value: Bytes) {
+    this.conditionIdBytes = value
+  }
+
+  get positionId(): Bytes {
+    return changetype<Bytes>(this.positionIdBytes)
+  }
+  set positionId(value: Bytes) {
+    this.positionIdBytes = value
+  }
+
+  get shares(): BigInt {
+    return changetype<BigInt>(this.sharesBytes)
+  }
+  set shares(value: BigInt) {
+    this.sharesBytes = changetype<Uint8Array>(value)
+  }
+
+  get collateralTokenAddress(): Address {
+    return changetype<Address>(this.collateralTokenAddressBytes)
+  }
+  set collateralTokenAddress(value: Address) {
+    this.collateralTokenAddressBytes = value
+  }
+
+  get maxPayout(): BigInt {
+    return changetype<BigInt>(this.maxPayoutBytes)
+  }
+  set maxPayout(value: BigInt) {
+    this.maxPayoutBytes = changetype<Uint8Array>(value)
+  }
+
+  get payoutPerShare(): BigDecimal {
+    if (this.payoutPerShareBytes.length == 0) return BigDecimal.zero()
+    return Protobuf.decode<BigDecimal>(this.payoutPerShareBytes, BigDecimalPb.decode)
+  }
+  set payoutPerShare(value: BigDecimal) {
+    this.payoutPerShareBytes = Protobuf.encode(value, BigDecimalPb.encode)
+  }
+
+  get currentPrice(): BigDecimal {
+    if (this.currentPriceBytes.length == 0) return BigDecimal.zero()
+    return Protobuf.decode<BigDecimal>(this.currentPriceBytes, BigDecimalPb.decode)
+  }
+  set currentPrice(value: BigDecimal) {
+    this.currentPriceBytes = Protobuf.encode(value, BigDecimalPb.encode)
+  }
+}

package/API/v1/activePositions/TokenBalance.ts

@@ -46,11 +46,11 @@ export class TokenBalance extends TokenBalancePb {
     }
     return changetype<BigInt>(this.claimableAmountBytes)
   }
-  set claimableAmount(value: BigInt | null) {
-    if (value === null) {
-      this.claimableAmountBytes = new Uint8Array(0)
-    } else {
-      this.claimableAmountBytes = value
-    }
+  // AssemblyScript cannot narrow `BigInt | null` → `BigInt` inside an `if` branch,
+  // and cannot implicitly widen `BigInt` → `Uint8Array` even though graph-ts BigInt
+  // extends Uint8Array. Accept non-null BigInt and use changetype explicitly.
+  // To clear the field, assign `new Uint8Array(0)` to `claimableAmountBytes` directly.
+  set claimableAmount(value: BigInt) {
+    this.claimableAmountBytes = changetype<Uint8Array>(value)
   }
 }

package/API/v1/activePositions/activePositions.ts

@@ -33,7 +33,13 @@ export namespace activePositions {
     
     // NEW: Check for perpetual position
     isActive = isActive || result.perpPosition !== null
-    
+
+    // NEW: Check for options position
+    isActive = isActive || result.optionPosition !== null
+
+    // NEW: Check for prediction-market positions
+    isActive = isActive || result.predictions.length > 0
+
     isActive = isActive && !forceInactive
 
     const resultMsg = Protobuf.encode(

package/API/v1/index.ts

@@ -2,6 +2,8 @@ export * from './activePositions/activePositions'
 export * from './activePositions/ActivePositionsResult'
 export * from './activePositions/NftItem'
 export * from './activePositions/PerpPosition'
+export * from './activePositions/OptionPosition'
+export * from './activePositions/Prediction'
 export * from './store/store'
 export * from './log/log'
 export * from './ethereum/ethereum'

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

@@ -8,6 +8,8 @@ import { TokenBalancePb } from "./TokenBalancePb";
 import { Timestamp } from "../../google/protobuf/Timestamp";
 import { NftItemPb } from "./NftItemPb";
 import { PerpPositionPb } from "./PerpPositionPb";
+import { OptionPositionPb } from "./OptionPositionPb";
+import { PredictionPositionPb } from "./PredictionPositionPb";
 
 export class ActivePositionsResultPb {
   static encode(message: ActivePositionsResultPb, writer: Writer): void {
@@ -69,6 +71,22 @@ export class ActivePositionsResultPb {
       PerpPositionPb.encode(perpPosition, writer);
       writer.ldelim();
     }
+
+    const optionPosition = message.optionPosition;
+    if (optionPosition !== null) {
+      writer.uint32(74);
+      writer.fork();
+      OptionPositionPb.encode(optionPosition, writer);
+      writer.ldelim();
+    }
+
+    const predictions = message.predictions;
+    for (let i: i32 = 0; i < predictions.length; ++i) {
+      writer.uint32(82);
+      writer.fork();
+      PredictionPositionPb.encode(predictions[i], writer);
+      writer.ldelim();
+    }
   }
 
   static decode(reader: Reader, length: i32): ActivePositionsResultPb {
@@ -119,6 +137,19 @@ export class ActivePositionsResultPb {
           message.perpPosition = PerpPositionPb.decode(reader, reader.uint32());
           break;
 
+        case 9:
+          message.optionPosition = OptionPositionPb.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+
+        case 10:
+          message.predictions.push(
+            PredictionPositionPb.decode(reader, reader.uint32())
+          );
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -136,6 +167,8 @@ export class ActivePositionsResultPb {
   poolAddressBytes: Uint8Array;
   supplyNfts: Array<NftItemPb>;
   perpPosition: PerpPositionPb | null;
+  optionPosition: OptionPositionPb | null;
+  predictions: Array<PredictionPositionPb>;
 
   constructor(
     supplyTokens: Array<TokenBalancePb> = [],
@@ -145,7 +178,9 @@ export class ActivePositionsResultPb {
     unlockTimestamp: Timestamp | null = null,
     poolAddressBytes: Uint8Array = new Uint8Array(0),
     supplyNfts: Array<NftItemPb> = [],
-    perpPosition: PerpPositionPb | null = null
+    perpPosition: PerpPositionPb | null = null,
+    optionPosition: OptionPositionPb | null = null,
+    predictions: Array<PredictionPositionPb> = []
   ) {
     this.supplyTokens = supplyTokens;
     this.borrowTokens = borrowTokens;
@@ -155,5 +190,7 @@ export class ActivePositionsResultPb {
     this.poolAddressBytes = poolAddressBytes;
     this.supplyNfts = supplyNfts;
     this.perpPosition = perpPosition;
+    this.optionPosition = optionPosition;
+    this.predictions = predictions;
   }
 }

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

@@ -0,0 +1,182 @@
+// 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 { OptionType } from "./OptionType";
+import { OptionStyle } from "./OptionStyle";
+import { OptionSide } from "./OptionSide";
+import { TokenBalancePb } from "./TokenBalancePb";
+
+export class OptionPositionPb {
+  static encode(message: OptionPositionPb, writer: Writer): void {
+    writer.uint32(8);
+    writer.int32(message.optionType);
+
+    writer.uint32(16);
+    writer.int32(message.style);
+
+    writer.uint32(24);
+    writer.int32(message.side);
+
+    writer.uint32(32);
+    writer.bool(message.isAutoExercise);
+
+    writer.uint32(40);
+    writer.int64(message.exerciseStartAt);
+
+    writer.uint32(48);
+    writer.int64(message.exerciseEndAt);
+
+    writer.uint32(56);
+    writer.int64(message.expiryAt);
+
+    const underlyingToken = message.underlyingToken;
+    if (underlyingToken !== null) {
+      writer.uint32(66);
+      writer.fork();
+      TokenBalancePb.encode(underlyingToken, writer);
+      writer.ldelim();
+    }
+
+    const strikeToken = message.strikeToken;
+    if (strikeToken !== null) {
+      writer.uint32(74);
+      writer.fork();
+      TokenBalancePb.encode(strikeToken, writer);
+      writer.ldelim();
+    }
+
+    const collateralTokens = message.collateralTokens;
+    for (let i: i32 = 0; i < collateralTokens.length; ++i) {
+      writer.uint32(82);
+      writer.fork();
+      TokenBalancePb.encode(collateralTokens[i], writer);
+      writer.ldelim();
+    }
+
+    writer.uint32(90);
+    writer.bytes(message.strikePriceValueBytes);
+
+    const spreadHedgeTokens = message.spreadHedgeTokens;
+    for (let i: i32 = 0; i < spreadHedgeTokens.length; ++i) {
+      writer.uint32(98);
+      writer.fork();
+      TokenBalancePb.encode(spreadHedgeTokens[i], writer);
+      writer.ldelim();
+    }
+  }
+
+  static decode(reader: Reader, length: i32): OptionPositionPb {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new OptionPositionPb();
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.optionType = reader.int32();
+          break;
+
+        case 2:
+          message.style = reader.int32();
+          break;
+
+        case 3:
+          message.side = reader.int32();
+          break;
+
+        case 4:
+          message.isAutoExercise = reader.bool();
+          break;
+
+        case 5:
+          message.exerciseStartAt = reader.int64();
+          break;
+
+        case 6:
+          message.exerciseEndAt = reader.int64();
+          break;
+
+        case 7:
+          message.expiryAt = reader.int64();
+          break;
+
+        case 8:
+          message.underlyingToken = TokenBalancePb.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+
+        case 9:
+          message.strikeToken = TokenBalancePb.decode(reader, reader.uint32());
+          break;
+
+        case 10:
+          message.collateralTokens.push(
+            TokenBalancePb.decode(reader, reader.uint32())
+          );
+          break;
+
+        case 11:
+          message.strikePriceValueBytes = reader.bytes();
+          break;
+
+        case 12:
+          message.spreadHedgeTokens.push(
+            TokenBalancePb.decode(reader, reader.uint32())
+          );
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  }
+
+  optionType: OptionType;
+  style: OptionStyle;
+  side: OptionSide;
+  isAutoExercise: bool;
+  exerciseStartAt: i64;
+  exerciseEndAt: i64;
+  expiryAt: i64;
+  underlyingToken: TokenBalancePb | null;
+  strikeToken: TokenBalancePb | null;
+  collateralTokens: Array<TokenBalancePb>;
+  strikePriceValueBytes: Uint8Array;
+  spreadHedgeTokens: Array<TokenBalancePb>;
+
+  constructor(
+    optionType: OptionType = 0,
+    style: OptionStyle = 0,
+    side: OptionSide = 0,
+    isAutoExercise: bool = false,
+    exerciseStartAt: i64 = 0,
+    exerciseEndAt: i64 = 0,
+    expiryAt: i64 = 0,
+    underlyingToken: TokenBalancePb | null = null,
+    strikeToken: TokenBalancePb | null = null,
+    collateralTokens: Array<TokenBalancePb> = [],
+    strikePriceValueBytes: Uint8Array = new Uint8Array(0),
+    spreadHedgeTokens: Array<TokenBalancePb> = []
+  ) {
+    this.optionType = optionType;
+    this.style = style;
+    this.side = side;
+    this.isAutoExercise = isAutoExercise;
+    this.exerciseStartAt = exerciseStartAt;
+    this.exerciseEndAt = exerciseEndAt;
+    this.expiryAt = expiryAt;
+    this.underlyingToken = underlyingToken;
+    this.strikeToken = strikeToken;
+    this.collateralTokens = collateralTokens;
+    this.strikePriceValueBytes = strikePriceValueBytes;
+    this.spreadHedgeTokens = spreadHedgeTokens;
+  }
+}

package/API/v1/proto/activePositions/activePositions/OptionSide.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 OptionSide {
+  OPTION_SIDE_UNSPECIFIED = 0,
+  OPTION_SIDE_BUYER = 1,
+  OPTION_SIDE_SELLER = 2,
+}

package/API/v1/proto/activePositions/activePositions/OptionStyle.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 OptionStyle {
+  OPTION_STYLE_UNSPECIFIED = 0,
+  OPTION_STYLE_EUROPEAN = 1,
+  OPTION_STYLE_AMERICAN = 2,
+}

package/API/v1/proto/activePositions/activePositions/OptionType.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 OptionType {
+  OPTION_TYPE_UNSPECIFIED = 0,
+  OPTION_TYPE_CALL = 1,
+  OPTION_TYPE_PUT = 2,
+}

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

@@ -0,0 +1,191 @@
+// 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 PredictionPositionPb {
+  static encode(message: PredictionPositionPb, writer: Writer): void {
+    writer.uint32(10);
+    writer.bytes(message.conditionIdBytes);
+
+    writer.uint32(18);
+    writer.bytes(message.positionIdBytes);
+
+    writer.uint32(24);
+    writer.int32(message.outcomeIndex);
+
+    writer.uint32(34);
+    writer.bytes(message.sharesBytes);
+
+    writer.uint32(42);
+    writer.bytes(message.collateralTokenAddressBytes);
+
+    writer.uint32(48);
+    writer.int32(message.collateralDecimals);
+
+    writer.uint32(58);
+    writer.bytes(message.maxPayoutBytes);
+
+    writer.uint32(66);
+    writer.string(message.status);
+
+    writer.uint32(74);
+    writer.bytes(message.payoutPerShareBytes);
+
+    writer.uint32(80);
+    writer.int64(message.expiryAt);
+
+    writer.uint32(88);
+    writer.bool(message.negativeRisk);
+
+    writer.uint32(98);
+    writer.bytes(message.currentPriceBytes);
+
+    writer.uint32(106);
+    writer.string(message.marketTitle);
+
+    writer.uint32(114);
+    writer.string(message.outcome);
+
+    writer.uint32(122);
+    writer.string(message.marketSlug);
+
+    writer.uint32(130);
+    writer.string(message.marketUrl);
+  }
+
+  static decode(reader: Reader, length: i32): PredictionPositionPb {
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new PredictionPositionPb();
+
+    while (reader.ptr < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.conditionIdBytes = reader.bytes();
+          break;
+
+        case 2:
+          message.positionIdBytes = reader.bytes();
+          break;
+
+        case 3:
+          message.outcomeIndex = reader.int32();
+          break;
+
+        case 4:
+          message.sharesBytes = reader.bytes();
+          break;
+
+        case 5:
+          message.collateralTokenAddressBytes = reader.bytes();
+          break;
+
+        case 6:
+          message.collateralDecimals = reader.int32();
+          break;
+
+        case 7:
+          message.maxPayoutBytes = reader.bytes();
+          break;
+
+        case 8:
+          message.status = reader.string();
+          break;
+
+        case 9:
+          message.payoutPerShareBytes = reader.bytes();
+          break;
+
+        case 10:
+          message.expiryAt = reader.int64();
+          break;
+
+        case 11:
+          message.negativeRisk = reader.bool();
+          break;
+
+        case 12:
+          message.currentPriceBytes = reader.bytes();
+          break;
+
+        case 13:
+          message.marketTitle = reader.string();
+          break;
+
+        case 14:
+          message.outcome = reader.string();
+          break;
+
+        case 15:
+          message.marketSlug = reader.string();
+          break;
+
+        case 16:
+          message.marketUrl = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  }
+
+  conditionIdBytes: Uint8Array;
+  positionIdBytes: Uint8Array;
+  outcomeIndex: i32;
+  sharesBytes: Uint8Array;
+  collateralTokenAddressBytes: Uint8Array;
+  collateralDecimals: i32;
+  maxPayoutBytes: Uint8Array;
+  status: string;
+  payoutPerShareBytes: Uint8Array;
+  expiryAt: i64;
+  negativeRisk: bool;
+  currentPriceBytes: Uint8Array;
+  marketTitle: string;
+  outcome: string;
+  marketSlug: string;
+  marketUrl: string;
+
+  constructor(
+    conditionIdBytes: Uint8Array = new Uint8Array(0),
+    positionIdBytes: Uint8Array = new Uint8Array(0),
+    outcomeIndex: i32 = 0,
+    sharesBytes: Uint8Array = new Uint8Array(0),
+    collateralTokenAddressBytes: Uint8Array = new Uint8Array(0),
+    collateralDecimals: i32 = 0,
+    maxPayoutBytes: Uint8Array = new Uint8Array(0),
+    status: string = "",
+    payoutPerShareBytes: Uint8Array = new Uint8Array(0),
+    expiryAt: i64 = 0,
+    negativeRisk: bool = false,
+    currentPriceBytes: Uint8Array = new Uint8Array(0),
+    marketTitle: string = "",
+    outcome: string = "",
+    marketSlug: string = "",
+    marketUrl: string = ""
+  ) {
+    this.conditionIdBytes = conditionIdBytes;
+    this.positionIdBytes = positionIdBytes;
+    this.outcomeIndex = outcomeIndex;
+    this.sharesBytes = sharesBytes;
+    this.collateralTokenAddressBytes = collateralTokenAddressBytes;
+    this.collateralDecimals = collateralDecimals;
+    this.maxPayoutBytes = maxPayoutBytes;
+    this.status = status;
+    this.payoutPerShareBytes = payoutPerShareBytes;
+    this.expiryAt = expiryAt;
+    this.negativeRisk = negativeRisk;
+    this.currentPriceBytes = currentPriceBytes;
+    this.marketTitle = marketTitle;
+    this.outcome = outcome;
+    this.marketSlug = marketSlug;
+    this.marketUrl = marketUrl;
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "datai-sdk",
   "main": "index.ts",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "Datai SDK which has useful libraries to help building projections",
   "scripts": {
     "postinstall": "node postinstall-script.js"