hermes-swap 0.0.10 → 0.0.11

package/dist/cjs/index.d.ts

@@ -0,0 +1,9 @@
+import { IExpectParams, ISwapParams, IBridgeParams, ISwapAndBridgeParams, IReceipt } from './types';
+declare class Hermes {
+    constructor();
+    expect(params: IExpectParams): Promise<bigint>;
+    swap(params: ISwapParams): Promise<IReceipt>;
+    bridge(params: IBridgeParams): Promise<IReceipt>;
+    swapAndBridge(params: ISwapAndBridgeParams): Promise<IReceipt>;
+}
+export default Hermes;

package/dist/cjs/index.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var Hermes = class {
+  constructor() {
+  }
+  expect(params) {
+    return Promise.resolve(BigInt(0));
+  }
+  swap(params) {
+    const receipt = {
+      fromToken: params.fromToken,
+      toToken: params.toToken,
+      amount: params.amount
+    };
+    return Promise.resolve(receipt);
+  }
+  bridge(params) {
+    const receipt = {
+      fromToken: params.fromToken,
+      toToken: params.toToken,
+      amount: params.amount
+    };
+    return Promise.resolve(receipt);
+  }
+  swapAndBridge(params) {
+    const receipt = {};
+    return Promise.resolve(receipt);
+  }
+};
+var src_default = Hermes;

package/dist/cjs/types.d.ts

@@ -0,0 +1,24 @@
+export interface IExpectParams {
+    fromToken: string;
+    toToken: string;
+    amount: bigint;
+}
+export interface ISwapParams {
+    fromToken: string;
+    toToken: string;
+    amount: bigint;
+}
+export interface IBridgeParams {
+    fromToken: string;
+    toToken: string;
+    amount: bigint;
+}
+export interface ISwapAndBridgeParams {
+    swapParams: ISwapParams;
+    bridgeParams: IBridgeParams;
+}
+export interface IReceipt {
+    fromToken?: string;
+    toToken?: string;
+    amount?: bigint;
+}

package/dist/cjs/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/esm/index.js

@@ -1 +1,45 @@
-function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}function _classCallCheck(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function _defineProperties(a,b){for(var c,d=0;d<b.length;d++)c=b[d],c.enumerable=c.enumerable||!1,c.configurable=!0,"value"in c&&(c.writable=!0),Object.defineProperty(a,_toPropertyKey(c.key),c)}function _createClass(a,b,c){return b&&_defineProperties(a.prototype,b),c&&_defineProperties(a,c),Object.defineProperty(a,"prototype",{writable:!1}),a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}var Hermes=/*#__PURE__*/function(){function a(){_classCallCheck(this,a)}return _createClass(a,[{key:"expect",value:function expect(){return Promise.resolve(BigInt(0))}},{key:"swap",value:function swap(a){var b={fromToken:a.fromToken,toToken:a.toToken,amount:a.amount};return Promise.resolve(b)}},{key:"bridge",value:function bridge(a){var b={fromToken:a.fromToken,toToken:a.toToken,amount:a.amount};return Promise.resolve(b)}},{key:"swapAndBridge",value:function swapAndBridge(){return Promise.resolve({})}}]),a}();export default Hermes;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var Hermes = /*#__PURE__*/function () {
+  function Hermes() {
+    _classCallCheck(this, Hermes);
+  }
+  _createClass(Hermes, [{
+    key: "expect",
+    value: function expect(params) {
+      return Promise.resolve(BigInt(0));
+    }
+  }, {
+    key: "swap",
+    value: function swap(params) {
+      var receipt = {
+        fromToken: params.fromToken,
+        toToken: params.toToken,
+        amount: params.amount
+      };
+      return Promise.resolve(receipt);
+    }
+  }, {
+    key: "bridge",
+    value: function bridge(params) {
+      var receipt = {
+        fromToken: params.fromToken,
+        toToken: params.toToken,
+        amount: params.amount
+      };
+      return Promise.resolve(receipt);
+    }
+  }, {
+    key: "swapAndBridge",
+    value: function swapAndBridge(params) {
+      var receipt = {};
+      return Promise.resolve(receipt);
+    }
+  }]);
+  return Hermes;
+}();
+export default Hermes;

package/dist/esm/types.js

@@ -1 +1 @@
-export{};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-swap",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "A TypeScript utility library for swap and bridge",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",