@optimex-xyz/market-maker-sdk 0.9.0 → 0.9.1

package/dist/index.js

@@ -51,6 +51,13 @@ __export(index_exports, {
   SolverService: () => SolverService,
   TokenSchema: () => TokenSchema,
   TokenService: () => TokenService,
+  TradeEventSchema: () => TradeEventSchema,
+  TradeResponseSchema: () => TradeResponseSchema,
+  TradeSchema: () => TradeSchema,
+  TradeService: () => TradeService,
+  TradeStatus: () => TradeStatus,
+  TradeTokenSchema: () => TradeTokenSchema,
+  TradeType: () => TradeType,
   camelToSnakeCase: () => camelToSnakeCase,
   config: () => config,
   confirmDepositType: () => confirmDepositType,
@@ -80,7 +87,8 @@ __export(index_exports, {
   signerService: () => signerService,
   snakeToCamelCase: () => snakeToCamelCase,
   solverService: () => solverService,
-  tokenService: () => tokenService
+  tokenService: () => tokenService,
+  tradeService: () => tradeService
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -5209,7 +5217,7 @@ var solverService = new SolverService();
 
 // src/services/token.service.ts
 var import_axios2 = __toESM(require("axios"));
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/types/token.ts
 var import_zod2 = require("zod");
@@ -5227,12 +5235,100 @@ var TokenSchema = import_zod2.z.object({
   networkLogoUri: import_zod2.z.string()
 });
 
+// src/types/trade.ts
+var import_zod3 = require("zod");
+var TradeStatus = /* @__PURE__ */ ((TradeStatus2) => {
+  TradeStatus2["INIT"] = "INIT";
+  TradeStatus2["PRE_SUBMIT"] = "PRE_SUBMIT";
+  TradeStatus2["DEPOSITED"] = "DEPOSITED";
+  TradeStatus2["SUBMITTED_TO_BE"] = "SUBMITTED_TO_BE";
+  TradeStatus2["SUBMITTED_TO_SOLVER"] = "SUBMITTED_TO_SOLVER";
+  TradeStatus2["SUBMITTED"] = "SUBMITTED";
+  TradeStatus2["DEPOSIT_CONFIRMED"] = "DEPOSIT_CONFIRMED";
+  TradeStatus2["PMM_SELECTED"] = "PMM_SELECTED";
+  TradeStatus2["PAYMENT_MADE"] = "PAYMENT_MADE";
+  TradeStatus2["PAYMENT_CONFIRMED"] = "PAYMENT_CONFIRMED";
+  TradeStatus2["SETTLEMENT_CONFIRMED"] = "SETTLEMENT_CONFIRMED";
+  TradeStatus2["TRADE_TIMEOUT"] = "TRADE_TIMEOUT";
+  TradeStatus2["TIMEOUT"] = "TIMEOUT";
+  TradeStatus2["TIMEOUT_NO_DEPOSIT"] = "TIMEOUT_NO_DEPOSIT";
+  TradeStatus2["PRE_REFUND"] = "PRE_REFUND";
+  TradeStatus2["REFUNDED"] = "REFUNDED";
+  TradeStatus2["RENEW_QUOTE"] = "RENEW_QUOTE";
+  TradeStatus2["BRIDGE_FAILED"] = "BRIDGE_FAILED";
+  TradeStatus2["BRIDGE_SUCCESS"] = "BRIDGE_SUCCESS";
+  TradeStatus2["UNKNOWN"] = "UNKNOWN";
+  return TradeStatus2;
+})(TradeStatus || {});
+var TradeType = /* @__PURE__ */ ((TradeType2) => {
+  TradeType2["OPTIMISTIC"] = "OPTIMISTIC";
+  TradeType2["BASIC"] = "BASIC";
+  return TradeType2;
+})(TradeType || {});
+var TradeTokenSchema = import_zod3.z.object({
+  id: import_zod3.z.number(),
+  chainId: import_zod3.z.string(),
+  tokenId: import_zod3.z.string(),
+  swapType: import_zod3.z.string(),
+  networkId: import_zod3.z.string(),
+  tokenName: import_zod3.z.string(),
+  networkName: import_zod3.z.string(),
+  networkType: import_zod3.z.string(),
+  tokenSymbol: import_zod3.z.string(),
+  tokenAddress: import_zod3.z.string(),
+  tokenLogoUri: import_zod3.z.string(),
+  networkSymbol: import_zod3.z.string(),
+  tokenDecimals: import_zod3.z.number(),
+  networkLogoUri: import_zod3.z.string(),
+  canonicalTokenId: import_zod3.z.string(),
+  acrossTokenAddress: import_zod3.z.string()
+});
+var TradeEventSchema = import_zod3.z.object({
+  id: import_zod3.z.number(),
+  tradeId: import_zod3.z.string(),
+  action: import_zod3.z.string(),
+  txId: import_zod3.z.string().nullable(),
+  blockNumber: import_zod3.z.number(),
+  timestamp: import_zod3.z.number(),
+  inputData: import_zod3.z.record(import_zod3.z.any()),
+  createdAt: import_zod3.z.string(),
+  updatedAt: import_zod3.z.string()
+});
+var TradeSchema = import_zod3.z.object({
+  id: import_zod3.z.number(),
+  tradeId: import_zod3.z.string(),
+  status: import_zod3.z.nativeEnum(TradeStatus),
+  tradeTimeout: import_zod3.z.number().nullable(),
+  scriptTimeout: import_zod3.z.number().nullable(),
+  timestamp: import_zod3.z.number().nullable(),
+  fromUserAddress: import_zod3.z.string().nullable(),
+  toUserAddress: import_zod3.z.string().nullable(),
+  orgId: import_zod3.z.number().nullable(),
+  processedAuto: import_zod3.z.boolean().nullable(),
+  processedAt: import_zod3.z.string().nullable(),
+  depositTxId: import_zod3.z.string().nullable(),
+  settlementTxId: import_zod3.z.string().nullable(),
+  toBridgeTxId: import_zod3.z.string().nullable(),
+  fromBridgeTxId: import_zod3.z.string().nullable(),
+  swapType: import_zod3.z.nativeEnum(TradeType).nullable(),
+  amountIn: import_zod3.z.string().nullable(),
+  fromToken: TradeTokenSchema.nullable(),
+  toToken: TradeTokenSchema.nullable(),
+  createdAt: import_zod3.z.string(),
+  updatedAt: import_zod3.z.string(),
+  events: import_zod3.z.array(TradeEventSchema)
+});
+var TradeResponseSchema = import_zod3.z.object({
+  data: TradeSchema,
+  traceId: import_zod3.z.string()
+});
+
 // src/services/token.service.ts
-var TokenResponseSchema = import_zod3.z.object({
-  data: import_zod3.z.object({
-    tokens: import_zod3.z.array(TokenSchema)
+var TokenResponseSchema = import_zod4.z.object({
+  data: import_zod4.z.object({
+    tokens: import_zod4.z.array(TokenSchema)
   }),
-  traceId: import_zod3.z.string()
+  traceId: import_zod4.z.string()
 });
 var TokenService = class {
   constructor() {
@@ -5266,7 +5362,7 @@ var TokenService = class {
         const errorMessage = error.response?.data?.message || error.response?.data?.error || error.message;
         throw new Error(errorMessage);
       }
-      if (error instanceof import_zod3.z.ZodError) {
+      if (error instanceof import_zod4.z.ZodError) {
         throw new Error(`Invalid token data received: ${error.message}`);
       }
       throw error;
@@ -5321,6 +5417,51 @@ var TokenService = class {
 };
 var tokenService = new TokenService();
 
+// src/services/trade.service.ts
+var import_axios3 = __toESM(require("axios"));
+var import_zod5 = require("zod");
+var TradeService = class {
+  constructor() {
+    this.baseURL = config.getBackendUrl();
+    config.registerObserver(this);
+  }
+  /**
+   * Implementation of ConfigObserver interface
+   * Updates service when config changes
+   */
+  onConfigUpdate(newConfig) {
+    this.baseURL = newConfig.backendUrl;
+  }
+  /**
+   * Fetches a trade by its trade ID
+   * @param tradeId The unique trade ID (hash)
+   * @returns Promise<Trade> The trade details
+   * @throws Error if the API request fails or response validation fails
+   */
+  async getTradeById(tradeId) {
+    try {
+      const response = await import_axios3.default.get(`${this.baseURL}/v1/trades/${tradeId}`, {
+        headers: {
+          Accept: "application/json"
+        }
+      });
+      const camelCaseData = convertToCamelCase(response.data);
+      const validatedResponse = TradeResponseSchema.parse(camelCaseData);
+      return validatedResponse.data;
+    } catch (error) {
+      if (import_axios3.default.isAxiosError(error)) {
+        const errorMessage = error.response?.data?.message || error.response?.data?.error || error.message;
+        throw new Error(errorMessage);
+      }
+      if (error instanceof import_zod5.z.ZodError) {
+        throw new Error(`Invalid trade data received: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+var tradeService = new TradeService();
+
 // src/signatures/domain.ts
 async function defaultDomain(signerHelper, provider) {
   const chainId = (await provider.getNetwork()).chainId;
@@ -5456,6 +5597,13 @@ async function getSignature(Signer2, provider, signerHelper, tradeId, infoHash,
   SolverService,
   TokenSchema,
   TokenService,
+  TradeEventSchema,
+  TradeResponseSchema,
+  TradeSchema,
+  TradeService,
+  TradeStatus,
+  TradeTokenSchema,
+  TradeType,
   camelToSnakeCase,
   config,
   confirmDepositType,
@@ -5485,5 +5633,6 @@ async function getSignature(Signer2, provider, signerHelper, tradeId, infoHash,
   signerService,
   snakeToCamelCase,
   solverService,
-  tokenService
+  tokenService,
+  tradeService
 });

package/dist/index.mjs

@@ -5129,7 +5129,7 @@ var solverService = new SolverService();
 
 // src/services/token.service.ts
 import axios2 from "axios";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/types/token.ts
 import { z as z2 } from "zod";
@@ -5147,12 +5147,100 @@ var TokenSchema = z2.object({
   networkLogoUri: z2.string()
 });
 
+// src/types/trade.ts
+import { z as z3 } from "zod";
+var TradeStatus = /* @__PURE__ */ ((TradeStatus2) => {
+  TradeStatus2["INIT"] = "INIT";
+  TradeStatus2["PRE_SUBMIT"] = "PRE_SUBMIT";
+  TradeStatus2["DEPOSITED"] = "DEPOSITED";
+  TradeStatus2["SUBMITTED_TO_BE"] = "SUBMITTED_TO_BE";
+  TradeStatus2["SUBMITTED_TO_SOLVER"] = "SUBMITTED_TO_SOLVER";
+  TradeStatus2["SUBMITTED"] = "SUBMITTED";
+  TradeStatus2["DEPOSIT_CONFIRMED"] = "DEPOSIT_CONFIRMED";
+  TradeStatus2["PMM_SELECTED"] = "PMM_SELECTED";
+  TradeStatus2["PAYMENT_MADE"] = "PAYMENT_MADE";
+  TradeStatus2["PAYMENT_CONFIRMED"] = "PAYMENT_CONFIRMED";
+  TradeStatus2["SETTLEMENT_CONFIRMED"] = "SETTLEMENT_CONFIRMED";
+  TradeStatus2["TRADE_TIMEOUT"] = "TRADE_TIMEOUT";
+  TradeStatus2["TIMEOUT"] = "TIMEOUT";
+  TradeStatus2["TIMEOUT_NO_DEPOSIT"] = "TIMEOUT_NO_DEPOSIT";
+  TradeStatus2["PRE_REFUND"] = "PRE_REFUND";
+  TradeStatus2["REFUNDED"] = "REFUNDED";
+  TradeStatus2["RENEW_QUOTE"] = "RENEW_QUOTE";
+  TradeStatus2["BRIDGE_FAILED"] = "BRIDGE_FAILED";
+  TradeStatus2["BRIDGE_SUCCESS"] = "BRIDGE_SUCCESS";
+  TradeStatus2["UNKNOWN"] = "UNKNOWN";
+  return TradeStatus2;
+})(TradeStatus || {});
+var TradeType = /* @__PURE__ */ ((TradeType2) => {
+  TradeType2["OPTIMISTIC"] = "OPTIMISTIC";
+  TradeType2["BASIC"] = "BASIC";
+  return TradeType2;
+})(TradeType || {});
+var TradeTokenSchema = z3.object({
+  id: z3.number(),
+  chainId: z3.string(),
+  tokenId: z3.string(),
+  swapType: z3.string(),
+  networkId: z3.string(),
+  tokenName: z3.string(),
+  networkName: z3.string(),
+  networkType: z3.string(),
+  tokenSymbol: z3.string(),
+  tokenAddress: z3.string(),
+  tokenLogoUri: z3.string(),
+  networkSymbol: z3.string(),
+  tokenDecimals: z3.number(),
+  networkLogoUri: z3.string(),
+  canonicalTokenId: z3.string(),
+  acrossTokenAddress: z3.string()
+});
+var TradeEventSchema = z3.object({
+  id: z3.number(),
+  tradeId: z3.string(),
+  action: z3.string(),
+  txId: z3.string().nullable(),
+  blockNumber: z3.number(),
+  timestamp: z3.number(),
+  inputData: z3.record(z3.any()),
+  createdAt: z3.string(),
+  updatedAt: z3.string()
+});
+var TradeSchema = z3.object({
+  id: z3.number(),
+  tradeId: z3.string(),
+  status: z3.nativeEnum(TradeStatus),
+  tradeTimeout: z3.number().nullable(),
+  scriptTimeout: z3.number().nullable(),
+  timestamp: z3.number().nullable(),
+  fromUserAddress: z3.string().nullable(),
+  toUserAddress: z3.string().nullable(),
+  orgId: z3.number().nullable(),
+  processedAuto: z3.boolean().nullable(),
+  processedAt: z3.string().nullable(),
+  depositTxId: z3.string().nullable(),
+  settlementTxId: z3.string().nullable(),
+  toBridgeTxId: z3.string().nullable(),
+  fromBridgeTxId: z3.string().nullable(),
+  swapType: z3.nativeEnum(TradeType).nullable(),
+  amountIn: z3.string().nullable(),
+  fromToken: TradeTokenSchema.nullable(),
+  toToken: TradeTokenSchema.nullable(),
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  events: z3.array(TradeEventSchema)
+});
+var TradeResponseSchema = z3.object({
+  data: TradeSchema,
+  traceId: z3.string()
+});
+
 // src/services/token.service.ts
-var TokenResponseSchema = z3.object({
-  data: z3.object({
-    tokens: z3.array(TokenSchema)
+var TokenResponseSchema = z4.object({
+  data: z4.object({
+    tokens: z4.array(TokenSchema)
   }),
-  traceId: z3.string()
+  traceId: z4.string()
 });
 var TokenService = class {
   constructor() {
@@ -5186,7 +5274,7 @@ var TokenService = class {
         const errorMessage = error.response?.data?.message || error.response?.data?.error || error.message;
         throw new Error(errorMessage);
       }
-      if (error instanceof z3.ZodError) {
+      if (error instanceof z4.ZodError) {
         throw new Error(`Invalid token data received: ${error.message}`);
       }
       throw error;
@@ -5241,6 +5329,51 @@ var TokenService = class {
 };
 var tokenService = new TokenService();
 
+// src/services/trade.service.ts
+import axios3 from "axios";
+import { z as z5 } from "zod";
+var TradeService = class {
+  constructor() {
+    this.baseURL = config.getBackendUrl();
+    config.registerObserver(this);
+  }
+  /**
+   * Implementation of ConfigObserver interface
+   * Updates service when config changes
+   */
+  onConfigUpdate(newConfig) {
+    this.baseURL = newConfig.backendUrl;
+  }
+  /**
+   * Fetches a trade by its trade ID
+   * @param tradeId The unique trade ID (hash)
+   * @returns Promise<Trade> The trade details
+   * @throws Error if the API request fails or response validation fails
+   */
+  async getTradeById(tradeId) {
+    try {
+      const response = await axios3.get(`${this.baseURL}/v1/trades/${tradeId}`, {
+        headers: {
+          Accept: "application/json"
+        }
+      });
+      const camelCaseData = convertToCamelCase(response.data);
+      const validatedResponse = TradeResponseSchema.parse(camelCaseData);
+      return validatedResponse.data;
+    } catch (error) {
+      if (axios3.isAxiosError(error)) {
+        const errorMessage = error.response?.data?.message || error.response?.data?.error || error.message;
+        throw new Error(errorMessage);
+      }
+      if (error instanceof z5.ZodError) {
+        throw new Error(`Invalid trade data received: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+var tradeService = new TradeService();
+
 // src/signatures/domain.ts
 async function defaultDomain(signerHelper, provider) {
   const chainId = (await provider.getNetwork()).chainId;
@@ -5375,6 +5508,13 @@ export {
   SolverService,
   TokenSchema,
   TokenService,
+  TradeEventSchema,
+  TradeResponseSchema,
+  TradeSchema,
+  TradeService,
+  TradeStatus,
+  TradeTokenSchema,
+  TradeType,
   camelToSnakeCase,
   config,
   confirmDepositType,
@@ -5404,5 +5544,6 @@ export {
   signerService,
   snakeToCamelCase,
   solverService,
-  tokenService
+  tokenService,
+  tradeService
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optimex-xyz/market-maker-sdk",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "private": false,
   "publishConfig": {
     "access": "public"