@sodax/types 2.0.0-rc.17 → 2.0.0-rc.19

package/dist/backend/backendApiV1.d.ts

@@ -0,0 +1,28 @@
+import type { SpokeChainKey, IntentRelayChainIdMap } from '../chains/chains.js';
+import type { XToken } from '../chains/tokens.js';
+import type { Result, SpokeChainConfigMap } from '../common/common.js';
+import type { Address } from '../shared/shared.js';
+export type GetChainsApiResponse = readonly SpokeChainKey[];
+export type GetSwapTokensApiResponse = Record<SpokeChainKey, readonly XToken[]>;
+export type GetSwapTokensByChainIdApiResponse = readonly XToken[];
+export type GetMoneyMarketTokensApiResponse = Record<SpokeChainKey, readonly XToken[]>;
+export type GetMoneyMarketTokensByChainIdApiResponse = readonly XToken[];
+export type GetRelayChainIdMapApiResponse = IntentRelayChainIdMap;
+export type GetSpokeChainConfigApiResponse = SpokeChainConfigMap;
+export type GetMoneyMarketReserveAssetsApiResponse = readonly Address[];
+export type GetAllConfigApiResponse = {
+    version?: number;
+    supportedChains: GetChainsApiResponse;
+    supportedSwapTokens: GetSwapTokensApiResponse;
+    supportedMoneyMarketTokens: GetMoneyMarketTokensApiResponse;
+    supportedMoneyMarketReserveAssets: GetMoneyMarketReserveAssetsApiResponse;
+    relayChainIdMap: GetRelayChainIdMapApiResponse;
+    spokeChainConfig: GetSpokeChainConfigApiResponse;
+};
+export interface IConfigApiV1 {
+    getChains(): Promise<Result<GetChainsApiResponse>>;
+    getSwapTokens(): Promise<Result<GetSwapTokensApiResponse>>;
+    getSwapTokensByChainId(chainId: SpokeChainKey): Promise<Result<GetSwapTokensByChainIdApiResponse>>;
+    getMoneyMarketTokens(): Promise<Result<GetMoneyMarketTokensApiResponse>>;
+    getMoneyMarketTokensByChainId(chainId: SpokeChainKey): Promise<Result<GetMoneyMarketTokensByChainIdApiResponse>>;
+}

package/dist/backend/backendApiV2.d.ts

@@ -3,6 +3,7 @@ import type { XToken } from '../chains/tokens.js';
 import type { RelayConfig } from '../common/constants.js';
 import type { ConcentratedLiquidityConfig, DexDefaultConfig } from '../dex/dex.js';
 import type { SodaxDefaultConfig } from '../sodax-config/sodax-config.js';
