@minswap/sdk-v2 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -190,6 +190,61 @@ var AppApiClient = class {
   }
 };
 
+// src/client/config.ts
+var DEFAULT_ENDPOINTS = {
+  mainnet: {
+    appApiUrl: "https://api-internal.minswap.org",
+    aggregatorApiUrl: "https://agg-api.minswap.org",
+    keyAppApiUrl: "https://k-app-monorepo-mainnet-prod.minswap.org/graphql"
+  }
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRY = {
+  retries: 2,
+  baseDelayMs: 300
+};
+function invalid(param, reason) {
+  throw new MinswapError(`Invalid config: ${param} ${reason}`, "INVALID_PARAMS" /* INVALID_PARAMS */, {
+    param,
+    reason
+  });
+}
+function resolveConfig(config = {}) {
+  const network = config.network ?? "mainnet";
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    invalid(
+      "fetch",
+      "is not available on globalThis; pass an implementation via `new MinswapSdk({ fetch })`"
+    );
+  }
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    invalid("timeoutMs", "must be a positive finite number");
+  }
+  const retries = config.retry?.retries ?? DEFAULT_RETRY.retries;
+  if (!Number.isInteger(retries) || retries < 0) {
+    invalid("retry.retries", "must be a non-negative integer");
+  }
+  const baseDelayMs = config.retry?.baseDelayMs ?? DEFAULT_RETRY.baseDelayMs;
+  if (!Number.isFinite(baseDelayMs) || baseDelayMs < 0) {
+    invalid("retry.baseDelayMs", "must be a non-negative finite number");
+  }
+  return {
+    network,
+    currency: config.currency ?? "USD",
+    apiKey: config.apiKey,
+    endpoints: {
+      ...DEFAULT_ENDPOINTS[network],
+      ...config.endpoints
+    },
+    fetch: fetchImpl,
+    timeoutMs,
+    retry: { retries, baseDelayMs },
+    rpcProvider: config.rpcProvider
+  };
+}
+
 // src/client/http.ts
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function isRetryable(error) {
@@ -379,8 +434,6 @@ async function readBody(response) {
 function truncate(value, max = 300) {
   return value.length <= max ? value : `${value.slice(0, max)}\u2026`;
 }
-
-// src/client/app-graphql-client.ts
 var graphqlEnvelope = zod.z.object({
   data: zod.z.unknown().nullish(),
   errors: zod.z.array(
@@ -390,137 +443,6 @@ var graphqlEnvelope = zod.z.object({
     })
   ).nullish()
 });
-var AppGraphqlClient = class {
-  constructor(http, config) {
-    this.http = http;
-    this.config = config;
-  }
-  http;
-  config;
-  async execute(operation) {
-    const endpoint = `GraphQL ${operation.operation}`;
-    const response = await this.http.request({
-      url: this.config.endpoints.appGraphqlUrl,
-      method: "POST",
-      endpoint,
-      body: {
-        // No `operationName`: each document defines exactly one operation, so
-        // the server runs it without one. Sending the field name would have to
-        // match the document's operation name exactly — a needless coupling.
-        query: operation.document,
-        variables: operation.variables ?? {}
-      },
-      schema: graphqlEnvelope,
-      // Resolver errors can come back with a 400/500 status; decode the body
-      // anyway so the GraphQL `errors` array is not lost as an opaque API error.
-      parseErrorBody: true
-    });
-    if (response.errors && response.errors.length > 0) {
-      throw new MinswapError(
-        `${operation.operation} failed: ${response.errors.map((e) => e.message).join("; ")}`,
-        "GRAPHQL_ERROR" /* GRAPHQL_ERROR */,
-        {
-          operation: operation.operation,
-          errors: response.errors.map((e) => ({
-            message: e.message,
-            path: e.path ?? void 0
-          }))
-        }
-      );
-    }
-    const data = response.data;
-    if (data === null || data === void 0) {
-      throw new MinswapError(
-        `${operation.operation} returned no data and no errors`,
-        "PARSE_ERROR" /* PARSE_ERROR */,
-        {
-          endpoint,
-          issues: [{ path: "data", message: "Expected an object, received null" }]
-        }
-      );
-    }
-    const root = data;
-    const keys = Object.keys(root);
-    if (keys.length !== 1) {
-      throw new MinswapError(
-        `${operation.operation} expected a single root field, got [${keys.join(", ")}]`,
-        "PARSE_ERROR" /* PARSE_ERROR */,
-        {
-          endpoint,
-          issues: [
-            { path: "data", message: `expected exactly one root field, got ${keys.length}` }
-          ]
-        }
-      );
-    }
-    return parseOrThrow(operation.schema, root[keys[0]], endpoint);
-  }
-};
-
-// src/client/config.ts
-var DEFAULT_ENDPOINTS = {
-  mainnet: {
-    appApiUrl: "https://api-internal.minswap.org",
-    aggregatorApiUrl: "https://agg-api.minswap.org",
-    keyAppApiUrl: "https://k-app-monorepo-mainnet-prod.minswap.org/graphql",
-    appGraphqlUrl: "https://app-monorepo-mainnet-prod.minswap.org/graphql"
-  }
-};
-var DEFAULT_TIMEOUT_MS = 3e4;
-var DEFAULT_RETRY = {
-  retries: 2,
-  baseDelayMs: 300
-};
-function invalid(param, reason) {
-  throw new MinswapError(`Invalid config: ${param} ${reason}`, "INVALID_PARAMS" /* INVALID_PARAMS */, {
-    param,
-    reason
-  });
-}
-function resolveConfig(config = {}) {
-  const network = config.network ?? "mainnet";
-  const fetchImpl = config.fetch ?? globalThis.fetch;
-  if (typeof fetchImpl !== "function") {
-    invalid(
-      "fetch",
-      "is not available on globalThis; pass an implementation via `new MinswapSdk({ fetch })`"
-    );
-  }
-  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    invalid("timeoutMs", "must be a positive finite number");
-  }
-  const retries = config.retry?.retries ?? DEFAULT_RETRY.retries;
-  if (!Number.isInteger(retries) || retries < 0) {
-    invalid("retry.retries", "must be a non-negative integer");
-  }
-  const baseDelayMs = config.retry?.baseDelayMs ?? DEFAULT_RETRY.baseDelayMs;
-  if (!Number.isFinite(baseDelayMs) || baseDelayMs < 0) {
-    invalid("retry.baseDelayMs", "must be a non-negative finite number");
-  }
-  return {
-    network,
-    currency: config.currency ?? "USD",
-    apiKey: config.apiKey,
-    endpoints: {
-      ...DEFAULT_ENDPOINTS[network],
-      ...config.endpoints
-    },
-    fetch: fetchImpl,
-    timeoutMs,
-    retry: { retries, baseDelayMs },
-    rpcProvider: config.rpcProvider
-  };
-}
-var graphqlEnvelope2 = zod.z.object({
-  data: zod.z.unknown().nullish(),
-  errors: zod.z.array(
-    zod.z.object({
-      message: zod.z.string(),
-      path: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).nullish()
-    })
-  ).nullish()
-});
 var KeyAppApiClient = class {
   constructor(http, config) {
     this.http = http;
@@ -543,7 +465,7 @@ var KeyAppApiClient = class {
         query: operation.document,
         variables: operation.variables ?? {}
       },
-      schema: graphqlEnvelope2,
+      schema: graphqlEnvelope,
       // This host returns resolver errors with a 400/500 status; decode the
       // body anyway so the GraphQL `errors` array is not lost.
       parseErrorBody: true
@@ -623,115 +545,6 @@ function inputAssetToCoinId(asset2) {
   }
   return asset2.tokenName === "" ? asset2.currencySymbol : `${asset2.currencySymbol}.${asset2.tokenName}`;
 }
-function arrayOf(schema) {
-  return zod.z.array(schema).nullish().transform((value) => value ?? []);
-}
-var zeroableNumber = zod.z.number().nullish().transform((value) => value ?? 0);
-var coinBasicInfoSchema = zod.z.object({
-  coin_type: zod.z.string().nullish(),
-  symbol: zod.z.string(),
-  decimals: zod.z.number(),
-  icon_url: zod.z.string(),
-  verified: zod.z.boolean()
-}).transform((c) => ({
-  coinId: c.coin_type ?? null,
-  symbol: c.symbol,
-  decimals: c.decimals,
-  iconUrl: c.icon_url,
-  verified: c.verified
-}));
-var coinAmountInfoSchema = zod.z.object({
-  coin_type: zod.z.string().nullish(),
-  symbol: zod.z.string(),
-  decimals: zod.z.number(),
-  icon_url: zod.z.string(),
-  verified: zod.z.boolean(),
-  amount: zod.z.number(),
-  usd_value: zod.z.number()
-}).transform((c) => ({
-  coinId: c.coin_type ?? null,
-  symbol: c.symbol,
-  decimals: c.decimals,
-  iconUrl: c.icon_url,
-  verified: c.verified,
-  amount: c.amount,
-  usdValue: c.usd_value
-}));
-var poolCoinSchema = zod.z.object({
-  coin_type: zod.z.string().nullish(),
-  symbol: zod.z.string(),
-  decimals: zod.z.number(),
-  icon_url: zod.z.string(),
-  verified: zod.z.boolean(),
-  category: zod.z.string().nullish()
-}).transform((c) => ({
-  coinId: c.coin_type ?? null,
-  symbol: c.symbol,
-  decimals: c.decimals,
-  iconUrl: c.icon_url,
-  verified: c.verified,
-  /** Free-form; not constrained to the `categoryGroup` filter values. */
-  category: c.category ?? null
-}));
-var poolRewardSchema = zod.z.object({
-  coin_type: zod.z.string().nullish(),
-  symbol: zod.z.string(),
-  decimals: zod.z.number(),
-  icon_url: zod.z.string(),
-  verified: zod.z.boolean(),
-  daily_amount: zod.z.number(),
-  daily_amount_usd: zod.z.number(),
-  apr: zod.z.number()
-}).transform((r) => ({
-  coinId: r.coin_type ?? null,
-  symbol: r.symbol,
-  decimals: r.decimals,
-  iconUrl: r.icon_url,
-  verified: r.verified,
-  dailyAmount: r.daily_amount,
-  dailyAmountUsd: r.daily_amount_usd,
-  apr: r.apr
-}));
-var poolFeeSchema = zod.z.object({ fee_raw: zod.z.number(), fee_usd: zod.z.number() }).transform((f) => ({ feeRaw: f.fee_raw, feeUsd: f.fee_usd }));
-var coinCandleSchema = zod.z.object({
-  t: zod.z.string(),
-  ohlcv: zod.z.array(zod.z.number()).nullish()
-}).transform(({ t, ohlcv }) => {
-  const [open = 0, high = 0, low = 0, close = 0, volume = 0] = ohlcv ?? [];
-  return { timestamp: Date.parse(t), open, high, low, close, volume };
-});
-var poolCandleSchema = zod.z.array(zod.z.number()).transform(([seconds = 0, open = 0, high = 0, low = 0, close = 0, volume = 0]) => ({
-  timestamp: seconds * 1e3,
-  open,
-  high,
-  low,
-  close,
-  volume
-}));
-var VALID_BUCKET_MINUTES = [
-  1,
-  5,
-  15,
-  30,
-  60,
-  120,
-  240,
-  360,
-  720,
-  1440,
-  5760,
-  10080,
-  43200
-];
-function assertBucket(bucketMinutes) {
-  if (!VALID_BUCKET_MINUTES.includes(bucketMinutes)) {
-    throw new MinswapError(
-      `bucketMinutes must be one of ${VALID_BUCKET_MINUTES.join(", ")}; received ${bucketMinutes}`,
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      { param: "bucketMinutes", reason: "unsupported bucket size" }
-    );
-  }
-}
 
 // src/modules/aggregator-module.ts
 var AGGREGATOR_PROTOCOLS = [
@@ -876,35 +689,6 @@ var estimateSchema = zod.z.object({
 }));
 var buildTxResponseSchema = zod.z.object({ cbor: zod.z.string() }).transform((r) => ({ cbor: r.cbor }));
 var submitResponseSchema = zod.z.object({ tx_id: zod.z.string() }).transform((r) => ({ txId: r.tx_id }));
-var pendingOrderSchema = zod.z.object({
-  owner_address: zod.z.string(),
-  protocol: zod.z.string(),
-  token_in: assetSchema,
-  token_out: assetSchema,
-  amount_in: zod.z.string(),
-  min_amount_out: zod.z.string(),
-  created_at: zod.z.number(),
-  tx_in: zod.z.string(),
-  dex_fee: zod.z.string(),
-  deposit: zod.z.string()
-}).transform((o) => ({
-  ownerAddress: o.owner_address,
-  protocol: o.protocol,
-  tokenIn: o.token_in,
-  tokenOut: o.token_out,
-  amountIn: o.amount_in,
-  minAmountOut: o.min_amount_out,
-  /** Epoch seconds. */
-  createdAt: o.created_at,
-  /** The order's UTxO reference, `txHash#index` — pass to {@link AggregatorModule.cancelOrders}. */
-  txIn: o.tx_in,
-  dexFee: o.dex_fee,
-  deposit: o.deposit
-}));
-var pendingOrdersSchema = zod.z.object({
-  orders: arrayOf(pendingOrderSchema),
-  amount_in_decimal: zod.z.boolean()
-}).transform((r) => r.orders);
 function estimateBody(params) {
   return dropUndefined({
     amount: params.amount,
@@ -1005,23 +789,6 @@ var AggregatorModule = class {
       schema: buildTxResponseSchema
     });
   }
-  /**
-   * List an address's still-open aggregator orders.
-   *
-   * Only orders whose UTxO is still unspent are returned, so this is genuinely
-   * "open orders" rather than history. For full history including filled and
-   * cancelled orders, use {@link OrderModule.getHistory}.
-   */
-  async getPendingOrders(ownerAddress, options = {}) {
-    return this.sdk.clients.aggregatorApi.get({
-      path: "/aggregator/pending-orders",
-      query: {
-        owner_address: ownerAddress,
-        amount_in_decimal: options.amountInDecimal
-      },
-      schema: pendingOrdersSchema
-    });
-  }
 };
 function dropUndefined(obj) {
   for (const key of Object.keys(obj)) {
@@ -1112,6 +879,115 @@ async function collect(fetchPage, options = {}) {
   }
   return items;
 }
+function arrayOf(schema) {
+  return zod.z.array(schema).nullish().transform((value) => value ?? []);
+}
+var zeroableNumber = zod.z.number().nullish().transform((value) => value ?? 0);
+var coinBasicInfoSchema = zod.z.object({
+  coin_type: zod.z.string().nullish(),
+  symbol: zod.z.string(),
+  decimals: zod.z.number(),
+  icon_url: zod.z.string(),
+  verified: zod.z.boolean()
+}).transform((c) => ({
+  coinId: c.coin_type ?? null,
+  symbol: c.symbol,
+  decimals: c.decimals,
+  iconUrl: c.icon_url,
+  verified: c.verified
+}));
+var coinAmountInfoSchema = zod.z.object({
+  coin_type: zod.z.string().nullish(),
+  symbol: zod.z.string(),
+  decimals: zod.z.number(),
+  icon_url: zod.z.string(),
+  verified: zod.z.boolean(),
+  amount: zod.z.number(),
+  usd_value: zod.z.number()
+}).transform((c) => ({
+  coinId: c.coin_type ?? null,
+  symbol: c.symbol,
+  decimals: c.decimals,
+  iconUrl: c.icon_url,
+  verified: c.verified,
+  amount: c.amount,
+  usdValue: c.usd_value
+}));
+var poolCoinSchema = zod.z.object({
+  coin_type: zod.z.string().nullish(),
+  symbol: zod.z.string(),
+  decimals: zod.z.number(),
+  icon_url: zod.z.string(),
+  verified: zod.z.boolean(),
+  category: zod.z.string().nullish()
+}).transform((c) => ({
+  coinId: c.coin_type ?? null,
+  symbol: c.symbol,
+  decimals: c.decimals,
+  iconUrl: c.icon_url,
+  verified: c.verified,
+  /** Free-form; not constrained to the `categoryGroup` filter values. */
+  category: c.category ?? null
+}));
+var poolRewardSchema = zod.z.object({
+  coin_type: zod.z.string().nullish(),
+  symbol: zod.z.string(),
+  decimals: zod.z.number(),
+  icon_url: zod.z.string(),
+  verified: zod.z.boolean(),
+  daily_amount: zod.z.number(),
+  daily_amount_usd: zod.z.number(),
+  apr: zod.z.number()
+}).transform((r) => ({
+  coinId: r.coin_type ?? null,
+  symbol: r.symbol,
+  decimals: r.decimals,
+  iconUrl: r.icon_url,
+  verified: r.verified,
+  dailyAmount: r.daily_amount,
+  dailyAmountUsd: r.daily_amount_usd,
+  apr: r.apr
+}));
+var poolFeeSchema = zod.z.object({ fee_raw: zod.z.number(), fee_usd: zod.z.number() }).transform((f) => ({ feeRaw: f.fee_raw, feeUsd: f.fee_usd }));
+var coinCandleSchema = zod.z.object({
+  t: zod.z.string(),
+  ohlcv: zod.z.array(zod.z.number()).nullish()
+}).transform(({ t, ohlcv }) => {
+  const [open = 0, high = 0, low = 0, close = 0, volume = 0] = ohlcv ?? [];
+  return { timestamp: Date.parse(t), open, high, low, close, volume };
+});
+var poolCandleSchema = zod.z.array(zod.z.number()).transform(([seconds = 0, open = 0, high = 0, low = 0, close = 0, volume = 0]) => ({
+  timestamp: seconds * 1e3,
+  open,
+  high,
+  low,
+  close,
+  volume
+}));
+var VALID_BUCKET_MINUTES = [
+  1,
+  5,
+  15,
+  30,
+  60,
+  120,
+  240,
+  360,
+  720,
+  1440,
+  5760,
+  10080,
+  43200
+];
+function assertBucket(bucketMinutes) {
+  if (!VALID_BUCKET_MINUTES.includes(bucketMinutes)) {
+    throw new MinswapError(
+      `bucketMinutes must be one of ${VALID_BUCKET_MINUTES.join(", ")}; received ${bucketMinutes}`,
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      { param: "bucketMinutes", reason: "unsupported bucket size" }
+    );
+  }
+}
 
 // src/client/rpc-provider.ts
 function parseTxIn(ref) {
@@ -1623,11 +1499,11 @@ function calculateDepositSwapAmount(params) {
   const { amountIn, amountOut, reserveIn, reserveOut, tradingFeeNumerator } = params;
   const x = (amountOut + reserveOut) * reserveIn;
   const y = 4n * (amountOut + reserveOut) * (amountOut * reserveIn * reserveIn - amountIn * reserveIn * reserveOut);
-  const z14 = 2n * (amountOut + reserveOut);
+  const z13 = 2n * (amountOut + reserveOut);
   const twoDenomMinusFee = 2n * FEE_DENOMINATOR - tradingFeeNumerator;
   const a = x * x * (twoDenomMinusFee * twoDenomMinusFee) - y * FEE_DENOMINATOR * (FEE_DENOMINATOR - tradingFeeNumerator);
   const b = twoDenomMinusFee * x;
-  return [sqrt(a) - b, z14 * (FEE_DENOMINATOR - tradingFeeNumerator)];
+  return [sqrt(a) - b, z13 * (FEE_DENOMINATOR - tradingFeeNumerator)];
 }
 function calculateDepositAmount(params) {
   const { amountA, amountB, pool } = params;
@@ -1764,6 +1640,17 @@ async function loadDexSerializer() {
   })();
   return cached;
 }
+function paymentCredentialHex(addr) {
+  const credential2 = addr.toPaymentCredential();
+  if (!credential2) {
+    throw new MinswapError(
+      "Sender address has no payment credential",
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      { param: "sender", reason: "address has no payment credential" }
+    );
+  }
+  return credential2.payload.hex;
+}
 async function toDatumHex(datum) {
   const { PlutusData: plutus } = await loadDexSerializer();
   return plutus.toDataHex(datum);
@@ -1775,8 +1662,18 @@ async function loadDexBuilder() {
 // src/liquidity/build/assemble.ts
 async function assembleOrder(order) {
   const b = await loadDexBuilder();
-  const { TxBuilderV2, TxOut, Value, Address, Asset, Bytes, DatumSource, Utxo, EmulatorProvider } = b;
-  const CoinSelectionAlgorithm = b.CoinSelectionAlgorithm;
+  const {
+    TxBuilderV2,
+    TxOut,
+    Value,
+    Address,
+    Asset,
+    Bytes,
+    DatumSource,
+    Utxo,
+    EmulatorProvider,
+    CoinSelectionAlgorithm
+  } = b;
   const valueMap = { lovelace: order.lovelace };
   for (const a of order.assets) {
     valueMap[Asset.fromBlockFrostString(a.unit).toString()] = a.amount;
@@ -1805,7 +1702,7 @@ var unitOf = (a) => a.policyId + a.nameHex;
 async function resolveSender(sender) {
   const b = await loadDexBuilder();
   const addr = b.Address.fromBech32(sender);
-  const paymentKeyHash = addr.toPaymentCredential().payload.hex;
+  const paymentKeyHash = paymentCredentialHex(addr);
   const stakeAddr = addr.toStakeAddress?.();
   const stakeKeyHash = stakeAddr ? stakeAddr.toPubKeyHash()?.keyHash.hex ?? null : null;
   const orderAddress = b.Address.fromPlutusJson(
@@ -1911,7 +1808,7 @@ var unitOf2 = (a) => a.policyId + a.nameHex;
 async function resolveSender2(sender) {
   const b = await loadDexBuilder();
   const addr = b.Address.fromBech32(sender);
-  const paymentKeyHash = addr.toPaymentCredential().payload.hex;
+  const paymentKeyHash = paymentCredentialHex(addr);
   const stakeAddr = addr.toStakeAddress?.();
   const stakeKeyHash = stakeAddr ? stakeAddr.toPubKeyHash()?.keyHash.hex ?? null : null;
   const orderAddress = b.Address.fromPlutusJson(
@@ -2274,7 +2171,7 @@ var unitOfLpAsset = (a) => a.policyId + a.nameHex;
 async function resolveSender3(sender) {
   const b = await loadDexBuilder();
   const addr = b.Address.fromBech32(sender);
-  const paymentKeyHash = addr.toPaymentCredential().payload.hex;
+  const paymentKeyHash = paymentCredentialHex(addr);
   const stakeAddr = addr.toStakeAddress?.();
   const stakeKeyHash = stakeAddr ? stakeAddr.toPubKeyHash()?.keyHash.hex ?? null : null;
   return { paymentKeyHash, stakeKeyHash };
@@ -2579,206 +2476,133 @@ function getStableswapConfigByLpAsset(lpAsset) {
   }
   return config;
 }
-var assetSchema2 = zod.z.object({
-  currencySymbol: zod.z.string(),
-  tokenName: zod.z.string(),
-  metadata: zod.z.object({ decimals: zod.z.number().nullish() }).nullish()
+var POOL_STATE_PATH = "/api/v1/pool/state";
+var POOL_STATE_ENDPOINT = `GET ${POOL_STATE_PATH}`;
+var MAX_POOL_IDS = 50;
+var uint = zod.z.string().regex(/^\d+$/, "expected a non-negative decimal integer string").transform((s) => BigInt(s));
+var coinSchema = zod.z.object({
+  coin_type: zod.z.string(),
+  symbol: zod.z.string(),
+  decimals: zod.z.number().nullish()
 });
-var ammPoolSchema = zod.z.object({
-  type: zod.z.enum(["DEX", "DEX_V2", "STABLESWAP"]),
-  lpAsset: assetSchema2,
-  poolAssets: zod.z.array(assetSchema2),
-  utxo: zod.z.object({
-    address: zod.z.string(),
-    datum: zod.z.string(),
-    txIn: zod.z.string(),
-    // A JSON blob `{"$ledgerValue":{unit: amountString, ...}}`; V1 reserves are
-    // read from it (V2/stableswap take reserves from the datum).
-    value: zod.z.string()
-  })
+var poolStateSchema = zod.z.object({
+  protocol: zod.z.enum(["minswap-cpmm-v1", "minswap-cpmm-v2", "minswap-stable-cpmm-v1"]),
+  pool_id: zod.z.string(),
+  coin_a: coinSchema,
+  coin_b: coinSchema,
+  tx_in: zod.z.string(),
+  address: zod.z.string(),
+  v1: zod.z.object({ reserve_a: uint, reserve_b: uint, liquidity: uint }).nullish(),
+  v2: zod.z.object({
+    reserve_a: uint,
+    reserve_b: uint,
+    liquidity: uint,
+    fee_a_numerator: uint,
+    fee_b_numerator: uint
+  }).nullish(),
+  stable: zod.z.object({
+    balances: zod.z.array(uint),
+    liquidity: uint,
+    amplification_coefficient: uint
+  }).nullish()
 });
-var poolsSchema = zod.z.array(ammPoolSchema);
-var POOL_FIELDS = `
-  type
-  lpAsset { currencySymbol tokenName }
-  poolAssets { currencySymbol tokenName metadata { decimals } }
-  utxo { address datum txIn value }
-`;
-var BY_LP_ASSETS_QUERY = `query AppliedPoolsByLpAssets($lpAssets: [InputAsset!]!) {
-  appliedPoolsByLPAssets(lpAssets: $lpAssets) {${POOL_FIELDS}}
-}`;
-var BY_PAIRS_QUERY = `query AppliedPoolsByPairs($pairs: [InputPair!]!) {
-  appliedPoolsByPairs(pairs: $pairs) {${POOL_FIELDS}}
-}`;
+var poolStatesSchema = zod.z.array(poolStateSchema).nullish().transform((pools) => pools ?? []);
 async function getAppliedPoolsByLpAssets(client, lpAssets) {
-  const pools = await client.execute({
-    operation: "appliedPoolsByLPAssets",
-    document: BY_LP_ASSETS_QUERY,
-    variables: { lpAssets },
-    schema: poolsSchema
-  });
-  return Promise.all(pools.map(toAppliedPool));
-}
-async function getAppliedPoolsByPairs(client, pairs) {
-  const pools = await client.execute({
-    operation: "appliedPoolsByPairs",
-    document: BY_PAIRS_QUERY,
-    variables: { pairs },
-    schema: poolsSchema
-  });
-  return Promise.all(pools.map(toAppliedPool));
+  const chunks = [];
+  for (let i = 0; i < lpAssets.length; i += MAX_POOL_IDS) {
+    chunks.push(lpAssets.slice(i, i + MAX_POOL_IDS));
+  }
+  const pages = await Promise.all(
+    chunks.map((chunk) => fetchPoolStates(client, { pool_ids: chunk, applied: true }))
+  );
+  return pages.flat();
 }
-function mapVersion(type) {
-  switch (type) {
-    case "DEX":
-      return "V1";
-    case "DEX_V2":
-      return "V2";
-    case "STABLESWAP":
-      return "STABLESWAP";
+async function getAppliedPoolsByPair(client, coinA, coinB) {
+  if (coinA === coinB) {
+    throw new MinswapError(
+      `A pool pair needs two different coins, got ${coinA} twice`,
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      { param: "pool", reason: "assetA and assetB must differ" }
+    );
   }
+  return fetchPoolStates(client, { coin_a: coinA, coin_b: coinB, applied: true });
 }
-function toPoolAsset(asset2) {
-  return { policyId: asset2.currencySymbol, nameHex: asset2.tokenName };
+async function fetchPoolStates(client, query) {
+  const { data } = await client.get({ path: POOL_STATE_PATH, query, schema: poolStatesSchema });
+  return data.map(toAppliedPool);
 }
-function unitOf3(a) {
+function coinIdOf(a) {
   return a.policyId === "" ? "lovelace" : `${a.policyId}.${a.nameHex}`;
 }
-async function toAppliedPool(pool) {
-  const version = mapVersion(pool.type);
-  const [rawA, rawB] = pool.poolAssets;
-  if (!rawA || !rawB) {
-    throw new MinswapError(
-      `Pool ${pool.utxo.txIn} returned ${pool.poolAssets.length} pool assets, expected 2`,
-      "PARSE_ERROR" /* PARSE_ERROR */,
-      {
-        endpoint: "GraphQL appliedPools",
-        issues: [{ path: "poolAssets", message: `expected 2, got ${pool.poolAssets.length}` }]
-      }
-    );
+function toPoolAsset(coinId) {
+  const a = coinIdToInputAsset(coinId);
+  return { policyId: a.currencySymbol, nameHex: a.tokenName };
+}
+function parseError(path, message) {
+  return new MinswapError(`${POOL_STATE_ENDPOINT}: ${message}`, "PARSE_ERROR" /* PARSE_ERROR */, {
+    endpoint: POOL_STATE_ENDPOINT,
+    issues: [{ path, message }]
+  });
+}
+function toAppliedPool(pool) {
+  const filled = [pool.v1, pool.v2, pool.stable].filter((s) => s != null).length;
+  if (filled !== 1) {
+    throw parseError(pool.pool_id, `expected exactly one of v1/v2/stable, got ${filled}`);
   }
-  const fields = await decodeDatumFields(pool.utxo.datum);
-  let assetA;
-  let assetB;
+  let version;
   let state;
-  if (version === "V2") {
-    assetA = decodeAssetNode(fields[1], "V2 pool datum", "assetA");
-    assetB = decodeAssetNode(fields[2], "V2 pool datum", "assetB");
-    state = decodeV2State(fields);
-  } else if (version === "STABLESWAP") {
-    assetA = toPoolAsset(rawA);
-    assetB = toPoolAsset(rawB);
-    state = decodeStableswapState(fields);
+  if (pool.protocol === "minswap-cpmm-v2" && pool.v2) {
+    version = "V2";
+    state = {
+      kind: "V2",
+      reserveA: pool.v2.reserve_a,
+      reserveB: pool.v2.reserve_b,
+      totalLiquidity: pool.v2.liquidity,
+      feeANumerator: pool.v2.fee_a_numerator,
+      feeBNumerator: pool.v2.fee_b_numerator
+    };
+  } else if (pool.protocol === "minswap-cpmm-v1" && pool.v1) {
+    version = "V1";
+    state = {
+      kind: "V1",
+      reserveA: pool.v1.reserve_a,
+      reserveB: pool.v1.reserve_b,
+      totalLiquidity: pool.v1.liquidity
+    };
+  } else if (pool.protocol === "minswap-stable-cpmm-v1" && pool.stable) {
+    version = "STABLESWAP";
+    state = {
+      kind: "STABLESWAP",
+      balances: pool.stable.balances,
+      totalLiquidity: pool.stable.liquidity,
+      amp: pool.stable.amplification_coefficient
+    };
   } else {
-    assetA = decodeAssetNode(fields[0], "V1 pool datum", "assetA");
-    assetB = decodeAssetNode(fields[1], "V1 pool datum", "assetB");
-    state = decodeV1State(fields, pool.utxo.value, assetA, assetB);
+    throw parseError(pool.pool_id, `state block does not match protocol ${pool.protocol}`);
   }
   const decimals = { lovelace: 6 };
-  for (const a of [rawA, rawB]) {
-    const d = a.metadata?.decimals;
-    if (a.currencySymbol !== "" && d != null) {
-      decimals[`${a.currencySymbol}.${a.tokenName}`] = d;
+  for (const coin of [pool.coin_a, pool.coin_b]) {
+    if (coin.coin_type !== "lovelace" && coin.symbol !== "" && coin.decimals != null) {
+      decimals[coinIdOf(toPoolAsset(coin.coin_type))] = coin.decimals;
     }
   }
   return {
     version,
-    lpAsset: toPoolAsset(pool.lpAsset),
-    assetA,
-    assetB,
+    lpAsset: toPoolAsset(pool.pool_id),
+    assetA: toPoolAsset(pool.coin_a.coin_type),
+    assetB: toPoolAsset(pool.coin_b.coin_type),
     state,
-    utxoRef: pool.utxo.txIn,
-    poolAddress: pool.utxo.address,
-    rawDatum: pool.utxo.datum,
+    utxoRef: pool.tx_in,
+    poolAddress: pool.address,
     decimals
   };
 }
-async function decodeDatumFields(datumHex) {
-  const builder = await loadDexBuilder();
-  const decoder = builder.PlutusData;
-  const fields = decoder.fromDataHex(datumHex).fields;
-  if (!fields) {
-    throw parseError("pool datum", "fields", "datum is not a constructor with fields");
-  }
-  return fields;
-}
-function parseError(endpoint, path, message) {
-  return new MinswapError(`${endpoint}: ${message}`, "PARSE_ERROR" /* PARSE_ERROR */, {
-    endpoint,
-    issues: [{ path, message }]
-  });
-}
-function decodeAssetNode(node, endpoint, field) {
-  const f = node?.fields;
-  if (!f || f.length < 2 || f[0]?.bytes === void 0 || f[1]?.bytes === void 0) {
-    throw parseError(endpoint, field, "expected an asset Constr[policyId, assetNameHex]");
-  }
-  return { policyId: f[0].bytes, nameHex: f[1].bytes };
-}
-function readInt(node, endpoint, field) {
-  if (!node || node.int === void 0) {
-    throw parseError(endpoint, field, "expected an integer");
-  }
-  return BigInt(node.int);
-}
-function requireFields(fields, min, endpoint) {
-  if (fields.length < min) {
-    throw parseError(endpoint, "fields", `expected >=${min}, got ${fields.length}`);
-  }
-}
-function decodeV2State(fields) {
-  requireFields(fields, 8, "V2 pool datum");
-  return {
-    kind: "V2",
-    totalLiquidity: readInt(fields[3], "V2 pool datum", "totalLiquidity"),
-    reserveA: readInt(fields[4], "V2 pool datum", "reserveA"),
-    reserveB: readInt(fields[5], "V2 pool datum", "reserveB"),
-    feeANumerator: readInt(fields[6], "V2 pool datum", "feeANumerator"),
-    feeBNumerator: readInt(fields[7], "V2 pool datum", "feeBNumerator")
-  };
-}
-function decodeStableswapState(fields) {
-  requireFields(fields, 3, "Stableswap pool datum");
-  const balancesList = fields[0]?.list;
-  if (!balancesList) {
-    throw parseError("Stableswap pool datum", "balances", "expected a list");
-  }
-  return {
-    kind: "STABLESWAP",
-    balances: balancesList.map((b, i) => readInt(b, "Stableswap pool datum", `balances[${i}]`)),
-    totalLiquidity: readInt(fields[1], "Stableswap pool datum", "totalLiquidity"),
-    amp: readInt(fields[2], "Stableswap pool datum", "amp")
-  };
-}
-var ledgerValueSchema = zod.z.object({ $ledgerValue: zod.z.record(zod.z.string(), zod.z.string()) });
-function decodeV1State(fields, valueJson, assetA, assetB) {
-  requireFields(fields, 3, "V1 pool datum");
-  const totalLiquidity = readInt(fields[2], "V1 pool datum", "totalLiquidity");
-  let parsed;
-  try {
-    parsed = JSON.parse(valueJson);
-  } catch {
-    throw parseError("V1 pool value", "value", "not valid JSON");
-  }
-  const ledger = ledgerValueSchema.safeParse(parsed);
-  if (!ledger.success) {
-    throw parseError("V1 pool value", "$ledgerValue", "missing ledger value map");
-  }
-  const amounts = ledger.data.$ledgerValue;
-  return {
-    kind: "V1",
-    reserveA: BigInt(amounts[unitOf3(assetA)] ?? "0"),
-    reserveB: BigInt(amounts[unitOf3(assetB)] ?? "0"),
-    totalLiquidity
-  };
-}
 
 // src/modules/liquidity-module.ts
 var assetId = (coinId) => {
   const a = coinIdToInputAsset(coinId);
   return { policyId: a.currencySymbol, nameHex: a.tokenName };
 };
-var coinIdOf = (a) => a.policyId === "" ? "lovelace" : `${a.policyId}.${a.nameHex}`;
 var eqAsset = (x, y) => x.policyId === y.policyId && x.nameHex === y.nameHex;
 var LiquidityModule = class {
   constructor(sdk) {
@@ -2941,17 +2765,15 @@ var LiquidityModule = class {
     });
   }
   async resolvePool(ref) {
-    const client = this.sdk.clients.appGraphql;
+    const client = this.sdk.clients.appApi;
     if (typeof ref === "string") {
-      const [pool] = await getAppliedPoolsByLpAssets(client, [coinIdToInputAsset(ref)]);
+      const [pool] = await getAppliedPoolsByLpAssets(client, [ref]);
       if (!pool) {
         throw poolNotFound("LP asset", ref);
       }
       return pool;
     }
-    const pools = await getAppliedPoolsByPairs(client, [
-      { assetA: coinIdToInputAsset(ref.assetA), assetB: coinIdToInputAsset(ref.assetB) }
-    ]);
+    const pools = await getAppliedPoolsByPair(client, ref.assetA, ref.assetB);
     const pairId = `${ref.assetA}/${ref.assetB}`;
     if (pools.length === 0) {
       throw poolNotFound("pair", pairId);
@@ -3156,6 +2978,36 @@ var orderSchema = zod.z.object({
    */
   splits: o.splits
 }));
+var pendingOrderSchema = zod.z.object({
+  tx_in: zod.z.string(),
+  protocol: zod.z.string(),
+  source: zod.z.string().nullish(),
+  coin_in: zod.z.string(),
+  coin_out: zod.z.string(),
+  amount_in: zod.z.string(),
+  min_amount_out: zod.z.string(),
+  dex_fee: zod.z.string(),
+  deposit: zod.z.string(),
+  created_at: zod.z.number()
+}).transform((o) => ({
+  /** The order's UTxO reference, `txHash#index`. */
+  txIn: o.tx_in,
+  /** App API protocol code, e.g. `"minswap-cpmm-v2"`. */
+  protocol: o.protocol,
+  /** Aggregator whose transaction placed the order (`"minswap"`, `"dex-hunter"`, …); `null` when placed on the DEX directly. */
+  source: o.source ?? null,
+  coinIn: o.coin_in,
+  coinOut: o.coin_out,
+  amountIn: o.amount_in,
+  /** `"0"` when the order sets no minimum. */
+  minAmountOut: o.min_amount_out,
+  /** Batcher fee, lovelace. */
+  dexFee: o.dex_fee,
+  /** Deposit returned with the output, lovelace. */
+  deposit: o.deposit,
+  /** Epoch milliseconds. */
+  createdAt: o.created_at
+}));
 var OrderModule = class {
   constructor(sdk) {
     this.sdk = sdk;
@@ -3187,6 +3039,31 @@ var OrderModule = class {
     });
     return cursorPage(data, pagination?.lastCursor);
   }
+  /**
+   * List an address's open swap orders, newest first, across every protocol
+   * and aggregator.
+   *
+   * An order is listed while its UTxO is unspent; each leg of a split or
+   * multi-hop submission is its own entry. Only `SWAP` orders are listed; the
+   * other types (deposit, withdraw, zap, limit, …) are in
+   * {@link OrderModule.getHistory}.
+   *
+   * @param params - `address`, plus `limit` (1..50, default 20) and `cursor` from a previous page
+   * @returns one page of pending orders and the cursor for the next
+   */
+  async getPending(params) {
+    assertLimit(params.limit, 50);
+    const { data, pagination } = await this.sdk.clients.appApi.get({
+      path: "/api/v1/order/pending",
+      query: {
+        address: params.address,
+        cursor: params.cursor,
+        limit: params.limit ?? 20
+      },
+      schema: arrayOf(pendingOrderSchema)
+    });
+    return cursorPage(data, pagination?.lastCursor);
+  }
   /**
    * Collect the UTxO references that can still be cancelled for an order.
    *
@@ -3833,7 +3710,7 @@ var DOC_LIQUID_UNSTAKE = `mutation MinBarBuildLiquidUnstakeTx($options: MinBarBu
   minBarBuildLiquidUnstakeTx(options: $options)
 }`;
 var amountString = zod.z.string();
-var coinSchema = zod.z.object({
+var coinSchema2 = zod.z.object({
   coin_type: zod.z.string().nullish(),
   symbol: zod.z.string(),
   name: zod.z.string(),
@@ -3945,7 +3822,7 @@ var securitySchema = zod.z.object({
 }));
 var tagSchema = zod.z.object({ id: zod.z.number(), name: zod.z.string() });
 var tokenDetailSchema = zod.z.object({
-  coin: coinSchema,
+  coin: coinSchema2,
   price_change: priceSchema,
   volume: volumeSchema.nullish(),
   social_media: socialMediaSchema,
@@ -4333,8 +4210,7 @@ var MinswapSdk = class {
     this.clients = {
       appApi: new AppApiClient(http, this.config),
       aggregatorApi: new AggregatorApiClient(http, this.config),
-      keyAppApi: new KeyAppApiClient(http, this.config),
-      appGraphql: new AppGraphqlClient(http, this.config)
+      keyAppApi: new KeyAppApiClient(http, this.config)
     };
     this.token = new TokenModule(this);
     this.pool = new PoolModule(this);
@@ -4563,7 +4439,6 @@ exports.AGGREGATOR_PROTOCOLS = AGGREGATOR_PROTOCOLS;
 exports.AggregatorApiClient = AggregatorApiClient;
 exports.AggregatorModule = AggregatorModule;
 exports.AppApiClient = AppApiClient;
-exports.AppGraphqlClient = AppGraphqlClient;
 exports.BATCHER_FEE = BATCHER_FEE;
 exports.CANCEL_ADAPTER_PROTOCOL = CANCEL_ADAPTER_PROTOCOL;
 exports.DEFAULT_ENDPOINTS = DEFAULT_ENDPOINTS;
@@ -4606,6 +4481,7 @@ exports.buildUrl = buildUrl;
 exports.coinAmountInfoSchema = coinAmountInfoSchema;
 exports.coinBasicInfoSchema = coinBasicInfoSchema;
 exports.coinCandleSchema = coinCandleSchema;
+exports.coinIdOf = coinIdOf;
 exports.coinIdToAssetUnit = coinIdToAssetUnit;
 exports.coinIdToInputAsset = coinIdToInputAsset;
 exports.collect = collect;
@@ -4615,10 +4491,9 @@ exports.decodeOffsetCursor = decodeOffsetCursor;
 exports.encodeOffsetCursor = encodeOffsetCursor;
 exports.formatTxIn = formatTxIn;
 exports.getAppliedPoolsByLpAssets = getAppliedPoolsByLpAssets;
-exports.getAppliedPoolsByPairs = getAppliedPoolsByPairs;
+exports.getAppliedPoolsByPair = getAppliedPoolsByPair;
 exports.inputAssetToCoinId = inputAssetToCoinId;
 exports.isPureAda = isPureAda;
-exports.loadDexBuilder = loadDexBuilder;
 exports.lovelaceOf = lovelaceOf;
 exports.offsetPage = offsetPage;
 exports.paginate = paginate;
@@ -4632,7 +4507,6 @@ exports.resolveConfig = resolveConfig;
 exports.resolveWalletInputs = resolveWalletInputs;
 exports.selectCollateral = selectCollateral;
 exports.toBigIntString = toBigIntString;
-exports.toDatumHex = toDatumHex;
 exports.toEpochMs = toEpochMs;
 exports.toEpochSeconds = toEpochSeconds;
 exports.toRfc3339 = toRfc3339;