@shapeshiftoss/swapper 17.6.2 → 17.6.4

package/dist/esm/utils.js

@@ -0,0 +1,183 @@
+import { solanaChainId } from '@shapeshiftoss/caip';
+import { evm, TxStatus } from '@shapeshiftoss/unchained-client';
+import { bn, fromBaseUnit } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import Axios from 'axios';
+import { setupCache } from 'axios-cache-interceptor';
+import { fetchSafeTransactionInfo } from './safe-utils/index.js';
+import { TradeQuoteError } from './types.js';
+export const makeSwapErrorRight = ({ details, cause, code, message, }) => ({
+    name: 'SwapError',
+    message,
+    details,
+    cause,
+    code,
+});
+export const createTradeAmountTooSmallErr = (details) => makeSwapErrorRight({
+    code: TradeQuoteError.SellAmountBelowMinimum,
+    message: 'Sell amount is too small',
+    details,
+});
+const getRequestFilter = (cachedUrls) => (request) => !cachedUrls.some(url => request.url?.includes(url));
+export const createCache = (maxAge, cachedUrls, axiosConfig) => {
+    const filter = getRequestFilter(cachedUrls);
+    const axiosInstance = Axios.create(axiosConfig);
+    setupCache(axiosInstance, {
+        ttl: maxAge,
+        cachePredicate: cacheResponse => filter(cacheResponse.config),
+        interpretHeader: false,
+        staleIfError: true,
+        cacheTakeover: false,
+    });
+    return axiosInstance;
+};
+// https://github.com/sniptt-official/monads/issues/111
+export const AsyncResultOf = async (promise) => {
+    try {
+        return Ok(await promise);
+    }
+    catch (err) {
+        return Err(err);
+    }
+};
+export const makeSwapperAxiosServiceMonadic = (service) => new Proxy(service, {
+    get: (trappedAxios, method) => {
+        const originalMethodPromise = trappedAxios[method];
+        return async (...args) => {
+            // getMixPanel()?.track(MixPanelEvent.SwapperApiRequest, {
+            //   swapper: swapperName,
+            //   url: args[0],
+            //   method,
+            // })
+            const result = await AsyncResultOf(originalMethodPromise(...args));
+            return result
+                .mapErr(e => makeSwapErrorRight({
+                message: 'makeSwapperAxiosServiceMonadic',
+                cause: e,
+                code: TradeQuoteError.QueryFailed,
+            }))
+                .andThen(result => {
+                if (!result.data)
+                    return Err(makeSwapErrorRight({
+                        message: 'makeSwapperAxiosServiceMonadic: no data was returned',
+                        cause: result,
+                        code: TradeQuoteError.QueryFailed,
+                    }));
+                return Ok(result);
+            });
+        };
+    },
+});
+export const getHopByIndex = (quote, index) => {
+    if (quote === undefined)
+        return undefined;
+    if (index > 1) {
+        throw new Error("Index out of bounds - Swapper doesn't currently support more than 2 hops.");
+    }
+    const hop = quote.steps[index];
+    return hop;
+};
+export const executeEvmTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+export const executeSolanaTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+export const createDefaultStatusResponse = (buyTxHash) => ({
+    status: TxStatus.Unknown,
+    buyTxHash,
+    message: undefined,
+});
+export const checkSafeTransactionStatus = async ({ address, txHash, chainId, assertGetEvmChainAdapter, fetchIsSmartContractAddressQuery, }) => {
+    const { isExecutedSafeTx, isQueuedSafeTx, transaction } = await fetchSafeTransactionInfo({
+        address,
+        chainId,
+        fetchIsSmartContractAddressQuery,
+        safeTxHash: txHash,
+    });
+    if (!transaction)
+        return;
+    // SAFE proposal queued, but not executed on-chain yet
+    if (isQueuedSafeTx) {
+        return {
+            status: TxStatus.Pending,
+            message: [
+                'common.safeProposalQueued',
+                {
+                    currentConfirmations: transaction.confirmations?.length,
+                    confirmationsRequired: transaction.confirmationsRequired,
+                },
+            ],
+            buyTxHash: undefined,
+        };
+    }
+    // Transaction executed on-chain
+    if (isExecutedSafeTx) {
+        const adapter = assertGetEvmChainAdapter(chainId);
+        const tx = await adapter.httpProvider.getTransaction({ txid: transaction.transactionHash });
+        const status = evm.getTxStatus(tx);
+        return {
+            status,
+            buyTxHash: transaction.transactionHash,
+            message: 'common.safeProposalExecuted',
+        };
+    }
+};
+export const checkEvmSwapStatus = async ({ txHash, chainId, address, assertGetEvmChainAdapter, fetchIsSmartContractAddressQuery, }) => {
+    try {
+        const maybeSafeTransactionStatus = await checkSafeTransactionStatus({
+            address,
+            txHash,
+            fetchIsSmartContractAddressQuery,
+            chainId,
+            assertGetEvmChainAdapter,
+        });
+        if (maybeSafeTransactionStatus)
+            return maybeSafeTransactionStatus;
+        const adapter = assertGetEvmChainAdapter(chainId);
+        const tx = await adapter.httpProvider.getTransaction({ txid: txHash });
+        const status = evm.getTxStatus(tx);
+        return {
+            status,
+            buyTxHash: txHash,
+            message: undefined,
+        };
+    }
+    catch (e) {
+        console.error(e);
+        return createDefaultStatusResponse(txHash);
+    }
+};
+export const getInputOutputRate = ({ sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit, sellAsset, buyAsset, }) => {
+    const sellAmountCryptoHuman = fromBaseUnit(sellAmountCryptoBaseUnit, sellAsset.precision);
+    const buyAmountCryptoHuman = fromBaseUnit(buyAmountCryptoBaseUnit, buyAsset.precision);
+    return bn(buyAmountCryptoHuman).div(sellAmountCryptoHuman).toFixed();
+};
+export const isExecutableTradeQuote = (quote) => quote.quoteOrRate === 'quote';
+export const isExecutableTradeStep = (step) => step.accountNumber !== undefined;
+export const getExecutableTradeStep = (tradeQuote, stepIndex) => {
+    const step = getHopByIndex(tradeQuote, stepIndex);
+    if (!step)
+        throw new Error(`No hop found for stepIndex ${stepIndex}`);
+    if (!isExecutableTradeStep(step))
+        throw Error('Unable to execute a trade rate step');
+    return step;
+};
+export const checkSolanaSwapStatus = async ({ txHash, address, assertGetSolanaChainAdapter, }) => {
+    try {
+        if (!address)
+            throw new Error('Missing address');
+        const adapter = assertGetSolanaChainAdapter(solanaChainId);
+        const tx = await adapter.httpProvider.getTransaction({ txid: txHash });
+        const status = await adapter.getTxStatus(tx, address);
+        return {
+            status,
+            buyTxHash: txHash,
+            message: undefined,
+        };
+    }
+    catch (e) {
+        console.error(e);
+        return createDefaultStatusResponse(txHash);
+    }
+};

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "@shapeshiftoss/swapper",
-  "version": "17.6.2",
-  "description": "An interface and implementations to trade coins via various protocols",
-  "repository": "https://github.com/shapeshift/lib",
+  "version": "17.6.4",
+  "packageManager": "yarn@3.5.0",
+  "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/esm/index.d.ts"
+    }
+  },
   "files": [
     "dist"
   ],
