@p2pdotme/sdk 1.0.5 → 1.1.1

package/dist/order-routing.mjs

@@ -1,860 +0,0 @@
-// src/order-routing/client.ts
-import { stringToHex as stringToHex3 } from "viem";
-
-// src/contracts/abis/index.ts
-import { erc20Abi } from "viem";
-
-// src/contracts/abis/order-flow-facet.ts
-var orderFlowFacetAbi = [
-  {
-    inputs: [
-      { internalType: "uint256", name: "circleId", type: "uint256" },
-      { internalType: "uint256", name: "assignUpto", type: "uint256" },
-      { internalType: "bytes32", name: "currency", type: "bytes32" },
-      { internalType: "address", name: "user", type: "address" },
-      { internalType: "uint256", name: "usdtAmount", type: "uint256" },
-      { internalType: "uint256", name: "fiatAmount", type: "uint256" },
-      { internalType: "int256", name: "orderType", type: "int256" },
-      { internalType: "uint256", name: "preferredPCConfigId", type: "uint256" }
-    ],
-    name: "getAssignableMerchantsFromCircle",
-    outputs: [{ internalType: "address[]", name: "", type: "address[]" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "_user", type: "address" },
-      { internalType: "bytes32", name: "_nativeCurrency", type: "bytes32" }
-    ],
-    name: "userTxLimit",
-    outputs: [
-      { internalType: "uint256", name: "", type: "uint256" },
-      { internalType: "uint256", name: "", type: "uint256" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-
-// src/contracts/abis/p2p-config-facet.ts
-var p2pConfigFacetAbi = [
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "_currency",
-        type: "bytes32"
-      }
-    ],
-    name: "getPriceConfig",
-    outputs: [
-      {
-        components: [
-          {
-            internalType: "uint256",
-            name: "buyPrice",
-            type: "uint256"
-          },
-          {
-            internalType: "uint256",
-            name: "sellPrice",
-            type: "uint256"
-          },
-          {
-            internalType: "int256",
-            name: "buyPriceOffset",
-            type: "int256"
-          },
-          {
-            internalType: "uint256",
-            name: "baseSpread",
-            type: "uint256"
-          }
-        ],
-        internalType: "struct P2pConfigStorage.PriceConfig",
-        name: "",
-        type: "tuple"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "_nativeCurrency",
-        type: "bytes32"
-      }
-    ],
-    name: "getRpPerUsdtLimitRational",
-    outputs: [
-      {
-        internalType: "uint256",
-        name: "numerator",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "denominator",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-
-// src/contracts/abis/reputation-manager.ts
-var reputationManagerAbi = [
-  {
-    inputs: [
-      {
-        internalType: "string",
-        name: "_socialName",
-        type: "string"
-      },
-      {
-        components: [
-          {
-            components: [
-              {
-                internalType: "string",
-                name: "provider",
-                type: "string"
-              },
-              {
-                internalType: "string",
-                name: "parameters",
-                type: "string"
-              },
-              {
-                internalType: "string",
-                name: "context",
-                type: "string"
-              }
-            ],
-            internalType: "struct IReclaimSDK.ClaimInfo",
-            name: "claimInfo",
-            type: "tuple"
-          },
-          {
-            components: [
-              {
-                components: [
-                  {
-                    internalType: "bytes32",
-                    name: "identifier",
-                    type: "bytes32"
-                  },
-                  {
-                    internalType: "address",
-                    name: "owner",
-                    type: "address"
-                  },
-                  {
-                    internalType: "uint32",
-                    name: "timestampS",
-                    type: "uint32"
-                  },
-                  {
-                    internalType: "uint32",
-                    name: "epoch",
-                    type: "uint32"
-                  }
-                ],
-                internalType: "struct IReclaimSDK.CompleteClaimData",
-                name: "claim",
-                type: "tuple"
-              },
-              {
-                internalType: "bytes[]",
-                name: "signatures",
-                type: "bytes[]"
-              }
-            ],
-            internalType: "struct IReclaimSDK.SignedClaim",
-            name: "signedClaim",
-            type: "tuple"
-          }
-        ],
-        internalType: "struct IReclaimSDK.Proof[]",
-        name: "proofs",
-        type: "tuple[]"
-      }
-    ],
-    name: "socialVerify",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "uint256",
-        name: "nullifierSeed",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "nullifier",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "timestamp",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "signal",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256[4]",
-        name: "revealArray",
-        type: "uint256[4]"
-      },
-      {
-        internalType: "uint256[8]",
-        name: "groth16Proof",
-        type: "uint256[8]"
-      }
-    ],
-    name: "submitAnonAadharProof",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        components: [
-          {
-            internalType: "bytes32",
-            name: "version",
-            type: "bytes32"
-          },
-          {
-            components: [
-              {
-                internalType: "bytes32",
-                name: "vkeyHash",
-                type: "bytes32"
-              },
-              {
-                internalType: "bytes",
-                name: "proof",
-                type: "bytes"
-              },
-              {
-                internalType: "bytes32[]",
-                name: "publicInputs",
-                type: "bytes32[]"
-              }
-            ],
-            internalType: "struct ProofVerificationData",
-            name: "proofVerificationData",
-            type: "tuple"
-          },
-          {
-            internalType: "bytes",
-            name: "committedInputs",
-            type: "bytes"
-          },
-          {
-            components: [
-              {
-                internalType: "uint256",
-                name: "validityPeriodInSeconds",
-                type: "uint256"
-              },
-              {
-                internalType: "string",
-                name: "domain",
-                type: "string"
-              },
-              {
-                internalType: "string",
-                name: "scope",
-                type: "string"
-              },
-              {
-                internalType: "bool",
-                name: "devMode",
-                type: "bool"
-              }
-            ],
-            internalType: "struct ServiceConfig",
-            name: "serviceConfig",
-            type: "tuple"
-          }
-        ],
-        internalType: "struct ProofVerificationParams",
-        name: "params",
-        type: "tuple"
-      },
-      {
-        internalType: "bool",
-        name: "isIDCard",
-        type: "bool"
-      }
-    ],
-    name: "zkPassportRegister",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  }
-];
-
-// src/contracts/abis/index.ts
-var DIAMOND_ABI = [...orderFlowFacetAbi, ...p2pConfigFacetAbi];
-var ABIS = {
-  DIAMOND: DIAMOND_ABI,
-  FACETS: {
-    ORDER_FLOW: orderFlowFacetAbi,
-    CONFIG: p2pConfigFacetAbi
-  },
-  EXTERNAL: {
-    USDC: erc20Abi,
-    REPUTATION_MANAGER: reputationManagerAbi
-  }
-};
-
-// src/contracts/order-flow/index.ts
-import { ResultAsync } from "neverthrow";
-
-// src/lib/logger.ts
-var noop = () => {
-};
-var noopLogger = {
-  debug: noop,
-  info: noop,
-  warn: noop,
-  error: noop
-};
-
-// src/lib/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/validation/errors.validation.ts
-var SdkError = class extends Error {
-  code;
-  cause;
-  context;
-  constructor(message, options) {
-    super(message);
-    this.name = "SdkError";
-    this.code = options.code;
-    this.cause = options.cause;
-    this.context = options.context;
-  }
-};
-
-// src/validation/schemas.validation.ts
-import { err, ok } from "neverthrow";
-import { isAddress } from "viem";
-import { z } from "zod";
-
-// src/constants/currencies.constant.ts
-var CURRENCY = {
-  IDR: "IDR",
-  INR: "INR",
-  BRL: "BRL",
-  ARS: "ARS",
-  MEX: "MEX",
-  VEN: "VEN",
-  EUR: "EUR",
-  NGN: "NGN",
-  USD: "USD",
-  COP: "COP"
-};
-
-// src/validation/schemas.validation.ts
-var ZodAddressSchema = z.string().refine((s) => isAddress(s), { message: "Invalid Ethereum address" });
-var ZodCurrencySchema = z.enum(Object.values(CURRENCY));
-function validate(schema, data, toError) {
-  const result = schema.safeParse(data);
-  if (result.success) {
-    return ok(result.data);
-  }
-  return err(toError(z.prettifyError(result.error), result.error, data));
-}
-
-// src/order-routing/errors.ts
-var OrderRoutingError = class extends SdkError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "OrderRoutingError";
-  }
-};
-
-// src/order-routing/validation.ts
-import { z as z2 } from "zod";
-var ZodCircleScoreStateSchema = z2.object({
-  activeMerchantsCount: z2.coerce.number()
-});
-var ZodCircleMetricsForRoutingSchema = z2.object({
-  circleScore: z2.coerce.number(),
-  circleStatus: z2.string(),
-  scoreState: ZodCircleScoreStateSchema
-});
-var ZodCircleForRoutingSchema = z2.object({
-  circleId: z2.string(),
-  currency: z2.string(),
-  metrics: ZodCircleMetricsForRoutingSchema
-});
-var ZodCirclesForRoutingResponseSchema = z2.object({
-  circles: z2.array(ZodCircleForRoutingSchema)
-});
-var ZodCheckCircleEligibilityParamsSchema = z2.object({
-  circleId: z2.bigint(),
-  currency: z2.string(),
-  user: ZodAddressSchema,
-  usdtAmount: z2.bigint(),
-  fiatAmount: z2.bigint(),
-  orderType: z2.bigint(),
-  preferredPCConfigId: z2.bigint()
-});
-var ZodSelectCircleParamsSchema = z2.object({
-  currency: z2.string().min(1),
-  user: ZodAddressSchema,
-  usdtAmount: z2.bigint(),
-  fiatAmount: z2.bigint(),
-  orderType: z2.bigint(),
-  preferredPCConfigId: z2.bigint()
-});
-
-// src/contracts/order-flow/index.ts
-function checkCircleEligibility(publicClient, contractAddress, params, logger = noopLogger) {
-  return validate(
-    ZodCheckCircleEligibilityParamsSchema,
-    params,
-    (message, cause, d) => new OrderRoutingError(message, { code: "VALIDATION_ERROR", cause, context: { data: d } })
-  ).asyncAndThen((validated) => {
-    logger.debug("checking on-chain eligibility", {
-      circleId: String(validated.circleId),
-      contractAddress
-    });
-    return ResultAsync.fromPromise(
-      publicClient.readContract({
-        address: contractAddress,
-        abi: ABIS.FACETS.ORDER_FLOW,
-        functionName: "getAssignableMerchantsFromCircle",
-        args: [
-          validated.circleId,
-          1n,
-          validated.currency,
-          validated.user,
-          validated.usdtAmount,
-          validated.fiatAmount,
-          validated.orderType,
-          validated.preferredPCConfigId
-        ]
-      }),
-      (error) => new OrderRoutingError("Eligibility check failed", {
-        code: "CONTRACT_READ_ERROR",
-        cause: error,
-        context: { circleId: String(params.circleId) }
-      })
-    );
-  }).map((merchants) => {
-    const arr = merchants;
-    const eligible = arr.length >= 1;
-    logger.debug("eligibility check result", {
-      circleId: String(params.circleId),
-      assignableMerchants: arr.length,
-      eligible
-    });
-    return eligible;
-  });
-}
-
-// src/contracts/p2p-config/index.ts
-import { ResultAsync as ResultAsync2 } from "neverthrow";
-import { stringToHex } from "viem";
-
-// src/profile/validation.ts
-import { z as z3 } from "zod";
-var ZodUsdcBalanceParamsSchema = z3.object({
-  address: ZodAddressSchema
-});
-var ZodGetBalancesParamsSchema = z3.object({
-  address: ZodAddressSchema,
-  currency: ZodCurrencySchema
-});
-var ZodTxLimitsParamsSchema = z3.object({
-  address: ZodAddressSchema,
-  currency: ZodCurrencySchema
-});
-var ZodPriceConfigParamsSchema = z3.object({
-  currency: ZodCurrencySchema
-});
-
-// src/contracts/reputation-manager/writes.ts
-import { Result } from "neverthrow";
-import { encodeFunctionData } from "viem";
-
-// src/zkkyc/validation.ts
-import { z as z4 } from "zod";
-var ZodAnonAadharProofParamsSchema = z4.object({
-  nullifierSeed: z4.bigint(),
-  nullifier: z4.bigint(),
-  timestamp: z4.bigint(),
-  signal: z4.bigint(),
-  revealArray: z4.tuple([z4.bigint(), z4.bigint(), z4.bigint(), z4.bigint()]),
-  packedGroth16Proof: z4.tuple([
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint()
-  ])
-});
-var ZodSocialVerifyParamsSchema = z4.object({
-  _socialName: z4.string(),
-  proofs: z4.array(
-    z4.object({
-      claimInfo: z4.object({
-        provider: z4.string(),
-        parameters: z4.string(),
-        context: z4.string()
-      }),
-      signedClaim: z4.object({
-        claim: z4.object({
-          identifier: z4.string(),
-          owner: ZodAddressSchema,
-          timestampS: z4.number(),
-          epoch: z4.number()
-        }),
-        signatures: z4.array(z4.string())
-      })
-    })
-  )
-});
-var ZodSolidityVerifierParametersSchema = z4.object({
-  version: z4.string().refine((val) => val.startsWith("0x"), {
-    message: "Version must be a hex string"
-  }),
-  proofVerificationData: z4.object({
-    vkeyHash: z4.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
-      message: "Invalid bytes32 hex string"
-    }),
-    proof: z4.string().refine((val) => val.startsWith("0x"), {
-      message: "Proof must be a hex string"
-    }),
-    publicInputs: z4.array(
-      z4.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
-        message: "Each public input must be a valid bytes32 hex string"
-      })
-    )
-  }),
-  committedInputs: z4.string().refine((val) => val.startsWith("0x"), {
-    message: "Committed inputs must be a hex string"
-  }),
-  serviceConfig: z4.object({
-    validityPeriodInSeconds: z4.number().int().nonnegative(),
-    domain: z4.string(),
-    scope: z4.string(),
-    devMode: z4.boolean()
-  })
-});
-var ZodZkPassportRegisterParamsSchema = z4.object({
-  params: ZodSolidityVerifierParametersSchema,
-  isIDCard: z4.boolean()
-});
-
-// src/contracts/tx-limits/index.ts
-import { ResultAsync as ResultAsync3 } from "neverthrow";
-import { formatUnits, stringToHex as stringToHex2 } from "viem";
-
-// src/contracts/usdc/index.ts
-import { ResultAsync as ResultAsync4 } from "neverthrow";
-
-// src/order-routing/routing.ts
-import { errAsync, okAsync } from "neverthrow";
-var EPSILON = 0.25;
-var RECOVERY_SCALE = 0.3;
-var BOOTSTRAP_MAX_WEIGHT = 25;
-var MAX_VALIDATION_ATTEMPTS = 3;
-function circleWeight(c) {
-  const score = c.metrics.circleScore;
-  if (c.metrics.circleStatus === "paused") {
-    return score * RECOVERY_SCALE;
-  }
-  if (c.metrics.circleStatus === "bootstrap") {
-    return Math.min(score, BOOTSTRAP_MAX_WEIGHT);
-  }
-  return score;
-}
-function filterEligibleCircles(circles, orderCurrency) {
-  return circles.filter((c) => c.currency.toLowerCase() === orderCurrency.toLowerCase());
-}
-function weightedRandomChoice(arr, weights) {
-  const totalWeight = weights.reduce((sum, w) => sum + w, 0);
-  if (totalWeight === 0) {
-    return arr[Math.floor(Math.random() * arr.length)];
-  }
-  let rand = Math.random() * totalWeight;
-  for (let i = 0; i < arr.length; i++) {
-    rand -= weights[i];
-    if (rand <= 0) {
-      return arr[i];
-    }
-  }
-  return arr[arr.length - 1];
-}
-function selectCircle(eligible) {
-  if (eligible.length === 0) {
-    return null;
-  }
-  const activeCircles = eligible.filter((c) => c.metrics.circleStatus === "active");
-  const isExplore = Math.random() < EPSILON;
-  if (isExplore) {
-    const weights2 = eligible.map(circleWeight);
-    return weightedRandomChoice(eligible, weights2);
-  }
-  if (activeCircles.length === 0) {
-    const weights2 = eligible.map(circleWeight);
-    return weightedRandomChoice(eligible, weights2);
-  }
-  const weights = activeCircles.map((c) => c.metrics.circleScore);
-  return weightedRandomChoice(activeCircles, weights);
-}
-function selectCircleForOrderAsync(circles, orderCurrency, validateCircle, logger = noopLogger) {
-  const eligible = filterEligibleCircles(circles, orderCurrency);
-  let remaining = [...eligible];
-  logger.debug("filtering eligible circles", {
-    total: circles.length,
-    eligible: eligible.length,
-    currency: orderCurrency,
-    circles: eligible
-  });
-  if (eligible.length === 0) {
-    logger.warn("no eligible circles found for currency", { currency: orderCurrency });
-  }
-  function attempt(attemptsLeft) {
-    if (attemptsLeft <= 0 || remaining.length === 0) {
-      logger.warn("exhausted all attempts or circles", {
-        attemptsLeft,
-        remainingCircles: remaining.length
-      });
-      return errAsync(
-        new OrderRoutingError("No eligible circles found", {
-          code: "NO_ELIGIBLE_CIRCLES"
-        })
-      );
-    }
-    const selected = selectCircle(remaining);
-    if (!selected) {
-      return errAsync(
-        new OrderRoutingError("No eligible circles found", {
-          code: "NO_ELIGIBLE_CIRCLES"
-        })
-      );
-    }
-    const circleId = BigInt(selected.circleId);
-    logger.debug("selected circle, validating on-chain", {
-      circleId: String(circleId),
-      status: selected.metrics.circleStatus,
-      score: selected.metrics.circleScore,
-      attemptsLeft
-    });
-    return validateCircle(circleId).orElse((error) => {
-      logger.warn("validation errored, treating as ineligible", {
-        circleId: String(circleId),
-        error: String(error)
-      });
-      return okAsync(false);
-    }).andThen((isValid) => {
-      if (isValid) {
-        logger.info("circle validated successfully", { circleId: String(circleId) });
-        return okAsync(circleId);
-      }
-      logger.debug("circle failed validation, retrying", {
-        circleId: String(circleId),
-        remainingCircles: remaining.length - 1
-      });
-      remaining = remaining.filter((c) => c.circleId !== selected.circleId);
-      return attempt(attemptsLeft - 1);
-    });
-  }
-  return attempt(MAX_VALIDATION_ATTEMPTS);
-}
-
-// src/order-routing/subgraph/client.ts
-import { ResultAsync as ResultAsync5 } from "neverthrow";
-var DEFAULT_TIMEOUT_MS = 1e4;
-var MAX_RETRIES = 3;
-var BACKOFF_MS = 500;
-function isTransient(error) {
-  if (error instanceof OrderRoutingError) return false;
-  if (error instanceof DOMException && error.name === "AbortError") return true;
-  if (error instanceof TypeError) return true;
-  return false;
-}
-function querySubgraph(url, params) {
-  const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const fetchOnce = async () => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          query: params.query,
-          variables: params.variables
-        }),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        throw new OrderRoutingError(`Subgraph request failed (status: ${response.status})`, {
-          code: "SUBGRAPH_ERROR",
-          cause: response,
-          context: { status: response.status }
-        });
-      }
-      const json = await response.json();
-      if (json.errors?.length > 0) {
-        throw new OrderRoutingError("Subgraph returned GraphQL errors", {
-          code: "SUBGRAPH_ERROR",
-          cause: json.errors,
-          context: { errors: json.errors }
-        });
-      }
-      if (!json.data) {
-        throw new OrderRoutingError("Subgraph returned no data", {
-          code: "SUBGRAPH_ERROR",
-          cause: "Missing data field in GraphQL response",
-          context: { response: json }
-        });
-      }
-      return json.data;
-    } finally {
-      clearTimeout(timer);
-    }
-  };
-  const fetchWithRetry = async () => {
-    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-      try {
-        return await fetchOnce();
-      } catch (error) {
-        const lastAttempt = attempt === MAX_RETRIES;
-        if (lastAttempt || !isTransient(error)) throw error;
-        await sleep(BACKOFF_MS * (attempt + 1));
-      }
-    }
-    throw new OrderRoutingError("Subgraph query exhausted retries", {
-      code: "SUBGRAPH_ERROR"
-    });
-  };
-  return ResultAsync5.fromPromise(
-    fetchWithRetry(),
-    (error) => error instanceof OrderRoutingError ? error : new OrderRoutingError("Subgraph query failed", {
-      code: "SUBGRAPH_ERROR",
-      cause: error
-    })
-  );
-}
-
-// src/order-routing/subgraph/queries.ts
-var CIRCLES_FOR_ROUTING_QUERY = (
-  /* GraphQL */
-  `
-  query CirclesForRouting($currency: Bytes!) {
-    circles(
-      first: 1000
-      where: {
-        currency: $currency
-        metrics_: {
-          circleStatus_in: ["active", "bootstrap", "paused"]
-        }
-      }
-    ) {
-      circleId
-      currency
-      metrics {
-        circleScore
-        circleStatus
-        scoreState {
-          activeMerchantsCount
-        }
-      }
-    }
-  }
-`
-);
-
-// src/order-routing/subgraph/index.ts
-function getCirclesForRouting(subgraphUrl, currency, logger = noopLogger) {
-  logger.debug("fetching circles from subgraph", { subgraphUrl, currency });
-  return querySubgraph(subgraphUrl, {
-    query: CIRCLES_FOR_ROUTING_QUERY,
-    variables: { currency }
-  }).andThen(
-    (data) => validate(
-      ZodCirclesForRoutingResponseSchema,
-      data,
-      (message, cause, d) => new OrderRoutingError(message, { code: "VALIDATION_ERROR", cause, context: { data: d } })
-    ).map((validated) => {
-      const circles = validated.circles.filter(
-        (item) => Number(item.metrics.scoreState.activeMerchantsCount) > 0
-      );
-      logger.info("fetched circles from subgraph", {
-        total: validated.circles.length,
-        withActiveMerchants: circles.length,
-        circles
-      });
-      return circles;
-    })
-  );
-}
-
-// src/order-routing/client.ts
-function createOrderRouter(config) {
-  const { subgraphUrl, publicClient, contractAddress } = config;
-  const logger = config.logger ?? noopLogger;
-  return {
-    selectCircle(params) {
-      const currencyHex = stringToHex3(params.currency, { size: 32 });
-      logger.info("selectCircle started", {
-        currency: params.currency,
-        user: params.user,
-        orderType: String(params.orderType)
-      });
-      return getCirclesForRouting(subgraphUrl, currencyHex, logger).andThen(
-        (circles) => selectCircleForOrderAsync(
-          circles,
-          currencyHex,
-          (circleId) => checkCircleEligibility(
-            publicClient,
-            contractAddress,
-            {
-              circleId,
-              currency: currencyHex,
-              user: params.user,
-              usdtAmount: params.usdtAmount,
-              fiatAmount: params.fiatAmount,
-              orderType: params.orderType,
-              preferredPCConfigId: params.preferredPCConfigId
-            },
-            logger
-          ),
-          logger
-        )
-      );
-    }
-  };
-}
-export {
-  OrderRoutingError,
-  createOrderRouter
-};
-//# sourceMappingURL=order-routing.mjs.map