@shapeshiftoss/swapper 17.6.6 → 17.6.7

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

@@ -0,0 +1,158 @@
+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",
+    ChainDisabled = "CHAIN_DISABLED",
+    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/esm/swappers/RelaySwapper/utils/types.js

@@ -0,0 +1,35 @@
+export const isRelayQuoteUtxoItemData = (item) => {
+    return 'psbt' in item;
+};
+export const isRelayQuoteEvmItemData = (item) => {
+    return 'to' in item && 'data' in item && 'value' in item;
+};
+export const isRelayQuoteSolanaItemData = (item) => {
+    return 'instructions' in item;
+};
+export var RelayErrorCode;
+(function (RelayErrorCode) {
+    RelayErrorCode["AmountTooLow"] = "AMOUNT_TOO_LOW";
+    RelayErrorCode["ChainDisabled"] = "CHAIN_DISABLED";
+    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 || (RelayErrorCode = {}));
+export const isRelayError = (error) => {
+    return typeof error === 'object' && error !== null && 'errorCode' in error && 'message' in error;
+};

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

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

package/dist/esm/swappers/ThorchainSwapper/ThorchainSwapper.js

@@ -0,0 +1,10 @@
+import { executeEvmTransaction } from '../../utils.js';
+export const thorchainSwapper = {
+    executeEvmTransaction,
+    executeCosmosSdkTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { SwapSource } from '../../types.js';
+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/esm/swappers/ThorchainSwapper/constants.js

@@ -0,0 +1,11 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { SwapperName } from '../../types.js';
+import { assetIdToThorPoolAssetIdMap } from './utils/poolAssetHelpers/poolAssetHelpers.js';
+export const THORCHAIN_PRECISION = 8;
+export const THORCHAIN_AFFILIATE_NAME = 'ss';
+export const THORCHAIN_SUPPORTED_CHAIN_IDS = [
+    ...new Set(Object.keys(assetIdToThorPoolAssetIdMap).map(assetId => fromAssetId(assetId).chainId)),
+];
+export const THORCHAIN_STREAM_SWAP_SOURCE = `${SwapperName.Thorchain} • Streaming`;
+export const THORCHAIN_LONGTAIL_SWAP_SOURCE = `${SwapperName.Thorchain} • Long-tail`;
+export const THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE = `${SwapperName.Thorchain} • Long-tail streaming`;

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

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

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

@@ -0,0 +1,78 @@
+import { cosmosAssetId, rujiAssetId, tcyAssetId, thorchainAssetId } from '@shapeshiftoss/caip';
+import { checkTradeStatus, cosmossdk, evm, getInboundAddressDataForChain, utxo, } from '../../thorchain-utils/index.js';
+import { SwapperName } from '../../types.js';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
+import { getTradeRate } from './getTradeRate/getTradeRate.js';
+const swapperName = SwapperName.Thorchain;
+export const thorchainApi = {
+    getTradeRate,
+    getTradeQuote,
+    getUnsignedEvmTransaction: input => evm.getUnsignedEvmTransaction(input, swapperName),
+    getEvmTransactionFees: input => evm.getEvmTransactionFees(input, swapperName),
+    getUnsignedUtxoTransaction: input => utxo.getUnsignedUtxoTransaction(input, swapperName),
+    getUtxoTransactionFees: input => utxo.getUtxoTransactionFees(input, swapperName),
+    getUnsignedCosmosSdkTransaction: async ({ tradeQuote, stepIndex, from, config, assertGetCosmosSdkChainAdapter, }) => {
+        if (!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 = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, feeData } = step;
+        const gas = feeData.chainSpecific.estimatedGasCryptoBaseUnit;
+        const fee = feeData.networkFeeCryptoBaseUnit ?? '0';
+        switch (sellAsset.assetId) {
+            case thorchainAssetId:
+            case rujiAssetId:
+            case tcyAssetId: {
+                const coin = (() => {
+                    if (sellAsset.assetId === tcyAssetId)
+                        return 'THOR.TCY';
+                    if (sellAsset.assetId === 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 cosmosAssetId: {
+                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+                const url = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;
+                const data = await getInboundAddressDataForChain(url, 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 => 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 checkTradeStatus({ ...input, nodeUrl, apiUrl, nativeChain: 'THOR' });
+    },
+};