refactor: tag token IDs in bindings

Use a shared TokenId schema across binding models so CTF position identifiers stay distinct from generic strings as the SDK surface grows.

Author: cesarenaldi

packages/bindings/src/clob/market-data.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { TokenIdSchema } from '../shared';
 import { OrderSideSchema } from './order';
 
 export enum PriceHistoryInterval {
@@ -24,10 +25,7 @@ export const PriceSchema = z.looseObject({
 });
 export type Price = z.infer<typeof PriceSchema>;
 
-const PricesBySideSchema = z.object({
-  BUY: z.string().optional(),
-  SELL: z.string().optional(),
-});
+const PricesBySideSchema = z.record(OrderSideSchema, z.string().optional());
 export type PricesBySide = z.infer<typeof PricesBySideSchema>;
 
 export const PricesSchema = z.record(z.string(), PricesBySideSchema);
@@ -47,15 +45,23 @@ export const LastTradePriceSchema = z.looseObject({
 });
 export type LastTradePrice = z.infer<typeof LastTradePriceSchema>;
 
-const LastTradePriceForTokenResponseSchema = LastTradePriceSchema.extend({
-  token_id: z.string(),
-});
+const LastTradePriceForTokenResponseSchema = z
+  .object({
+    price: z.string(),
+    side: OrderSideSchema,
+    token_id: TokenIdSchema,
+  })
+  .transform(({ token_id, price, side }) => ({
+    tokenId: token_id,
+    price,
+    side,
+  }));
 export type LastTradePriceForTokenResponse = z.infer<
   typeof LastTradePriceForTokenResponseSchema
 >;
 
 const LastTradePriceForTokenSchema = z.object({
-  tokenId: z.string(),
+  tokenId: TokenIdSchema,
   price: z.string(),
   side: OrderSideSchema,
 });

packages/bindings/src/gamma/comment.ts

@@ -1,8 +1,9 @@
 import { z } from 'zod';
+import { TokenIdSchema } from '../shared';
 import { ImageOptimizationSchema } from './common';
 
 export const CommentPositionSchema = z.looseObject({
-  tokenId: z.string().nullish(),
+  tokenId: TokenIdSchema.nullish(),
   positionSize: z.string().nullish(),
 });
 

packages/bindings/src/gamma/market.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { MarketIdSchema, TickSizeValueSchema } from '../shared';
+import { MarketIdSchema, TickSizeValueSchema, TokenIdSchema } from '../shared';
 import {
   CategoryReferenceSchema,
   ClobRewardsSchema,
@@ -11,11 +11,21 @@ import {
   TagReferenceSchema,
 } from './common';
 
-const TwoStringTupleSchema = z
+const OutcomePairSchema = z
   .string()
   .transform((val) => JSON.parse(val))
   .pipe(z.tuple([z.string(), z.string()]));
 
+const OutcomePricePairSchema = z
+  .string()
+  .transform((val) => JSON.parse(val))
+  .pipe(z.tuple([z.string(), z.string()]));
+
+const TokenIdPairSchema = z
+  .string()
+  .transform((val) => JSON.parse(val))
+  .pipe(z.tuple([TokenIdSchema, TokenIdSchema]));
+
 export const MarketSchema = z.looseObject({
   id: MarketIdSchema,
   question: z.string().nullish(),
@@ -39,8 +49,8 @@ export const MarketSchema = z.looseObject({
   lowerBound: z.string().nullish(),
   upperBound: z.string().nullish(),
   description: z.string().nullish(),
-  outcomes: TwoStringTupleSchema.nullish(),
-  outcomePrices: TwoStringTupleSchema.nullish(),
+  outcomes: OutcomePairSchema.nullish(),
+  outcomePrices: OutcomePricePairSchema.nullish(),
   volume: z.string().nullish(),
   active: z.boolean().nullish(),
   marketType: z.string().nullish(),
@@ -92,7 +102,7 @@ export const MarketSchema = z.looseObject({
   volume1yr: z.number().nullish(),
   gameStartTime: z.string().nullish(),
   secondsDelay: z.number().int().nullish(),
-  clobTokenIds: TwoStringTupleSchema.nullish(),
+  clobTokenIds: TokenIdPairSchema.nullish(),
   disqusThread: z.string().nullish(),
   shortOutcomes: z.string().nullish(),
   teamAID: z.string().nullish(),

packages/bindings/src/shared.ts

@@ -43,6 +43,7 @@ export type SportId = Tagged<number, 'SportId'>;
 export type TagId = Tagged<string, 'TagId'>;
 export type TeamId = Tagged<number, 'TeamId'>;
 export type TemplateId = Tagged<string, 'TemplateId'>;
+export type TokenId = Tagged<string, 'TokenId'>;
 
 export function toBestLineId(value: string): BestLineId {
   return toTaggedString<BestLineId>(value);
@@ -126,6 +127,10 @@ export function toTemplateId(value: string): TemplateId {
   return toTaggedString<TemplateId>(value);
 }
 
+export function toTokenId(value: string): TokenId {
+  return toTaggedString<TokenId>(value);
+}
+
 export const CategoryIdSchema = z.string().transform(toCategoryId);
 export const ApiKeySchema = z.string().transform(toApiKey);
 export const ClobRewardIdSchema = z.string().transform(toClobRewardId);
@@ -153,6 +158,7 @@ export const NotificationIdSchema = z
   .int()
   .transform(toNotificationId);
 export const TagIdSchema = z.string().transform(toTagId);
+export const TokenIdSchema = z.string().transform(toTokenId);
 export const TxHashSchema = z.string().transform(toTxHash);
 
 export type ISODateString = z.output<typeof ISODateStringSchema>;

packages/client/src/actions/clob.ts

@@ -600,18 +600,13 @@ export async function fetchLastTradePrices(
 ): Promise<LastTradePriceForToken[]> {
   const params = parseUserInput(request, FetchLastTradePricesRequestSchema);
 
-  const response = await unwrap(
+  return unwrap(
     client.clob
       .post('last-trades-prices', {
         json: toTokenRequestPayload(params),
       })
       .andThen(validateWith(LastTradePricesSchema)),
   );
-
-  return response.map(({ token_id, ...trade }) => ({
-    ...trade,
-    tokenId: token_id,
-  }));
 }
 
 const ListPriceHistoryRequestSchema = z.object({