@shapeshiftoss/swapper 17.6.2 → 17.6.4

package/dist/cjs/swappers/RelaySwapper/utils/types.d.ts

@@ -0,0 +1,157 @@
+import type { Asset } from '@shapeshiftoss/types';
+export type RelayTradeBaseParams = {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    affiliateBps: string;
+};
+export type RelayTradeInputParams<T extends 'rate' | 'quote'> = RelayTradeBaseParams & {
+    quoteOrRate: T;
+    receiveAddress: T extends 'rate' ? string | undefined : string;
+    sendAddress: T extends 'rate' ? undefined : string;
+    accountNumber: T extends 'rate' ? undefined : number;
+    slippageTolerancePercentageDecimal?: string;
+    xpub: string | undefined;
+};
+export type RelayTransactionMetadata = {
+    to?: string;
+    from?: string;
+    value?: string;
+    data?: string;
+    gasLimit?: string;
+    psbt?: string;
+    opReturnData?: string;
+    relayId: string;
+};
+export type RelayStatus = {
+    status: 'success' | 'failed' | 'pending' | 'refund' | 'delayed' | 'waiting';
+    details?: string;
+    inTxHashes: string[];
+    txHashes: string[];
+    time: number;
+    originChainId: number;
+    destinationChainId: number;
+};
+export type AppFee = {
+    recipient: string;
+    fee: string;
+};
+export type Transaction = {
+    from: string;
+    to: string;
+    value: string;
+    data: string;
+};
+export type RelayFetchQuoteParams<T extends 'quote' | 'rate'> = {
+    user: T extends 'quote' ? string : undefined;
+    originChainId: number;
+    destinationChainId: number;
+    originCurrency: string;
+    destinationCurrency: string;
+    tradeType: 'EXACT_INPUT' | 'EXACT_OUTPUT' | 'EXPECTED_OUTPUT';
+    recipient?: string;
+    amount?: string;
+    referrer?: string;
+    refundOnOrigin?: boolean;
+    refundTo: string;
+    slippageTolerance?: string;
+    appFees?: AppFee[];
+};
+export type RelayToken = {
+    chainId: number;
+    address: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+};
+export type RelayCurrencyData = {
+    currency: RelayToken;
+    amount: string;
+    amountFormatted: string;
+    amountUsd: string;
+    minimumAmount: string;
+};
+export type RelayFees = {
+    gas: RelayCurrencyData;
+    relayer: RelayCurrencyData;
+    app: RelayCurrencyData;
+};
+export type QuoteDetails = {
+    currencyOut: RelayCurrencyData;
+    rate: string;
+    slippageTolerance: {
+        origin: {
+            percent: string;
+        };
+        destination: {
+            percent: string;
+        };
+    };
+    timeEstimate: number;
+};
+export type RelayQuoteEvmItemData = {
+    to?: string;
+    data?: string;
+    value?: string;
+    gas?: string;
+};
+export type RelayQuoteUtxoItemData = {
+    psbt?: string;
+    to?: string;
+    opReturnData?: string;
+};
+export type RelayQuoteSolanaItemData = {
+    instructions: RelaySolanaInstruction[];
+    addressLookupTableAddresses: string[];
+};
+export type RelayQuoteItem = {
+    data?: RelayQuoteEvmItemData | RelayQuoteUtxoItemData | RelayQuoteSolanaItemData;
+};
+export type RelayQuoteStep = {
+    id: string;
+    requestId: string;
+    items?: RelayQuoteItem[];
+};
+export type RelayQuote = {
+    fees: RelayFees;
+    details: QuoteDetails;
+    steps: RelayQuoteStep[];
+};
+export declare const isRelayQuoteUtxoItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData) => item is RelayQuoteUtxoItemData;
+export declare const isRelayQuoteEvmItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData) => item is RelayQuoteEvmItemData;
+export declare const isRelayQuoteSolanaItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData) => item is RelayQuoteSolanaItemData;
+export type RelaySolanaInstruction = {
+    keys: {
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }[];
+    data: string;
+    programId: string;
+};
+export declare enum RelayErrorCode {
+    AmountTooLow = "AMOUNT_TOO_LOW",
+    Erc20RouterAddressNotFound = "ERC20_ROUTER_ADDRESS_NOT_FOUND",
+    ExtraTransactionsNotSupported = "EXTRA_TXS_NOT_SUPPORTED",
+    InsufficientFunds = "INSUFFICIENT_FUNDS",
+    InsufficientLiquidity = "INSUFFICIENT_LIQUIDITY",
+    InvalidAddress = "INVALID_ADDRESS",
+    InvalidExtraTransactions = "INVALID_EXTRA_TXS",
+    NoQuotes = "NO_QUOTES",
+    NoSwapRoutesFound = "NO_SWAP_ROUTES_FOUND",
+    PermitFailed = "PERMIT_FAILED",
+    SwapImpactTooHigh = "SWAP_IMPACT_TOO_HIGH",
+    SwapQuoteFailed = "SWAP_QUOTE_FAILED",
+    Unauthorized = "UNAUTHORIZED",
+    UnknownError = "UNKNOWN_ERROR",
+    UnsupportedChain = "UNSUPPORTED_CHAIN",
+    UnsupportedCurrency = "UNSUPPORTED_CURRENCY",
+    UnsupportedExecutionType = "UNSUPPORTED_EXECUTION_TYPE",
+    UnsupportedRoute = "UNSUPPORTED_ROUTE",
+    UserRecipientMismatch = "USER_RECIPIENT_MISMATCH"
+}
+export type RelayError = {
+    errorCode: RelayErrorCode;
+    message: string;
+};
+export declare const isRelayError: (error: unknown) => error is RelayError;

