@olympex-io/olympex-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,817 @@
+// src/errors/base-error.ts
+var OlympexSdkError = class extends Error {
+  code;
+  metadata;
+  constructor(message, code = "OLYMPEX_SDK_ERROR", metadata) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.metadata = metadata;
+  }
+};
+
+// src/errors/graphql-error.ts
+var OlympexGraphQLError = class extends OlympexSdkError {
+  constructor(message, metadata) {
+    super(message, "OLYMPEX_GRAPHQL_ERROR", metadata);
+  }
+};
+
+// src/errors/network-error.ts
+var OlympexNetworkError = class extends OlympexSdkError {
+  constructor(message, metadata) {
+    super(message, "OLYMPEX_NETWORK_ERROR", metadata);
+  }
+};
+
+// src/errors/redact.ts
+var SENSITIVE_KEY_PATTERN = /api[-_]?key|authorization|cookie|token|secret|password/i;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function redact(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => redact(item));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      SENSITIVE_KEY_PATTERN.test(key) ? "<REDACTED>" : redact(entry)
+    ])
+  );
+}
+
+// src/client/request-signing.ts
+import crypto from "crypto";
+function generateBodySignature(body) {
+  const hashBuffer = crypto.createHash("sha256").update(body).digest();
+  return hashBuffer.toString("base64url");
+}
+function getTimestamp() {
+  return Math.floor(Date.now() / 1e3).toString();
+}
+function generateNonce() {
+  return crypto.randomBytes(12).toString("hex");
+}
+function sign({ message, secret }) {
+  return crypto.createHmac("sha256", secret).update(message).digest("hex");
+}
+function buildSignedHeaders({
+  apiKey,
+  apiSecret,
+  passphrase,
+  body,
+  timestamp,
+  nonce
+}) {
+  const bodyHash = generateBodySignature(body);
+  const resolvedTimestamp = timestamp ?? getTimestamp();
+  const resolvedNonce = nonce ?? generateNonce();
+  const message = `${resolvedTimestamp}
+${resolvedNonce}
+${bodyHash}`;
+  const headerData = Buffer.from(message).toString("base64");
+  return {
+    "x-api-key-id": apiKey,
+    "x-value-info": headerData,
+    "x-passphrase": passphrase,
+    "x-signature": sign({ message, secret: apiSecret })
+  };
+}
+
+// src/client/graphql-client.ts
+var OlympexGraphQLClient = class {
+  apiKey;
+  apiSecret;
+  passphrase;
+  endpoint;
+  headers;
+  logger;
+  timeoutMs;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.apiSecret = options.apiSecret;
+    this.passphrase = options.passphrase;
+    this.endpoint = options.endpoint;
+    this.headers = options.headers ?? {};
+    this.logger = options.logger;
+    this.timeoutMs = options.timeoutMs;
+  }
+  async request(document, variables) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      this.logger?.log(
+        "debug",
+        "Sending Olympex GraphQL request",
+        redact({
+          endpoint: this.endpoint,
+          variables
+        })
+      );
+      const bodyToFetch = JSON.stringify({ query: document, variables });
+      const signedHeaders = buildSignedHeaders({
+        apiKey: this.apiKey,
+        apiSecret: this.apiSecret,
+        body: bodyToFetch,
+        passphrase: this.passphrase
+      });
+      const response = await fetch(this.endpoint, {
+        body: bodyToFetch,
+        headers: {
+          accept: "application/json",
+          "content-type": "application/json",
+          ...this.headers,
+          ...signedHeaders
+        },
+        method: "POST",
+        signal: controller.signal
+      });
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        this.logger?.log(
+          "error",
+          "Olympex GraphQL response was not valid JSON",
+          redact({
+            contentType: response.headers.get("content-type") ?? void 0,
+            endpoint: this.endpoint,
+            status: response.status
+          })
+        );
+        throw new OlympexNetworkError("GraphQL response was not valid JSON", {
+          contentType: response.headers.get("content-type") ?? void 0,
+          status: response.status,
+          statusText: response.statusText
+        });
+      }
+      if (!response.ok) {
+        this.logger?.log(
+          "error",
+          "Olympex GraphQL request failed with HTTP status",
+          redact({
+            endpoint: this.endpoint,
+            status: response.status,
+            statusText: response.statusText
+          })
+        );
+        throw new OlympexNetworkError(`GraphQL request failed with status ${response.status}`, {
+          status: response.status,
+          statusText: response.statusText
+        });
+      }
+      if (body?.errors?.length) {
+        const firstError = body.errors[0];
+        this.logger?.log(
+          "warn",
+          "Olympex GraphQL response contains errors",
+          redact({
+            endpoint: this.endpoint,
+            errorCount: body.errors.length,
+            extensions: firstError?.extensions,
+            firstMessage: firstError?.message
+          })
+        );
+        throw new OlympexGraphQLError(body.errors[0]?.message ?? "GraphQL request failed", {
+          errors: body.errors.map((error) => ({
+            extensions: error.extensions,
+            message: error.message,
+            path: error.path
+          }))
+        });
+      }
+      if (!body?.data) {
+        throw new OlympexGraphQLError("GraphQL response did not include data");
+      }
+      return body.data;
+    } catch (error) {
+      if (error instanceof OlympexGraphQLError || error instanceof OlympexNetworkError) {
+        throw error;
+      }
+      const errorName = error instanceof Error ? error.name : "UnknownError";
+      const errorMessage = error instanceof Error ? error.message : "Unknown network error";
+      this.logger?.log(
+        "error",
+        "Olympex GraphQL network failure",
+        redact({
+          endpoint: this.endpoint,
+          errorMessage,
+          errorName
+        })
+      );
+      throw new OlympexNetworkError(errorMessage);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/errors/config-error.ts
+var OlympexConfigError = class extends OlympexSdkError {
+  constructor(message, metadata) {
+    super(message, "OLYMPEX_CONFIG_ERROR", metadata);
+  }
+};
+
+// src/fees/validation.ts
+import { isAddress } from "ethers";
+
+// src/fees/constants.ts
+var FEE_BPS_MIN = 0;
+var FEE_BPS_MAX = 100;
+
+// src/fees/validation.ts
+function validateFeeOptions(fees) {
+  if (!fees) {
+    return;
+  }
+  if (fees.feeBps !== void 0) {
+    if (!Number.isFinite(fees.feeBps) || fees.feeBps < FEE_BPS_MIN || fees.feeBps > FEE_BPS_MAX) {
+      throw new OlympexConfigError(`feeBps must be between ${FEE_BPS_MIN} and ${FEE_BPS_MAX}`);
+    }
+  }
+  if (fees.feeRecipient !== void 0 && !isAddress(fees.feeRecipient)) {
+    throw new OlympexConfigError("feeRecipient must be a valid Ethereum address");
+  }
+}
+
+// src/config/backend-url.ts
+var DEFAULT_BACKEND_URL = "https://back.olympex.io/graphql";
+var BACKEND_URL_ENV = "OLYMPEX_BACKEND_URL";
+var GRAPHQL_PATH = "/graphql";
+function readBackendUrlEnv() {
+  const raw = process.env[BACKEND_URL_ENV];
+  if (raw === void 0) {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function validateBackendUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new OlympexConfigError(`Invalid ${BACKEND_URL_ENV}: ${url}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new OlympexConfigError(`Invalid ${BACKEND_URL_ENV}: ${url}`);
+  }
+  if (parsed.search || parsed.hash) {
+    throw new OlympexConfigError(`Invalid ${BACKEND_URL_ENV}: ${url}`);
+  }
+  const pathname = parsed.pathname.replace(/\/$/, "") || "/";
+  if (pathname !== "/" && pathname !== GRAPHQL_PATH) {
+    throw new OlympexConfigError(`Invalid ${BACKEND_URL_ENV}: ${url}`);
+  }
+  return parsed;
+}
+function normalizeBase(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
+function toGraphqlEndpoint(url) {
+  const parsed = validateBackendUrl(url);
+  const pathname = parsed.pathname.replace(/\/$/, "") || "/";
+  if (pathname === GRAPHQL_PATH) {
+    return `${parsed.origin}${GRAPHQL_PATH}`;
+  }
+  return `${parsed.origin}${GRAPHQL_PATH}`;
+}
+function resolveBackendBaseUrl() {
+  const configured = readBackendUrlEnv();
+  const candidate = configured ?? DEFAULT_BACKEND_URL;
+  return toGraphqlEndpoint(candidate);
+}
+function getGraphqlEndpoint() {
+  return normalizeBase(resolveBackendBaseUrl());
+}
+function getRestBaseUrl() {
+  const graphqlEndpoint = normalizeBase(resolveBackendBaseUrl());
+  if (graphqlEndpoint.endsWith(GRAPHQL_PATH)) {
+    return graphqlEndpoint.slice(0, -GRAPHQL_PATH.length);
+  }
+  return graphqlEndpoint;
+}
+
+// src/methods/account.ts
+var CREATE_ACCOUNT_PATH = "/api/v1/accounts";
+function extractCredentials(payload) {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const directPayload = payload;
+  const candidatePayloads = [directPayload];
+  if (directPayload.data !== void 0) {
+    candidatePayloads.push(directPayload.data);
+  }
+  for (const candidate of candidatePayloads) {
+    if (!candidate || typeof candidate !== "object") {
+      continue;
+    }
+    const values = candidate;
+    if (typeof values.apiKey === "string" && typeof values.secretKey === "string") {
+      return {
+        apiKey: values.apiKey,
+        secretKey: values.secretKey
+      };
+    }
+  }
+  return null;
+}
+function parseResponseMessage(payload) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  const maybeMessage = payload.message;
+  return typeof maybeMessage === "string" ? maybeMessage : void 0;
+}
+async function createAccount({
+  name,
+  password
+}) {
+  const normalizedName = name.trim();
+  const normalizedPassword = password.trim();
+  if (!normalizedName) {
+    throw new OlympexConfigError("name is required");
+  }
+  if (!normalizedPassword) {
+    throw new OlympexConfigError("password is required");
+  }
+  const endpoint = `${getRestBaseUrl()}${CREATE_ACCOUNT_PATH}`;
+  const response = await fetch(endpoint, {
+    body: JSON.stringify({ name: normalizedName, password: normalizedPassword }),
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json"
+    },
+    method: "POST"
+  });
+  let responseBody;
+  try {
+    responseBody = await response.json();
+  } catch {
+    throw new OlympexNetworkError("createAccount response was not valid JSON", {
+      contentType: response.headers.get("content-type") ?? void 0,
+      endpoint,
+      status: response.status,
+      statusText: response.statusText
+    });
+  }
+  if (!response.ok) {
+    throw new OlympexNetworkError(`createAccount request failed with status ${response.status}`, {
+      endpoint,
+      responseMessage: parseResponseMessage(responseBody),
+      status: response.status,
+      statusText: response.statusText
+    });
+  }
+  const credentials = extractCredentials(responseBody);
+  if (!credentials) {
+    throw new OlympexNetworkError("createAccount response did not include credentials", {
+      endpoint,
+      status: response.status
+    });
+  }
+  return credentials;
+}
+
+// src/methods/get-version.ts
+var VERSION = "0.0.0";
+function getVersion() {
+  return VERSION;
+}
+
+// src/errors/domain-error.ts
+var OlympexDomainError = class extends OlympexSdkError {
+  constructor(message, metadata) {
+    super(message, "OLYMPEX_DOMAIN_ERROR", metadata);
+  }
+};
+
+// src/client/domain-response.ts
+function requireSuccessfulDomainResponse(response, payloadName) {
+  if (response === null || response === void 0) {
+    throw new OlympexDomainError(`Missing ${payloadName} response`);
+  }
+  if (response.success === false) {
+    throw new OlympexDomainError(response.message ?? `${payloadName} failed`, {
+      code: response.code,
+      success: response.success
+    });
+  }
+  return response;
+}
+function requirePayload(payload, payloadName) {
+  if (payload === null || payload === void 0) {
+    throw new OlympexDomainError(`Missing ${payloadName} payload`);
+  }
+  return payload;
+}
+
+// src/fees/defaults.ts
+function resolveFeeOptions(callFees, clientDefaultFees) {
+  if (!callFees && !clientDefaultFees) {
+    return void 0;
+  }
+  return {
+    ...clientDefaultFees,
+    ...callFees
+  };
+}
+
+// src/fees/serialize.ts
+function serializeFeeOptions(fees) {
+  if (!fees) {
+    return void 0;
+  }
+  const serialized = {};
+  if (fees.feeBps !== void 0) {
+    serialized.feeBps = fees.feeBps;
+  }
+  if (fees.feeRecipient !== void 0) {
+    serialized.feeRecipient = fees.feeRecipient;
+  }
+  return Object.keys(serialized).length > 0 ? serialized : void 0;
+}
+function mergeParamsWithFees(params, fees) {
+  const serialized = serializeFeeOptions(fees);
+  if (!serialized) {
+    return params;
+  }
+  return {
+    ...params,
+    ...serialized
+  };
+}
+
+// src/graphql/operations.ts
+var GET_ENABLED_CHAINS = (
+  /* GraphQL */
+  `
+  query GetEnabledChains {
+    getEnabledChains {
+      chainIds
+    }
+  }
+`
+);
+var GET_QUOTE = (
+  /* GraphQL */
+  `
+  query GetQuote($getQuoteParams: QuoteInput!) {
+    getQuote(params: $getQuoteParams) {
+      outAmount
+      estimatedGas
+      aggregatorId
+      aggregatorOrder
+      market {
+        dexName
+        swapAmount
+        dexImageURL
+      }
+      routes {
+        percentage
+        subRoutes {
+          from
+          to
+          dexes {
+            name
+            percentage
+          }
+        }
+      }
+      dataFeeTransaction {
+        effectiveGasPrice
+        nativePrice
+        transactionFee
+        transactionFeeInUSD
+        tokenPrice
+        transactionFeeInTokenIn
+        valueToApprove
+      }
+      gasMultiplier
+    }
+  }
+`
+);
+var GET_QUOTE_SWAP = (
+  /* GraphQL */
+  `
+  mutation GetQuoteSwap($getQuoteSwapParams: QuoteSwapInput!) {
+    getQuoteSwap(params: $getQuoteSwapParams) {
+      code
+      message
+      quoteSwap {
+        data
+        estimatedGas
+        minOutAmount
+        outAmount
+        value
+        approveTransaction
+      }
+      success
+    }
+  }
+`
+);
+var GET_CROSS_CHAIN_QUOTE = (
+  /* GraphQL */
+  `
+  query GetCrossChainQuote($params: CrossChainQuoteInput!) {
+    getCrossChainQuote(params: $params) {
+      code
+      message
+      success
+      crossChainQuote {
+        aggregatorId
+        estimatedGas
+        estimatedTime
+        estimateCostInUSD
+        fromTokenAmount
+        toTokenAmount
+        minimumReceived
+        bridgeInfo {
+          icon
+          displayName
+        }
+        middlewareRoute {
+          chainFrom {
+            fromAsset {
+              address
+              decimals
+              symbol
+            }
+            toAsset {
+              address
+              decimals
+              symbol
+            }
+          }
+          chainTo {
+            fromAsset {
+              address
+              decimals
+              symbol
+            }
+            toAsset {
+              address
+              decimals
+              symbol
+            }
+          }
+        }
+      }
+    }
+  }
+`
+);
+var GET_CROSS_CHAIN_SWAP = (
+  /* GraphQL */
+  `
+  mutation GetCrossChainSwap($params: CrossChainSwapInput!) {
+    getCrossChainSwap(params: $params) {
+      code
+      message
+      success
+      crossChainSwap {
+        calldata
+        value
+        approveTransaction
+        dexHash
+      }
+    }
+  }
+`
+);
+var GET_CROSS_CHAIN_TX_STATUS = (
+  /* GraphQL */
+  `
+  query GetCrossChainTxStatus($hash: String!, $chainId: String!, $dexHash: String!) {
+    getCrossChainTxStatus(txHash: $hash, chainId: $chainId, dexHash: $dexHash) {
+      message
+      success
+      txStatus {
+        toChainId
+        fromChainId
+        detailStatus
+        status
+      }
+    }
+  }
+`
+);
+
+// src/methods/quote.ts
+function createQuoteMethod(graphqlClient, defaultFees, logger) {
+  return async function quote(input) {
+    const fees = resolveFeeOptions(input.fees, defaultFees);
+    validateFeeOptions(fees);
+    if (input.mode === "single-chain") {
+      logger?.log(
+        "info",
+        "Olympex quote requested",
+        redact({
+          chainId: input.params.chainId,
+          mode: "single-chain"
+        })
+      );
+      const data2 = await graphqlClient.request(
+        GET_QUOTE,
+        {
+          getQuoteParams: mergeParamsWithFees(input.params, fees)
+        }
+      );
+      return {
+        mode: "single-chain",
+        quote: requirePayload(data2.getQuote, "getQuote")
+      };
+    }
+    logger?.log(
+      "info",
+      "Olympex quote requested",
+      redact({
+        fromChainId: input.params.fromChainId,
+        mode: "cross-chain",
+        toChainId: input.params.toChainId
+      })
+    );
+    const data = await graphqlClient.request(
+      GET_CROSS_CHAIN_QUOTE,
+      {
+        params: mergeParamsWithFees(input.params, fees)
+      }
+    );
+    const response = requireSuccessfulDomainResponse(data.getCrossChainQuote, "getCrossChainQuote");
+    return {
+      mode: "cross-chain",
+      quote: requirePayload(response.crossChainQuote, "crossChainQuote")
+    };
+  };
+}
+
+// src/methods/support-chain.ts
+function createSupportChainMethod(graphqlClient) {
+  return async function supportChain(chainId) {
+    const data = await graphqlClient.request(
+      GET_ENABLED_CHAINS,
+      {}
+    );
+    const enabledChains = requirePayload(data.getEnabledChains, "getEnabledChains");
+    return enabledChains.chainIds.includes(String(chainId));
+  };
+}
+
+// src/methods/swap.ts
+function createSwapMethod(graphqlClient, defaultFees, logger) {
+  return async function swap(input) {
+    const fees = resolveFeeOptions(input.fees, defaultFees);
+    validateFeeOptions(fees);
+    if (input.mode === "single-chain") {
+      logger?.log(
+        "info",
+        "Olympex swap requested",
+        redact({
+          chainId: input.params.chainId,
+          mode: "single-chain"
+        })
+      );
+      const data2 = await graphqlClient.request(
+        GET_QUOTE_SWAP,
+        {
+          getQuoteSwapParams: mergeParamsWithFees(input.params, fees)
+        }
+      );
+      const response2 = requireSuccessfulDomainResponse(data2.getQuoteSwap, "getQuoteSwap");
+      return {
+        mode: "single-chain",
+        swap: requirePayload(response2.quoteSwap, "quoteSwap")
+      };
+    }
+    logger?.log(
+      "info",
+      "Olympex swap requested",
+      redact({
+        fromChainId: input.params.fromChainId,
+        mode: "cross-chain",
+        toChainId: input.params.toChainId
+      })
+    );
+    const data = await graphqlClient.request(
+      GET_CROSS_CHAIN_SWAP,
+      {
+        params: mergeParamsWithFees(input.params, fees)
+      }
+    );
+    const response = requireSuccessfulDomainResponse(data.getCrossChainSwap, "getCrossChainSwap");
+    return {
+      mode: "cross-chain",
+      swap: requirePayload(response.crossChainSwap, "crossChainSwap")
+    };
+  };
+}
+
+// src/methods/tx-status.ts
+function createTxStatusMethod(graphqlClient) {
+  return async function txStatus(input) {
+    const data = await graphqlClient.request(
+      GET_CROSS_CHAIN_TX_STATUS,
+      input
+    );
+    const response = requireSuccessfulDomainResponse(
+      data.getCrossChainTxStatus,
+      "getCrossChainTxStatus"
+    );
+    return requirePayload(response.txStatus, "txStatus");
+  };
+}
+
+// src/config/initialize.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+function initialize(options) {
+  const apiKey = options.apiKey.trim();
+  const apiSecret = options.apiSecret.trim();
+  const passphrase = options.passphrase.trim();
+  if (!apiKey) {
+    throw new OlympexConfigError("apiKey is required");
+  }
+  if (!apiSecret) {
+    throw new OlympexConfigError("apiSecret is required");
+  }
+  if (!passphrase) {
+    throw new OlympexConfigError("passphrase is required");
+  }
+  validateFeeOptions(options.defaultFees);
+  const graphqlClient = new OlympexGraphQLClient({
+    apiKey,
+    apiSecret,
+    endpoint: getGraphqlEndpoint(),
+    headers: options.headers,
+    logger: options.logger,
+    passphrase,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  });
+  return {
+    apiKey,
+    createAccount,
+    getVersion,
+    quote: createQuoteMethod(graphqlClient, options.defaultFees, options.logger),
+    supportChain: createSupportChainMethod(graphqlClient),
+    swap: createSwapMethod(graphqlClient, options.defaultFees, options.logger),
+    txStatus: createTxStatusMethod(graphqlClient)
+  };
+}
+
+// src/logging/console-logger.ts
+var LEVEL_RANK = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function createConsoleLogger(options = {}) {
+  const minRank = LEVEL_RANK[options.minLevel ?? "info"];
+  const target = (level) => {
+    const method = globalThis.console[level];
+    return typeof method === "function" ? method.bind(globalThis.console) : globalThis.console.log.bind(globalThis.console);
+  };
+  return Object.freeze({
+    log(level, message, metadata) {
+      if (LEVEL_RANK[level] < minRank) {
+        return;
+      }
+      try {
+        const write = target(level);
+        if (metadata === void 0) {
+          write(message);
+        } else {
+          write(message, metadata);
+        }
+      } catch {
+      }
+    }
+  });
+}
+
+// src/errors/not-implemented-error.ts
+var OlympexNotImplementedError = class extends OlympexSdkError {
+  constructor(message, metadata) {
+    super(message, "OLYMPEX_NOT_IMPLEMENTED", metadata);
+  }
+};
+export {
+  OlympexConfigError,
+  OlympexDomainError,
+  OlympexGraphQLError,
+  OlympexNetworkError,
+  OlympexNotImplementedError,
+  OlympexSdkError,
+  createAccount,
+  createConsoleLogger,
+  getVersion,
+  initialize
+};
+//# sourceMappingURL=index.mjs.map