@@ -13,41 +22,18 @@
     "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile",
-    "dev": "tsc --watch",
-    "clean": "rm -rf dist && rm -rf tsconfig.build.tsbuildinfo",
-    "compile": "tsc -p tsconfig.build.json",
-    "prepare": "yarn build",
-    "test": "jest test",
-    "type-check": "tsc --project ./tsconfig.build.json --noEmit",
-    "swapcli": "yarn build && node ./dist/swappercli.js"
+    "build": "yarn clean && yarn run -T tsc --build && yarn postbuild",
+    "clean": "rm -rf dist",
+    "dev": "yarn run -T tsc --build --watch",
+    "postbuild": "yarn postbuild:esm && yarn postbuild:cjs",
+    "postbuild:esm": "yarn run -T tsc-esm-fix --target=dist/esm --ext=.js",
+    "postbuild:cjs": "echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json"
   },
   "dependencies": {
-    "axios": "^0.26.1",
-    "axios-cache-adapter": "^2.7.3",
-    "bignumber.js": "^9.1.1",
-    "lodash": "^4.17.21",
-    "retry-axios": "^2.6.0",
-    "web3": "1.7.4"
-  },
-  "peerDependencies": {
-    "@shapeshiftoss/asset-service": "^8.0.1",
-    "@shapeshiftoss/caip": "^8.0.0",
-    "@shapeshiftoss/chain-adapters": "^11.0.0",
-    "@shapeshiftoss/errors": "^1.1.2",
-    "@shapeshiftoss/hdwallet-core": "^1.46.0",
-    "@shapeshiftoss/types": "^8.1.0"
-  },
-  "devDependencies": {
-    "@shapeshiftoss/asset-service": "^8.0.1",
-    "@shapeshiftoss/caip": "^8.0.0",
-    "@shapeshiftoss/chain-adapters": "^11.0.0",
-    "@shapeshiftoss/errors": "^1.1.2",
-    "@shapeshiftoss/hdwallet-core": "^1.46.0",
-    "@shapeshiftoss/types": "^8.1.0",
-    "@shapeshiftoss/unchained-client": "^10.0.1",
-    "@types/readline-sync": "^1.4.4",
-    "readline-sync": "^1.4.10",
-    "web3-utils": "1.7.4"
+    "@coral-xyz/anchor": "0.29.0",
+    "@shapeshiftoss/caip": "workspace:^",
+    "@shapeshiftoss/chain-adapters": "workspace:^",
+    "@shapeshiftoss/types": "workspace:^",
+    "@shapeshiftoss/utils": "workspace:^"
   }
 }