package/dist/cjs/swappers/RelaySwapper/utils/types.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRelayError = exports.RelayErrorCode = exports.isRelayQuoteSolanaItemData = exports.isRelayQuoteEvmItemData = exports.isRelayQuoteUtxoItemData = void 0;
+const isRelayQuoteUtxoItemData = (item) => {
+    return 'psbt' in item;
+};
+exports.isRelayQuoteUtxoItemData = isRelayQuoteUtxoItemData;
+const isRelayQuoteEvmItemData = (item) => {
+    return 'to' in item && 'data' in item && 'value' in item;
+};
+exports.isRelayQuoteEvmItemData = isRelayQuoteEvmItemData;
+const isRelayQuoteSolanaItemData = (item) => {
+    return 'instructions' in item;
+};
+exports.isRelayQuoteSolanaItemData = isRelayQuoteSolanaItemData;
+var RelayErrorCode;
+(function (RelayErrorCode) {
+    RelayErrorCode["AmountTooLow"] = "AMOUNT_TOO_LOW";
+    RelayErrorCode["Erc20RouterAddressNotFound"] = "ERC20_ROUTER_ADDRESS_NOT_FOUND";
+    RelayErrorCode["ExtraTransactionsNotSupported"] = "EXTRA_TXS_NOT_SUPPORTED";
+    RelayErrorCode["InsufficientFunds"] = "INSUFFICIENT_FUNDS";
+    RelayErrorCode["InsufficientLiquidity"] = "INSUFFICIENT_LIQUIDITY";
+    RelayErrorCode["InvalidAddress"] = "INVALID_ADDRESS";
+    RelayErrorCode["InvalidExtraTransactions"] = "INVALID_EXTRA_TXS";
+    RelayErrorCode["NoQuotes"] = "NO_QUOTES";
+    RelayErrorCode["NoSwapRoutesFound"] = "NO_SWAP_ROUTES_FOUND";
+    RelayErrorCode["PermitFailed"] = "PERMIT_FAILED";
+    RelayErrorCode["SwapImpactTooHigh"] = "SWAP_IMPACT_TOO_HIGH";
+    RelayErrorCode["SwapQuoteFailed"] = "SWAP_QUOTE_FAILED";
+    RelayErrorCode["Unauthorized"] = "UNAUTHORIZED";
+    RelayErrorCode["UnknownError"] = "UNKNOWN_ERROR";
+    RelayErrorCode["UnsupportedChain"] = "UNSUPPORTED_CHAIN";
+    RelayErrorCode["UnsupportedCurrency"] = "UNSUPPORTED_CURRENCY";
+    RelayErrorCode["UnsupportedExecutionType"] = "UNSUPPORTED_EXECUTION_TYPE";
+    RelayErrorCode["UnsupportedRoute"] = "UNSUPPORTED_ROUTE";
+    RelayErrorCode["UserRecipientMismatch"] = "USER_RECIPIENT_MISMATCH";
+})(RelayErrorCode || (exports.RelayErrorCode = RelayErrorCode = {}));
+const isRelayError = (error) => {
+    return typeof error === 'object' && error !== null && 'errorCode' in error && 'message' in error;
+};
+exports.isRelayError = isRelayError;

package/dist/cjs/swappers/ThorchainSwapper/ThorchainSwapper.d.ts

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types';
+export declare const thorchainSwapper: Swapper;