+import type { RawTxReturnType } from '../common/index.js';
 /** Quote direction. Only exact-input quoting is supported. */
 export type QuoteTypeV2 = 'exact_input';
 /**
@@ -254,13 +255,13 @@ export interface AllowanceCheckResponseV2 {
 }
 /** POST /swaps/approve — response body. */
 export interface ApproveResponseV2 {
-    /** Unsigned approval transaction (chain-specific shape). For EVM: `{ from, to, value, data }`. */
-    tx: unknown;
+    /** Unsigned approval transaction — the `RawTxReturnType` variant for the request's `srcChainKey`. */
+    tx: RawTxReturnType;
 }
 /** POST /swaps/intents — response body. */
 export interface CreateIntentResponseV2 {
-    /** Unsigned create-intent transaction (chain-specific shape). For EVM: `{ from, to, value, data }`. */
-    tx: unknown;
+    /** Unsigned create-intent transaction — the `RawTxReturnType` variant for the request's `srcChainKey`. */
+    tx: RawTxReturnType;
     /** Built intent struct (hub representation). */
     intent: IntentResponseV2;
     /** Extra data required when calling `POST /swaps/intents/submit`. */
@@ -301,8 +302,8 @@ export interface CancelIntentRequestV2 {
 }
 /** POST /swaps/intents/cancel — response body. */
 export interface CancelIntentResponseV2 {
-    /** Unsigned cancel transaction (chain-specific shape). For EVM: `{ from, to, value, data }`. */
-    tx: unknown;
+    /** Unsigned cancel-intent transaction — the `RawTxReturnType` variant for the request's `srcChainKey`. */
+    tx: RawTxReturnType;
 }
 /** POST /swaps/intents/hash — request body. */
 export interface IntentHashRequestV2 {

package/dist/backend/backendApiV2.js

@@ -10,15 +10,21 @@
 // - Outbound (response) types are pure JSON: every bigint-derived value (intent
 //   ids, amounts, deadlines, fees, relay chain ids) is a decimal `string`, and
 //   every `Date` is an ISO 8601 `string` (e.g. `abandonedAt`). A response NEVER
-//   contains `bigint` — JSON cannot represent it.
+//   contains `bigint` on the wire — JSON cannot represent it (the one typed
+//   exception is the unsigned `tx`; see below).
 // - Inbound (request) types mirror the server's parsed request DTOs: the Intent
 //   struct (`IntentRequestV2`) carries `bigint` for its numeric fields, matching
 //   the backend `IntentDto`. Other request fields (amounts/deadlines on
 //   `CreateIntentParamsV2`/`QuoteRequestV2`, fees, relay chain ids, etc.) are
 //   decimal `string`, matching their `@IsNumberString` DTO fields.
 // - `Hex` / `Address` / `Hash` / `SpokeChainKey` are plain `string` everywhere.
-// - Chain-specific opaque payloads (unsigned `tx`, gas estimate, raw relay
-//   `result`) are `unknown` because their shape varies by chain family.
+// - The unsigned `tx` is typed as the SDK domain union `RawTxReturnType`. It
+//   travels as pure JSON (bigints stringified; Injective byte arrays as
+//   `{ "0": N, … }` index objects), and the SDK client's response schema
+//   (`@sodax/sdk` `rawTxSchemas`) rebuilds the domain shape (`bigint`,
+//   `Uint8Array`) on parse — the inverse of the backend's `stringifyBigInts`.
+// - The remaining chain-specific opaque payloads (gas estimate, raw relay
+//   `result`) stay `unknown` because their shape varies by chain family.
 //
 // Shapes used in both directions are split into a `*RequestV2` (client → server)
 // and a `*ResponseV2` (server → client) interface. `IntentRequestV2` (bigint

package/dist/backend/index.d.ts

@@ -1,2 +1,2 @@
-export * from './backendApi.js';
+export * from './backendApiV1.js';
 export * from './backendApiV2.js';

package/dist/backend/index.js

@@ -1,2 +1,2 @@
-export * from './backendApi.js';
+export * from './backendApiV1.js';
 export * from './backendApiV2.js';

package/dist/chains/chains.js

@@ -29,7 +29,7 @@ export const RelayChainIdMap = {
     [ChainKeys.STACKS_MAINNET]: 60n,
 };
 export const INTENT_CHAIN_IDS = Object.values(RelayChainIdMap);
-export const IntentRelayChainIdToChainKey = Object.fromEntries(Object.entries(RelayChainIdMap).map(([chainKey, chainId]) => [chainId, chainKey]));
+export const IntentRelayChainIdToChainKey = new Map(Object.entries(RelayChainIdMap).map(([chainKey, chainId]) => [chainId, chainKey]));
 /**
  * Base URL for default chain logos hosted in the `@sodax/assets` package.
  * Each logo is served from `main` via raw.githubusercontent and named by its

package/dist/common/constants.d.ts

@@ -15,11 +15,28 @@ export declare const DEFAULT_BACKEND_API_HEADERS: {
 };
 export declare const DEFAULT_RELAYER_API_ENDPOINT = "https://xcall-relay.nw.iconblockchain.xyz";
 export declare const VAULT_TOKEN_DECIMALS = 18;
-export type ApiConfig = {
+export type BaseApiConfig = {
     baseURL: HttpUrl;
     timeout: number;
     headers: Record<string, string>;
 };
+/** Per-endpoint config for the swaps API. Structurally identical to {@link BaseApiConfig}. */
+export type SwapsApiConfig = BaseApiConfig;
+/**
+ * Nested config that points the base (backend) API and the swaps API at independent endpoints.
+ * At least one slice must be provided — an empty custom config is meaningless (pass a flat
+ * {@link BaseApiConfig} instead). Requiring a slice keeps the two members disjoint from
+ * `BaseApiConfig` (which carries `baseURL`), so {@link ApiConfig} can be discriminated by the
+ * presence of a `baseApiConfig` / `swapsApiConfig` slice.
+ */
+export type CustomApiConfig = {
+    baseApiConfig: BaseApiConfig;
+    swapsApiConfig?: SwapsApiConfig;
+} | {
+    baseApiConfig?: BaseApiConfig;
+    swapsApiConfig: SwapsApiConfig;
+};
+export type ApiConfig = BaseApiConfig | CustomApiConfig;
 export declare const apiConfig: {
     baseURL: "https://api.sodax.com/v1/be";
     timeout: number;

package/dist/index.d.ts

@@ -19,4 +19,4 @@ export * from './sui/index.js';
 export * from './swap/index.js';
 export * from './utils/index.js';
 export * from './wallet/index.js';
-export declare const CONFIG_VERSION = 215;
+export declare const CONFIG_VERSION = 217;

package/dist/index.js

@@ -19,4 +19,4 @@ export * from './sui/index.js';
 export * from './swap/index.js';
 export * from './utils/index.js';
 export * from './wallet/index.js';
-export const CONFIG_VERSION = 215; // this value should be incremented (inside release/sdk branch) each time @sodax/types package is updated
+export const CONFIG_VERSION = 217; // this value should be incremented (inside release/sdk branch) each time @sodax/types package is updated

package/dist/shared/analytics.d.ts

@@ -0,0 +1,119 @@
+import type { SodaxFeature } from './features.js';
+/**
+ * Analytics for the SDK — structured, opt-in tracking of user-action flows.
+ *
+ * This is deliberately separate from {@link SodaxLogger}. The logger is a developer-facing
+ * diagnostics sink that is **on by default** (`console`) and takes free-form messages. Analytics
+ * is a product-facing event stream that is **off by default**: the SDK emits nothing — and never
+ * even builds an event payload — unless a consumer explicitly enables it via
+ * `new Sodax({ analytics })`. This keeps feature code paths free of analytics overhead when it is
+ * not in use.
+ *
+ * Enable and shape it through {@link AnalyticsOption} on the `Sodax` constructor:
+ * - omitted / `false` — disabled (default).
+ * - an {@link AnalyticsConfig} — forward events to your own product-analytics backend, optionally
+ *   scoped by feature and detail level.
+ */
+/**
+ * Lifecycle phase of a tracked feature action flow. Every event marks where in a feature's action
+ * flow it was emitted, so a sink can pair a `start` with its terminal `success` / `failure`
+ * (e.g. to measure duration or drop-off).
+ */
+export type AnalyticsEventPhase = 'start' | 'success' | 'failure';
+/**
+ * Detail level an event belongs to. Consumers choose how much the SDK tracks:
+ * - `basic` — coarse action flow (feature, action, phase) only.
+ * - `detailed` — adds richer `data` payloads (amounts, tokens, chain keys, …).
+ *
+ * The SDK only builds and emits a `detailed` event when the configured level is `detailed`, so
+ * heavier payloads are never constructed when a consumer stays on `basic`.
+ */
+export type AnalyticsDetailLevel = 'basic' | 'detailed';
+/**
+ * A single user-action analytics event emitted by the SDK at a feature action-flow boundary.
+ *
+ * `feature` + `action` + `phase` form the stable identity of an event — the same `(feature,
+ * action)` tagging the error layer already standardizes — so events line up with errors in a
+ * downstream sink. `data` is an optional structured payload whose richness depends on the
+ * configured {@link AnalyticsDetailLevel}.
+ */
+export interface AnalyticsEvent {
+    /** The high-level feature the action belongs to. */
+    feature: SodaxFeature;
+    /** The feature-level operation in flight, e.g. `'supply'`, `'createIntent'`, `'stake'`. */
+    action: string;
+    /** Where in the action flow this event was emitted. */
+    phase: AnalyticsEventPhase;
+    /** The detail level this event belongs to; gated against the configured level. */
+    level: AnalyticsDetailLevel;
+    /** Optional structured payload. Present mainly on `detailed` events. */
+    data?: Record<string, unknown>;
+}
+/**
+ * Consumer-supplied tracker: the SDK calls it once per emitted event, and the consumer forwards the
+ * event to their product-analytics backend (Segment, Amplitude, PostHog, a custom collector, …),
+ * e.g. `tracker: (event) => amplitude.track(event.action, event.data)`.
+ *
+ * It must be cheap and non-throwing — the SDK treats it as fire-and-forget, does not await it, and
+ * swallows any error it throws so analytics can never break a feature flow.
+ */
+export type AnalyticsTracker = (event: AnalyticsEvent) => void;
+/**
+ * How much of one feature to track, in the {@link AnalyticsConfig.features} allowlist:
+ * - `true` — every action of the feature.
+ * - `{ actions }` — only the named actions (e.g. `{ actions: ['supply', 'borrow'] }`).
+ */
+export type AnalyticsFeatureScope = true | {
+    actions: readonly string[];
+};
+/**
+ * The set of features (and actions) to track — an **allowlist**. Two equivalent forms:
+ * - Object: per-feature {@link AnalyticsFeatureScope}. A feature **omitted from the object is OFF**.
+ *   `{ swap: true, moneyMarket: { actions: ['supply'] } }`.
+ * - Array shorthand: a list of features, each fully tracked. `['swap', 'moneyMarket']`.
+ *
+ * Omitting {@link AnalyticsConfig.features} entirely tracks **everything** (all features, all
+ * actions) — scoping is opt-in.
+ */
+export type AnalyticsFeatures = Partial<Record<SodaxFeature, AnalyticsFeatureScope>> | readonly SodaxFeature[];
+/**
+ * Analytics configuration passed to `new Sodax({ analytics })`.
+ *
+ * Providing this object is what turns analytics on; the {@link AnalyticsTracker} `tracker` is the
+ * only required field. `level` and `features` narrow what gets emitted so consumers track only what
+ * they care about — by detail level and by feature/action.
+ *
+ * @example
+ * new Sodax({
+ *   analytics: {
+ *     tracker: (event) => amplitude.track(event.action, event.data),
+ *     features: {
+ *       swap: true,                              // all swap actions
+ *       moneyMarket: { actions: ['supply', 'borrow'] }, // only these
+ *       // staking omitted → OFF
+ *     }, // or simple form: features: ['swap', 'moneyMarket']
+ *   },
+ * });
+ */
+export interface AnalyticsConfig {
+    /** Where events are delivered. Required — enabling analytics means supplying a tracker. */
+    tracker: AnalyticsTracker;
+    /**
+     * Highest detail level to emit. Defaults to `'basic'`. Events tagged `'detailed'` are only built
+     * and delivered when this is `'detailed'`.
+     */
+    level?: AnalyticsDetailLevel;
+    /**
+     * Allowlist of features/actions to track. Omit to track everything; otherwise only the listed
+     * features (and, with `{ actions }`, only the listed actions) emit. See {@link AnalyticsFeatures}.
+     */
+    features?: AnalyticsFeatures;
+}
+/**
+ * The `analytics` option accepted by `new Sodax(...)`. Either a full {@link AnalyticsConfig} or
+ * `false` (the default — analytics disabled).
+ *
+ * Like `logger`, this is a client-side runtime option resolved once by the SDK; it is never
+ * fetched from or overwritten by the backend config.
+ */
+export type AnalyticsOption = AnalyticsConfig | false;

package/dist/shared/analytics.js

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

package/dist/shared/features.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The set of high-level SODAX SDK features.
+ *
+ * Used as a first-class tag across cross-cutting concerns — error reporting
+ * (`SodaxError.feature` in `@sodax/sdk`) and analytics ({@link AnalyticsEvent.feature} and
+ * per-feature analytics toggles). It lives in `@sodax/types`, the lowest layer, so every package
+ * shares one source of truth instead of redefining the list; `@sodax/sdk` re-exports it.
+ */
+export type SodaxFeature = 'swap' | 'moneyMarket' | 'bridge' | 'staking' | 'migration' | 'dex' | 'partner' | 'recovery' | 'backend' | 'leverageYield';

package/dist/shared/features.js

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

package/dist/shared/index.d.ts

@@ -1,2 +1,4 @@
 export * from './shared.js';
 export * from './logger.js';
+export * from './features.js';
+export * from './analytics.js';

package/dist/shared/index.js

@@ -1,2 +1,4 @@
 export * from './shared.js';
 export * from './logger.js';
+export * from './features.js';
+export * from './analytics.js';

package/dist/sodax-config/sodax-config.d.ts

@@ -1,5 +1,6 @@
 import type { TxPollingConfig } from '../shared/shared.js';
 import type { SodaxLoggerOption } from '../shared/logger.js';
+import type { AnalyticsOption } from '../shared/analytics.js';
 import type { DeepPartial } from '../utils/deep-partial.js';
 import { type ApiConfig, type SolverConfig, type RelayConfig } from '../common/constants.js';
 import type { MoneyMarketDefaultConfig, MoneyMarketOptions, PartnerFee, Prettify } from '../common/common.js';
@@ -35,11 +36,13 @@ export type BridgeDefaultConfig = {};
 export declare const bridgeConfig: {};
 export type SodaxOptionalConfig = {
     logger?: SodaxLoggerOption;
+    analytics?: AnalyticsOption;
     fee?: PartnerFee;
     swaps?: SwapsOptions;
     moneyMarket?: MoneyMarketOptions;
     bridge?: BridgeOptions;
     leverageYield?: LeverageYieldOptions;
+    swapsOptions?: SwapsClientOptions;
 };
 /**
  * Options (always optional) accepted by `new Sodax(...)`. A deep-partial override of the {@link SodaxDefaultConfig} data
@@ -68,8 +71,17 @@ export type SodaxDefaultConfig = {
     relay: RelayConfig;
 };
 /**
- * Sodax default static data object which can always be overriden through Sodax instance (i.e. new Sodax(...config))
+ * Client-side swap behavior options. Like {@link SodaxOptionalConfig.logger}, these are runtime toggles
+ * resolved once at construction — NOT part of the backend-fetched {@link SodaxDefaultConfig} data.
  */
+export type SwapsClientOptions = {
+    /**
+     * Opt-in: route `swap()` through the backend submit-tx 2-step flow (the backend relays +
+     * post-executes server-side). On ANY non-success the SDK falls back to the client-side relay so
+     * the swap still completes. Default `false` (the current fully client-side flow).
+     */
+    useBackendSubmitTx?: boolean;
+};
 export declare const sodaxConfig: {
     chains: {
         readonly sonic: {

package/dist/sodax-config/sodax-config.js

@@ -5,9 +5,7 @@ import { swapsConfig } from '../swap/swap.js';
 import { leverageYieldConfig, } from '../leverageYield/leverageYield.js';
 import { spokeChainConfig, hubConfig, } from '../chains/chains.js';
 export const bridgeConfig = {};
-/**
- * Sodax default static data object which can always be overriden through Sodax instance (i.e. new Sodax(...config))
- */
+// default sodax config object which can always be overriden through Sodax instance (i.e. new Sodax(...config))
 export const sodaxConfig = {
     chains: spokeChainConfig,
     swaps: swapsConfig,

package/dist/solana/solana.d.ts

@@ -100,6 +100,8 @@ export interface ISolanaWalletProvider extends ICoreWallet {
     readonly chainType: 'SOLANA';
     getWalletAddress: () => Promise<string>;
     sendTransaction: (rawTransaction: Uint8Array | Array<number>) => Promise<TransactionSignature>;
+    /** Deserialize, sign, and broadcast an unsigned `SolanaRawTransaction` (e.g. from the Swaps API). */
+    signAndSendTransaction?: (params: SolanaRawTransaction) => Promise<TransactionSignature>;
     waitForConfirmation: (signature: TransactionSignature, commitment: Commitment) => Promise<SolanaRpcResponseAndContext<SolanaSignatureResult>>;
     buildV0Txn: (instructions: SolanaRawTransactionInstruction[]) => Promise<SolanaSerializedTransaction>;
     getWalletBase58PublicKey: () => SolanaBase58PublicKey;

package/dist/stacks/stacks.d.ts

@@ -207,4 +207,6 @@ export interface IStacksWalletProvider extends ICoreWallet {
     getPublicKey: () => Promise<string>;
     getBalance: (address: string) => Promise<bigint>;
     sendTransaction: (txParams: StacksTransactionParams) => Promise<string>;
+    /** Sign and broadcast an unsigned `StacksRawTransaction` (e.g. from the Swaps API). Returns the tx id. */
+    signAndSendTransaction?: (params: StacksRawTransaction) => Promise<string>;
 }

package/dist/stellar/stellar.d.ts

@@ -92,5 +92,9 @@ export interface IStellarWalletProvider extends ICoreWallet {
     readonly chainType: 'STELLAR';
     signTransaction: (tx: XDR) => Promise<XDR>;
     waitForTransactionReceipt: (txHash: string) => Promise<StellarRawTransactionReceipt>;
+    /** Broadcast an already-signed XDR transaction via the Soroban RPC server. Returns the tx hash. */
+    sendTransaction?: (signedTx: XDR) => Promise<string>;
+    /** Sign and broadcast an unsigned `StellarRawTransaction` (e.g. from the Swaps API). Returns the tx hash. */
+    signAndSendTransaction?: (params: StellarRawTransaction) => Promise<string>;
 }
 export {};

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.0.0-rc.17",
+  "version": "2.0.0-rc.19",
   "description": "Sodax Common Types",
   "main": "dist/index.js",
   "homepage": "https://github.com/icon-project/sodax-sdks/tree/main/packages/types",

package/dist/backend/backendApi.d.ts

@@ -1,74 +0,0 @@
-import type { SpokeChainKey, IntentRelayChainIdMap } from '../chains/chains.js';
-import type { XToken } from '../chains/tokens.js';
-import type { Result, SpokeChainConfigMap } from '../common/common.js';
-import type { Address } from '../shared/shared.js';
-import type { SodaxConfig } from '../sodax-config/sodax-config.js';
-export type GetChainsApiResponse = readonly SpokeChainKey[];
-export type GetSwapTokensApiResponse = Record<SpokeChainKey, readonly XToken[]>;
-export type GetSwapTokensByChainIdApiResponse = readonly XToken[];
-export type GetMoneyMarketTokensApiResponse = Record<SpokeChainKey, readonly XToken[]>;
-export type GetMoneyMarketTokensByChainIdApiResponse = readonly XToken[];
-export type GetRelayChainIdMapApiResponse = IntentRelayChainIdMap;
-export type GetSpokeChainConfigApiResponse = SpokeChainConfigMap;
-export type GetMoneyMarketReserveAssetsApiResponse = readonly Address[];
-export type GetAllConfigApiResponse = {
-    version?: number;
-    config: SodaxConfig;
-};
-export interface IConfigApi {
-    getChains(): Promise<Result<GetChainsApiResponse>>;
-    getSwapTokens(): Promise<Result<GetSwapTokensApiResponse>>;
-    getSwapTokensByChainId(chainId: SpokeChainKey): Promise<Result<GetSwapTokensByChainIdApiResponse>>;
-    getMoneyMarketTokens(): Promise<Result<GetMoneyMarketTokensApiResponse>>;
-    getMoneyMarketTokensByChainId(chainId: SpokeChainKey): Promise<Result<GetMoneyMarketTokensByChainIdApiResponse>>;
-}
-export interface SwapIntentData {
-    intentId: string;
-    creator: string;
-    inputToken: string;
-    outputToken: string;
-    inputAmount: string;
-    minOutputAmount: string;
-    deadline: string;
-    allowPartialFill: boolean;
-    srcChain: number;
-    dstChain: number;
-    srcAddress: string;
-    dstAddress: string;
-    solver: string;
-    data: string;
-}
-export interface SubmitSwapTxRequest {
-    txHash: string;
-    srcChainKey: string;
-    walletAddress: string;
-    intent: SwapIntentData;
-    relayData: string;
-}
-export interface SubmitSwapTxResponse {
-    success: boolean;
-    message: string;
-}
-export interface GetSubmitSwapTxStatusParams {
-    txHash: string;
-    srcChainKey?: string;
-}
-export interface SubmitSwapTxStatusResult {
-    dstIntentTxHash: string;
-    packetData?: Record<string, unknown>;
-    intent_hash?: string;
-}
-export type SubmitSwapTxStatus = 'pending' | 'verifying' | 'verified' | 'relaying' | 'relayed' | 'posting_execution' | 'executed' | 'failed';
-export interface SubmitSwapTxStatusData {
-    txHash: string;
-    srcChainKey: string;
-    status: SubmitSwapTxStatus;
-    failedAtStep?: string;
-    failureReason?: string;
-    failedAttempts: number;
-    result?: SubmitSwapTxStatusResult;
-}
-export interface SubmitSwapTxStatusResponse {
-    success: boolean;
-    data: SubmitSwapTxStatusData;
-}