package/README.md

@@ -1,72 +0,0 @@
-# @shapeshiftoss/swapper
-
-## Getting Started
-
-```sh
-yarn add @shapeshiftoss/swapper
-```
-
-## Usage
-
-### Swapper CLI
-- Copy the `sample.env` to `.env`
-```sh
-cp sample.env .env
-```
-
-- Usage:
-```sh
-$ swapcli [sellSymbol] [buySymbol] [sellAmount](denominated in sell asset, not wei)
-```
-ie:
-```sh
-$ swapcli ETH USDC 0.001
-```
-
-### Setup
-
-```ts
-import { SwapperManager, SwapperType, ZrxSwapper } from '@shapeshiftoss/swapper'
-
-// in code
-const manager = new SwapperManager<MyCustomSwapperTypes>()
-
-// Add a swapper to the manager, you can add your own if it follows the `Swapper` API spec
-manager
-  .addSwapper(new ZrxSwapper())
-  .addSwapper(new ThorchainSwapper())
-
-// Get a swapper from the manager
-const swapper = manager.getSwapper(SwapperType.Zrx)
-
-// Remove a swapper from the manager
-manager.removeSwapper(SwapperType.ZrxEthereum)
-```
-
-### Working with the manager
-
-```ts
-// Get best quote and swapper for a trading pair
-const { swapperType, quote } = await manager.getBestQuote(...args)
-
-// Get the swapper and do stuff
-const swapper = manager.getSwapper(swapperType)
-```
-
-### Working with a specific swapper
-
-```ts
-// Get a list of supported assets/trading pairs
-const assets = await swapper.getSupportedAssets()
-
-// Get a quote from a swapper
-const quote = await swapper.getQuote(...args)
-
-// Execute a Trade
-const txToSign = await swapper.buildTransaction(...args)
-
-// broadcast your TX
-const tx = await swapper.execute(signedTx)
-// or
-const tx = await adapter.broadcastTransaction(...args)
-```

package/dist/adapters.d.ts

@@ -1,2 +0,0 @@
-import { ChainAdapterManager } from '@shapeshiftoss/chain-adapters';
-export declare const getAdapterManager: () => ChainAdapterManager;

package/dist/adapters.js

