feat: add order query fns and test

Author: royvardhan

packages/filler/src/index.ts

@@ -4,3 +4,4 @@ export { IntentFiller } from "./core/filler"
 export { EventMonitor } from "./core/event-monitor"
 export { BasicFiller } from "./strategies/basic"
 export { ConfirmationPolicy } from "./config/confirmation-policy"
+export { ChainConfigService } from "./services/ChainConfigService"

packages/indexer/src/configs/schema.graphql

@@ -877,43 +877,6 @@ type OrderPlaced @entity {
 	transactionHash: String! @index
 }
 
-type OrderFilled @entity {
-	"""
-	Unique identifier for the order (commitment)
-	"""
-	id: ID!
-
-	"""
-	Address of the user who filled the order
-	"""
-	filler: String! @index
-
-	"""
-	Reference to the order that was filled
-	"""
-	order: OrderPlaced!
-
-	"""
-	Timestamp when the order was filled
-	"""
-	createdAt: Date! @index
-
-	"""
-	Block number where the order was filled
-	"""
-	blockNumber: BigInt! @index
-
-	"""
-	Timestamp of the block where the order was filled
-	"""
-	blockTimestamp: BigInt! @index
-
-	"""
-	Hash of the transaction that filled the order
-	"""
-	transactionHash: String! @index
-}
-
 """
 Metadata about the status of an Order
 """

packages/indexer/src/services/intentGateway.service.ts

@@ -182,7 +182,7 @@ export class IntentGatewayService {
 			await orderPlaced.save()
 		}
 