package/dist/cjs/swappers/ThorchainSwapper/ThorchainSwapper.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thorchainSwapper = void 0;
+const utils_1 = require("../../utils");
+exports.thorchainSwapper = {
+    executeEvmTransaction: utils_1.executeEvmTransaction,
+    executeCosmosSdkTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

package/dist/cjs/swappers/ThorchainSwapper/constants.d.ts

@@ -0,0 +1,7 @@
+import type { SwapSource } from '../../types';
+export declare const THORCHAIN_PRECISION = 8;
+export declare const THORCHAIN_AFFILIATE_NAME = "ss";
+export declare const THORCHAIN_SUPPORTED_CHAIN_IDS: import("@shapeshiftoss/caip").ChainId[];
+export declare const THORCHAIN_STREAM_SWAP_SOURCE: SwapSource;
+export declare const THORCHAIN_LONGTAIL_SWAP_SOURCE: SwapSource;
+export declare const THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE: SwapSource;

package/dist/cjs/swappers/ThorchainSwapper/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE = exports.THORCHAIN_LONGTAIL_SWAP_SOURCE = exports.THORCHAIN_STREAM_SWAP_SOURCE = exports.THORCHAIN_SUPPORTED_CHAIN_IDS = exports.THORCHAIN_AFFILIATE_NAME = exports.THORCHAIN_PRECISION = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("../../types");
+const poolAssetHelpers_1 = require("./utils/poolAssetHelpers/poolAssetHelpers");
+exports.THORCHAIN_PRECISION = 8;
+exports.THORCHAIN_AFFILIATE_NAME = 'ss';
+exports.THORCHAIN_SUPPORTED_CHAIN_IDS = [
+    ...new Set(Object.keys(poolAssetHelpers_1.assetIdToThorPoolAssetIdMap).map(assetId => (0, caip_1.fromAssetId)(assetId).chainId)),
+];
+exports.THORCHAIN_STREAM_SWAP_SOURCE = `${types_1.SwapperName.Thorchain} • Streaming`;
+exports.THORCHAIN_LONGTAIL_SWAP_SOURCE = `${types_1.SwapperName.Thorchain} • Long-tail`;
+exports.THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE = `${types_1.SwapperName.Thorchain} • Long-tail streaming`;

package/dist/cjs/swappers/ThorchainSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types';
+export declare const thorchainApi: SwapperApi;

package/dist/cjs/swappers/ThorchainSwapper/endpoints.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thorchainApi = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const thorchain_utils_1 = require("../../thorchain-utils");
+const types_1 = require("../../types");
+const utils_1 = require("../../utils");
+const getTradeQuote_1 = require("./getTradeQuote/getTradeQuote");
+const getTradeRate_1 = require("./getTradeRate/getTradeRate");
+const swapperName = types_1.SwapperName.Thorchain;
+exports.thorchainApi = {
+    getTradeRate: getTradeRate_1.getTradeRate,
+    getTradeQuote: getTradeQuote_1.getTradeQuote,
+    getUnsignedEvmTransaction: input => thorchain_utils_1.evm.getUnsignedEvmTransaction(input, swapperName),
+    getEvmTransactionFees: input => thorchain_utils_1.evm.getEvmTransactionFees(input, swapperName),
+    getUnsignedUtxoTransaction: input => thorchain_utils_1.utxo.getUnsignedUtxoTransaction(input, swapperName),
+    getUtxoTransactionFees: input => thorchain_utils_1.utxo.getUtxoTransactionFees(input, swapperName),
+    getUnsignedCosmosSdkTransaction: async ({ tradeQuote, stepIndex, from, config, assertGetCosmosSdkChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const { memo } = tradeQuote;
+        if (!memo)
+            throw new Error('Memo is required');
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, feeData } = step;
+        const gas = feeData.chainSpecific.estimatedGasCryptoBaseUnit;
+        const fee = feeData.networkFeeCryptoBaseUnit ?? '0';
+        switch (sellAsset.assetId) {
+            case caip_1.thorchainAssetId:
+            case caip_1.rujiAssetId:
+            case caip_1.tcyAssetId: {
+                const coin = (() => {
+                    if (sellAsset.assetId === caip_1.tcyAssetId)
+                        return 'THOR.TCY';
+                    if (sellAsset.assetId === caip_1.rujiAssetId)
+                        return 'THOR.RUJI';
+                    return 'THOR.RUNE';
+                })();
+                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+                const { txToSign } = await adapter.buildDepositTransaction({
+                    accountNumber,
+                    from,
+                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    memo,
+                    chainSpecific: {
+                        gas,
+                        fee,
+                        coin,
+                    },
+                });
+                return txToSign;
+            }
+            case caip_1.cosmosAssetId: {
+                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+                const url = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;
+                const data = await (0, thorchain_utils_1.getInboundAddressDataForChain)(url, caip_1.cosmosAssetId, true, swapperName);
+                if (data.isErr())
+                    throw data.unwrapErr();
+                const { address: vault } = data.unwrap();
+                const { txToSign } = await adapter.buildSendApiTransaction({
+                    accountNumber,
+                    from,
+                    to: vault,
+                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    memo,
+                    chainSpecific: { gas, fee },
+                });
+                return txToSign;
+            }
+            default:
+                throw Error(`Unsupported sellAsset: ${sellAsset.assetId}`);
+        }
+    },
+    getCosmosSdkTransactionFees: input => thorchain_utils_1.cosmossdk.getCosmosSdkTransactionFees(input),
+    checkTradeStatus: input => {
+        const { config } = input;
+        const nodeUrl = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;
+        const apiUrl = `${config.VITE_UNCHAINED_THORCHAIN_HTTP_URL}/api/v1`;
+        return (0, thorchain_utils_1.checkTradeStatus)({ ...input, nodeUrl, apiUrl, nativeChain: 'THOR' });
+    },
+};