@@ -1,94 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAdapterManager = void 0;
-const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
-const types_1 = require("@shapeshiftoss/types");
-const unchained = __importStar(require("@shapeshiftoss/unchained-client"));
-const dotenv_1 = __importDefault(require("dotenv"));
-dotenv_1.default.config();
-const { UNCHAINED_ETH_HTTPS_API = 'http://localhost:31300', UNCHAINED_ETH_WS_API = 'wss://localhost:31300', UNCHAINED_BTC_HTTPS_API = 'http://localhost:31300', UNCHAINED_BTC_WS_API = 'wss://localhost:31300', UNCHAINED_LTC_HTTPS_API = 'http://localhost:31300', UNCHAINED_LTC_WS_API = 'wss://localhost:31300', UNCHAINED_RUNE_HTTPS_API = 'http://localhost:31300', UNCHAINED_RUNE_WS_API = 'wss://localhost:31300', UNCHAINED_ATOM_HTTPS_API = 'http://localhost:31300', UNCHAINED_ATOM_WS_API = 'wss://localhost:31300', ETH_NODE_URL = 'http://localhost:31300', } = process.env;
-const getAdapterManager = () => {
-    const ethChainAdapter = new chain_adapters_1.ethereum.ChainAdapter({
-        providers: {
-            ws: new unchained.ws.Client(UNCHAINED_ETH_WS_API),
-            http: new unchained.ethereum.V1Api(new unchained.ethereum.Configuration({
-                basePath: UNCHAINED_ETH_HTTPS_API,
-            })),
-        },
-        rpcUrl: ETH_NODE_URL,
-    });
-    const btcAdapterArgs = {
-        coinName: 'bitcoin',
-        providers: {
-            ws: new unchained.ws.Client(UNCHAINED_BTC_WS_API),
-            http: new unchained.bitcoin.V1Api(new unchained.bitcoin.Configuration({
-                basePath: UNCHAINED_BTC_HTTPS_API,
-            })),
-        },
-    };
-    const bitcoinChainAdapter = new chain_adapters_1.bitcoin.ChainAdapter(btcAdapterArgs);
-    const ltcAdapterArgs = {
-        coinName: 'litecoin',
-        providers: {
-            ws: new unchained.ws.Client(UNCHAINED_LTC_WS_API),
-            http: new unchained.bitcoin.V1Api(new unchained.bitcoin.Configuration({
-                basePath: UNCHAINED_LTC_HTTPS_API,
-            })),
-        },
-    };
-    const litecoinChainAdapter = new chain_adapters_1.bitcoin.ChainAdapter(ltcAdapterArgs);
-    const runeAdapterArgs = {
-        coinName: 'rune',
-        providers: {
-            ws: new unchained.ws.Client(UNCHAINED_RUNE_WS_API),
-            http: new unchained.thorchain.V1Api(new unchained.thorchain.Configuration({
-                basePath: UNCHAINED_RUNE_HTTPS_API,
-            })),
-        },
-    };
-    const thorchainChainAdapter = new chain_adapters_1.thorchain.ChainAdapter(runeAdapterArgs);
-    const cosmosAdapterArgs = {
-        coinName: 'atom',
-        providers: {
-            ws: new unchained.ws.Client(UNCHAINED_ATOM_WS_API),
-            http: new unchained.thorchain.V1Api(new unchained.thorchain.Configuration({
-                basePath: UNCHAINED_ATOM_HTTPS_API,
-            })),
-        },
-    };
-    const cosmosChainAdapter = new chain_adapters_1.cosmos.ChainAdapter(cosmosAdapterArgs);
-    const adapterManager = new Map();
-    adapterManager.set(types_1.KnownChainIds.BitcoinMainnet, bitcoinChainAdapter);
-    adapterManager.set(types_1.KnownChainIds.EthereumMainnet, ethChainAdapter);
-    adapterManager.set(types_1.KnownChainIds.ThorchainMainnet, thorchainChainAdapter);
-    adapterManager.set(types_1.KnownChainIds.LitecoinMainnet, litecoinChainAdapter);
-    adapterManager.set(types_1.KnownChainIds.CosmosMainnet, cosmosChainAdapter);
-    return adapterManager;
-};
-exports.getAdapterManager = getAdapterManager;