-		await OrderStatusMetadata.create({
+		const orderStatusMetadata = await OrderStatusMetadata.create({
 			id: `${commitment}.${status}`,
 			orderId: commitment,
 			status,
@@ -193,6 +193,8 @@ export class IntentGatewayService {
 			transactionHash,
 			createdAt: timestampToDate(timestamp),
 		})
+
+		await orderStatusMetadata.save()
 	}
 
 	static bytes32ToBytes20(bytes32: string): string {

packages/sdk/package.json

@@ -49,13 +49,15 @@
 		"test:concurrent": "vitest --watch=false --exclude=./src/tests/sequential",
 		"test:sequence": "vitest --watch=false --sequence.concurrent=false ./src/tests/sequential/**",
 		"test:requests": "vitest --watch=false --sequence.concurrent=false ./src/tests/sequential/requests.test.ts",
+		"test:intent-gateway": "vitest --watch=false --sequence.concurrent=false ./src/tests/intentGateway.test.ts",
 		"test:watch": "vitest --exclude=./src/tests/sequential",
 		"lint": "biome lint .",
 		"lint:fix": "biome lint --write .",
 		"format": "prettier --write \"src/**/*.ts\""
 	},
 	"dependencies": {
 		"@async-generator/merge-race": "^1.0.3",
+		"@hyperbridge/filler": "workspace:*",
 		"@polkadot/api": "^15.7.1",
 		"@polkadot/types": "14.0.1",
 		"@polkadot/util": "13.3.1",

packages/sdk/pnpm-lock.yaml

@@ -25,6 +25,8 @@ import {
 	type RequestStatusKey,
 	type TimeoutStatusKey,
 	type PostRequestStatus,
+	type OrderWithStatus,
+	OrderStatus,
 } from "@/types"
 import {
 	STATE_MACHINE_UPDATES_BY_HEIGHT,
@@ -45,7 +47,7 @@ import {
 	waitForChallengePeriod,
 } from "@/utils"
 import { getChain, type IChain, type SubstrateChain } from "@/chain"
-import { _queryGetRequestInternal, _queryRequestInternal } from "./query-client"
+import { _queryGetRequestInternal, _queryRequestInternal, _queryOrderInternal } from "./query-client"
 
 /**
  * IndexerClient provides methods for interacting with the Hyperbridge indexer.
@@ -1316,16 +1318,6 @@ export class IndexerClient {
 		}
 	}
 
-	/**
-	 * Executes an async operation with exponential backoff retry
-	 * @param operation - Async function to execute
-	 * @param retryConfig - Optional retry configuration
-	 * @returns Result of the operation
-	 * @throws Last encountered error after all retries are exhausted
-	 *
-	 * @example
-	 * const result = await this.withRetry(() => this.queryStatus(hash));
-	 */
 	/**
 	 * Query for asset teleported events by sender, recipient, and destination chain
 	 * @param from - The sender address
@@ -1367,6 +1359,107 @@ export class IndexerClient {
 			...retryConfig,
 		})
 	}
+
+	/**
+	 * Query for an order by its commitment hash
+	 * @param commitment - The commitment hash of the order
+	 * @returns The order with its status if found, undefined otherwise
+	 */
+	async queryOrder(commitment: HexString): Promise<OrderWithStatus | undefined> {
+		return _queryOrderInternal({
+			commitmentHash: commitment,
+			queryClient: this.client,
+			logger: this.logger,
+		})
+	}
+
+	/**
+	 * Create a Stream of status updates for an order.
+	 * Stream ends when the order reaches a terminal state (FILLED, REDEEMED, or REFUNDED).
+	 * @param commitment - The commitment hash of the order
+	 * @returns AsyncGenerator that emits status updates until a terminal state is reached
+	 * @example
+	 *
+	 * let client = new IndexerClient(config)
+	 * let stream = client.orderStatusStream(commitment)
+	 *
+	 * // you can use a for-await-of loop
+	 * for await (const status of stream) {
+	 *   console.log(status)
+	 * }
+	 *
+	 * // you can also use a while loop
+	 * while (true) {
+	 *   const status = await stream.next()
+	 *   if (status.done) {
+	 *     break
+	 *   }
+	 *   console.log(status.value)
+	 * }
+	 */
+	async *orderStatusStream(commitment: HexString): AsyncGenerator<
+		{
+			status: OrderStatus
+			metadata: {
+				blockHash: string
+				blockNumber: number
+				transactionHash: string
+				timestamp: bigint
+				filler?: string
+			}
+		},
+		void
+	> {
+		const logger = this.logger.withTag("[orderStatusStream]")
+
+		let order: OrderWithStatus | undefined
+
+		while (!order) {
+			await this.sleep_for_interval()
+			order = await _queryOrderInternal({
+				commitmentHash: commitment,
+				queryClient: this.client,
+				logger: this.logger,
+			})
+		}
+
+		logger.trace("`Order` found")
+		// Yield initial status
+		const latestStatus = order.statuses[order.statuses.length - 1]
+		yield {
+			status: latestStatus.status,
+			metadata: latestStatus.metadata,
+		}
+
+		// If we're already in a terminal state, end the stream
+		if ([OrderStatus.FILLED, OrderStatus.REDEEMED, OrderStatus.REFUNDED].includes(latestStatus.status)) {
+			return
+		}
+
+		while (true) {
+			await this.sleep_for_interval()
+			const updatedOrder = await _queryOrderInternal({
+				commitmentHash: commitment,
+				queryClient: this.client,
+				logger: this.logger,
+			})
+
+			if (!updatedOrder) continue
+
+			const newLatestStatus = updatedOrder.statuses[updatedOrder.statuses.length - 1]
+
+			if (newLatestStatus.status !== latestStatus.status) {
+				yield {
+					status: newLatestStatus.status,
+					metadata: newLatestStatus.metadata,
+				}
+
+				if ([OrderStatus.FILLED, OrderStatus.REDEEMED, OrderStatus.REFUNDED].includes(newLatestStatus.status)) {
+					return
+				}
+			}
+		}
+	}
 }
 
 interface PartialClientConfig extends Omit<ClientConfig, "pollInterval"> {

packages/sdk/src/client.ts

@@ -156,3 +156,44 @@ query GetResponseByRequestId($requestId: String!) {
   }
 }
 `
+
+export const ORDER_STATUS = `
+query OrderStatus($commitment: String!) {
+  orderPlaceds(
+    filter: { commitment: { equalTo: $commitment } }
+  ) {
+    nodes {
+      id
+      user
+      sourceChain
+      destChain
+      commitment
+      deadline
+      nonce
+      fees
+      inputTokens
+      inputAmounts
+      inputValuesUSD
+      inputUSD
+      outputTokens
+      outputAmounts
+      outputBeneficiaries
+      calldata
+      status
+      createdAt
+      blockNumber
+      blockTimestamp
+      transactionHash
+      statusMetadata {
+        nodes {
+          status
+          chain
+          timestamp
+          blockNumber
+          transactionHash
+          filler
+        }
+      }
+    }
+  }
+}`

packages/sdk/src/queries.ts

@@ -7,9 +7,11 @@ import type {
 	RequestResponse,
 	RequestStatusKey,
 	PostRequestWithStatus,
+	OrderResponse,
+	OrderWithStatus,
 } from "./types"
 import type { ConsolaInstance } from "consola"
-import { GET_REQUEST_STATUS, POST_REQUEST_STATUS } from "./queries"
+import { GET_REQUEST_STATUS, POST_REQUEST_STATUS, ORDER_STATUS } from "./queries"
 
 export function createQueryClient(config: { url: string }) {
 	return new GraphQLClient(config.url)
@@ -47,6 +49,22 @@ export function queryGetRequest(params: { commitmentHash: string; queryClient: I
 	return _queryGetRequestInternal(params)
 }
 
+/**
+ * Queries an order by CommitmentHash
+ *
+ * @example
+ * import { createQueryClient, queryOrder } from "hyperbridge-sdk"
+ *
+ * const queryClient = createQueryClient({
+ *   url: "http://localhost:3000", // URL of the Hyperbridge indexer API
+ * })
+ * const commitmentHash = "0x...."
+ * const order = await queryOrder({ commitmentHash, queryClient })
+ */
+export function queryOrder(params: { commitmentHash: string; queryClient: IndexerQueryClient }) {
+	return _queryOrderInternal(params)
+}
+
 type InternalQueryParams = {
 	commitmentHash: string
 	queryClient: IndexerQueryClient
@@ -161,3 +179,65 @@ export async function _queryGetRequestInternal(params: InternalQueryParams): Pro
 		statuses: sorted,
 	}
 }
+
+/**
+ * Internal function to query an order by CommitmentHash
+ *
+ * @param params - Parameters for querying the order
+ * @returns Latest status and block metadata of the order
+ */
+export async function _queryOrderInternal(params: InternalQueryParams): Promise<OrderWithStatus | undefined> {
+	const { commitmentHash, queryClient: client, logger = DEFAULT_LOGGER } = params
+
+	const response = await retryPromise(
+		() => {
+			return client.request<OrderResponse>(ORDER_STATUS, {
+				commitment: commitmentHash,
+			})
+		},
+		{
+			maxRetries: 3,
+			backoffMs: 1000,
+			logger,
+			logMessage: `querying 'Order' with Statuses by CommitmentHash(${commitmentHash})`,
+		},
+	)
+
+	const first_record = response.orderPlaceds.nodes[0]
+	if (!first_record) return
+
+	logger.trace("`Order` found")
+	const { statusMetadata, ...first_node } = first_record
+
+	const statuses = structuredClone(statusMetadata.nodes).map((item) => ({
+		status: item.status,
+		metadata: {
+			blockHash: item.blockHash,
+			blockNumber: Number.parseInt(item.blockNumber),
+			transactionHash: item.transactionHash,
+			timestamp: BigInt(item.timestamp),
+			filler: item.filler,
+		},
+	}))
+
+	// sort by ascending order
+	const sorted = statuses.sort((a, b) => {
+		// Since OrderStatus and RequestStatus are different enums, we'll just sort by timestamp
+		return Number(a.metadata.timestamp) - Number(b.metadata.timestamp)
+	})
+
+	const order: OrderWithStatus = {
+		...first_node,
+		deadline: BigInt(first_node.deadline),
+		nonce: BigInt(first_node.nonce),
+		fees: BigInt(first_node.fees),
+		inputAmounts: first_node.inputAmounts.map(BigInt),
+		outputAmounts: first_node.outputAmounts.map(BigInt),
+		blockNumber: BigInt(first_node.blockNumber),
+		blockTimestamp: BigInt(first_node.blockTimestamp),
+		createdAt: new Date(first_node.createdAt),
+		statuses: sorted,
+	}
+
+	return order
+}