@skip-go/client 1.0.1-alpha-1 → 1.0.1

package/dist/chunk-5KVRQLI5.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
+
+// src/api/postRoute.ts
+var route = (request) => chunkASPVKNJ7_js.__async(void 0, null, function* () {
+  const requestWithAffiliateFeeBps = chunkASPVKNJ7_js.__spreadProps(chunkASPVKNJ7_js.__spreadValues({}, request), {
+    cumulativeAffiliateFeeBps: chunkASPVKNJ7_js.ApiState.cumulativeAffiliateFeeBPS
+  });
+  return chunkASPVKNJ7_js.api({
+    methodName: "getRouteV2",
+    method: "post",
+    path: "/v2/fungible/route"
+  })(requestWithAffiliateFeeBps);
+});
+
+exports.route = route;

package/dist/{chunk-KNV72XRZ.js → chunk-5ZJBR5AQ.js}

@@ -1,10 +1,12 @@
-import { api } from './chunk-W6TBGBV3.js';
+'use strict';
+
+var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
 
 // src/api/getBridges.ts
-var bridges = api({
+var bridges = chunkASPVKNJ7_js.api({
   methodName: "getBridges",
   path: "/v2/info/bridges",
   transformResponse: (response) => response.bridges
 });
 
-export { bridges };
+exports.bridges = bridges;

package/dist/chunk-6BTWKTNM.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunk6GJEXV5J_js = require('./chunk-6GJEXV5J.js');
+var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
+
+// src/api/postAssetsFromSource.ts
+var assetsFromSource = chunkASPVKNJ7_js.api({
+  methodName: "getAssetsFromSource",
+  method: "post",
+  path: "/v2/fungible/assets_from_source",
+  transformResponse(response) {
+    return chunk6GJEXV5J_js.transformAssetsMap(response.destAssets);
+  }
+});
+
+exports.assetsFromSource = assetsFromSource;

package/dist/chunk-6GJEXV5J.js

@@ -0,0 +1,130 @@
+'use strict';
+
+var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
+
+// src/private-functions/getMainnetAndTestnetChains.ts
+var getMainnetAndTestnetChains = (apiOptions) => chunkASPVKNJ7_js.__async(void 0, null, function* () {
+  const [mainnetRes, testnetRes] = yield Promise.all([
+    chains(chunkASPVKNJ7_js.__spreadValues({
+      includeEvm: true,
+      includeSvm: true
+    }, apiOptions)),
+    chains(chunkASPVKNJ7_js.__spreadValues({
+      includeEvm: true,
+      includeSvm: true,
+      onlyTestnets: true
+    }, apiOptions))
+  ]);
+  const combinedChains = [...mainnetRes != null ? mainnetRes : [], ...testnetRes != null ? testnetRes : []];
+  ClientState.skipChains = combinedChains;
+  return combinedChains;
+});
+
+// src/api/getAssets.ts
+var assets = chunkASPVKNJ7_js.api({
+  methodName: "getAssets",
+  path: "/v2/fungible/assets",
+  transformResponse: (response) => {
+    return transformAssetsMap(response.chainToAssetsMap);
+  },
+  onSuccess: (response, options) => {
+    if ((options == null ? void 0 : options.includeEvmAssets) && (options == null ? void 0 : options.includeSvmAssets) && (options == null ? void 0 : options.includeCw20Assets)) {
+      ClientState.skipAssets = response;
+    }
+  }
+});
+var transformAssetsMap = (input) => Object.entries(input != null ? input : {}).reduce(
+  (acc, [chainId, { assets: assets2 }]) => {
+    acc[chainId] = (assets2 != null ? assets2 : []).map((asset) => asset);
+    return acc;
+  },
+  {}
+);
+
+// src/private-functions/getMainnetAndTestnetAssets.ts
+var getMainnetAndTestnetAssets = (_a) => chunkASPVKNJ7_js.__async(void 0, null, function* () {
+  var _b = _a, {
+    chainId
+  } = _b, apiOptions = chunkASPVKNJ7_js.__objRest(_b, [
+    "chainId"
+  ]);
+  const [assetsMainnet, assetsTestnet] = yield Promise.all([
+    assets(chunkASPVKNJ7_js.__spreadValues({
+      chainIds: chainId ? [chainId] : void 0
+    }, apiOptions)),
+    assets(chunkASPVKNJ7_js.__spreadValues({
+      chainIds: chainId ? [chainId] : void 0,
+      onlyTestnets: true
+    }, apiOptions))
+  ]);
+  const mainnet = assetsMainnet;
+  const testnet = assetsTestnet;
+  const merged = chunkASPVKNJ7_js.__spreadValues(chunkASPVKNJ7_js.__spreadValues({}, mainnet), testnet);
+  ClientState.skipAssets = merged;
+  return merged;
+});
+
+// src/api/postBalances.ts
+var balances = chunkASPVKNJ7_js.api({
+  methodName: "getBalances",
+  method: "post",
+  path: "/v2/info/balances",
+  onSuccess: (response, options) => {
+    if (!options) {
+      ClientState.skipBalances = response;
+    }
+  }
+});
+
+// src/state/clientState.ts
+var ClientState = class {
+  static getSkipChains(apiOptions) {
+    return chunkASPVKNJ7_js.__async(this, null, function* () {
+      if (this.skipChains) {
+        return this.skipChains;
+      }
+      const response = yield getMainnetAndTestnetChains(apiOptions);
+      this.skipChains = response;
+      return response;
+    });
+  }
+  static getSkipAssets(props) {
+    return chunkASPVKNJ7_js.__async(this, null, function* () {
+      if (this.skipAssets) {
+        return this.skipAssets;
+      }
+      const response = yield getMainnetAndTestnetAssets(props);
+      this.skipAssets = response;
+      return response;
+    });
+  }
+  static getSkipBalances() {
+    return chunkASPVKNJ7_js.__async(this, null, function* () {
+      if (this.skipBalances) {
+        return this.skipBalances;
+      }
+      const response = yield balances();
+      this.skipBalances = response;
+      return response;
+    });
+  }
+};
+ClientState.signingStargateClientByChainId = {};
+
+// src/api/getChains.ts
+var chains = chunkASPVKNJ7_js.api({
+  methodName: "getChains",
+  path: "/v2/info/chains",
+  transformResponse: (response) => response.chains,
+  onSuccess: (response, options) => {
+    if ((options == null ? void 0 : options.includeEvm) && (options == null ? void 0 : options.includeSvm)) {
+      ClientState.skipChains = response;
+    }
+  }
+});
+
+exports.ClientState = ClientState;
+exports.assets = assets;
+exports.balances = balances;
+exports.chains = chains;
+exports.transformAssetsMap = transformAssetsMap;

package/dist/chunk-ASPVKNJ7.js

@@ -0,0 +1,242 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/state/apiState.ts
+var _ApiState = class _ApiState {
+  static setClientInitialized() {
+    _ApiState.resolveInitialization();
+  }
+};
+_ApiState.cumulativeAffiliateFeeBPS = "0";
+_ApiState.isInitialized = false;
+_ApiState.clientInitialized = new Promise((resolve) => {
+  _ApiState.resolveInitialization = () => {
+    if (!_ApiState.isInitialized) {
+      _ApiState.isInitialized = true;
+      resolve();
+    }
+  };
+});
+var ApiState = _ApiState;
+
+// src/utils/convert.ts
+function toSnake(obj) {
+  return convertKeys(obj, (key) => key.replace(/([A-Z])/g, "_$1").toLowerCase());
+}
+function toCamel(obj) {
+  return convertKeys(obj, (key) => key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()));
+}
+function convertKeys(obj, convertKey) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => convertKeys(item, convertKey));
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.keys(obj).reduce((acc, key) => {
+      acc[convertKey(key)] = convertKeys(obj[key], convertKey);
+      return acc;
+    }, {});
+  } else {
+    return obj;
+  }
+}
+
+// src/utils/timer.ts
+var wait = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+// src/utils/generateApi.ts
+var createRequestClient = ({ baseUrl, apiKey }) => {
+  const defaultHeaders = __spreadValues({
+    "content-type": "application/json"
+  }, apiKey ? { authorization: apiKey } : {});
+  const handleResponse = (response) => __async(void 0, null, function* () {
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType == null ? void 0 : contentType.includes("application/json");
+    const body = isJson ? yield response.json() : yield response.text();
+    if (!response.ok) {
+      const message = typeof body === "object" && (body == null ? void 0 : body.message) ? body.message : response.statusText;
+      throw new Error(message);
+    }
+    return body;
+  });
+  const get = (path, params, signal) => __async(void 0, null, function* () {
+    const url = new URL(baseUrl + (path != null ? path : ""));
+    if (params && typeof params === "object") {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    const response = yield fetch(url.toString(), {
+      method: "GET",
+      headers: defaultHeaders,
+      signal
+    });
+    return handleResponse(response);
+  });
+  const post = (_0, ..._1) => __async(void 0, [_0, ..._1], function* (path, data = {}, signal) {
+    const response = yield fetch(new URL(baseUrl + path).toString(), {
+      method: "POST",
+      headers: defaultHeaders,
+      body: JSON.stringify(data),
+      signal
+    });
+    return handleResponse(response);
+  });
+  return { get, post };
+};
+function createRequest({
+  path,
+  method = "get",
+  onSuccess,
+  transformResponse
+}) {
+  let controller = null;
+  const request = (options) => __async(this, null, function* () {
+    var _b;
+    const _a = options != null ? options : {}, { apiKey, apiUrl, abortDuplicateRequests } = _a, requestParams = __objRest(_a, ["apiKey", "apiUrl", "abortDuplicateRequests"]);
+    let fetchClient = ApiState.client;
+    if (apiUrl || apiKey) {
+      fetchClient = createRequestClient({
+        baseUrl: apiUrl || "https://api.skip.build",
+        apiKey
+      });
+    } else {
+      yield ApiState.clientInitialized;
+    }
+    if (abortDuplicateRequests && controller && !((_b = controller == null ? void 0 : controller.signal) == null ? void 0 : _b.aborted)) {
+      controller == null ? void 0 : controller.abort();
+    }
+    controller = new AbortController();
+    try {
+      const response = yield fetchClient[method](
+        path,
+        requestParams ? toSnake(requestParams) : void 0,
+        controller.signal
+      );
+      const camelCased = toCamel(response != null ? response : {});
+      const finalResponse = transformResponse ? transformResponse(camelCased) : camelCased;
+      onSuccess == null ? void 0 : onSuccess(finalResponse, requestParams);
+      return finalResponse;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        console.log("Request was cancelled");
+      } else {
+        console.error("Error:", error);
+        throw error;
+      }
+    }
+  });
+  return request;
+}
+function api({
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  methodName,
+  path,
+  onSuccess,
+  method = "get",
+  transformResponse
+}) {
+  return createRequest({
+    path,
+    method,
+    onSuccess,
+    transformResponse
+  });
+}
+function pollingApi({
+  methodName,
+  path,
+  method = "get",
+  onSuccess,
+  onError,
+  isSuccess = () => true,
+  maxRetries = 5,
+  retryInterval = 1e3,
+  backoffMultiplier = 2
+}) {
+  const request = (requestParams) => __async(this, null, function* () {
+    let attempt = 0;
+    let lastError;
+    while (attempt < maxRetries) {
+      try {
+        const result = yield api({ methodName, path, method })(requestParams);
+        if (result && isSuccess(result)) {
+          onSuccess == null ? void 0 : onSuccess(result, attempt);
+          return result;
+        }
+      } catch (err) {
+        lastError = err;
+        onError == null ? void 0 : onError(err, attempt);
+      }
+      const delay = retryInterval * Math.pow(backoffMultiplier, attempt);
+      yield wait(delay);
+      attempt++;
+    }
+    throw lastError != null ? lastError : new Error("pollingApi: max retries exceeded");
+  });
+  return (params) => request(params);
+}
+
+exports.ApiState = ApiState;
+exports.__async = __async;
+exports.__objRest = __objRest;
+exports.__spreadProps = __spreadProps;
+exports.__spreadValues = __spreadValues;
+exports.api = api;
+exports.createRequestClient = createRequestClient;
+exports.pollingApi = pollingApi;
+exports.toCamel = toCamel;
+exports.wait = wait;