Skip to main content

Variable: GSWAP\_ERROR\_CATALOG

gSwap SDK 2.0.0-rc.4

gSwap SDK 2.0.0-rc.4 / GSWAP_ERROR_CATALOG

Variable: GSWAP_ERROR_CATALOG

const GSWAP_ERROR_CATALOG: object

Defined in: packages/gswap-sdk/dist/index.d.ts:262

The whole DEX catalog. Add a code here before throwing it anywhere in gswap-sdk.

Type Declaration​

AMOUNT_IS_JS_NUMBER​

readonly AMOUNT_IS_JS_NUMBER: object

AMOUNT_IS_JS_NUMBER.params​

readonly params: object

AMOUNT_IS_JS_NUMBER.params.field​

readonly field: "string"

AMOUNT_IS_JS_NUMBER.phase​

readonly phase: "pre_send"

AMOUNT_IS_JS_NUMBER.template​

readonly template: "Invalid {field}: use a decimal string or BigNumber, not a JavaScript number"

AMOUNT_NEGATIVE​

readonly AMOUNT_NEGATIVE: object

AMOUNT_NEGATIVE.params​

readonly params: object

AMOUNT_NEGATIVE.params.field​

readonly field: "string"

AMOUNT_NEGATIVE.params.value​

readonly value: "string"

AMOUNT_NEGATIVE.phase​

readonly phase: "pre_send"

AMOUNT_NEGATIVE.template​

readonly template: "Invalid {field}: must not be negative (got {value})"

AMOUNT_NOT_FINITE​

readonly AMOUNT_NOT_FINITE: object

AMOUNT_NOT_FINITE.params​

readonly params: object

AMOUNT_NOT_FINITE.params.field​

readonly field: "string"

AMOUNT_NOT_FINITE.params.value​

readonly value: "string"

AMOUNT_NOT_FINITE.phase​

readonly phase: "pre_send"

AMOUNT_NOT_FINITE.template​

readonly template: "Invalid {field}: must be a finite number (got {value})"

AMOUNT_NOT_POSITIVE​

readonly AMOUNT_NOT_POSITIVE: object

AMOUNT_NOT_POSITIVE.params​

readonly params: object

AMOUNT_NOT_POSITIVE.params.field​

readonly field: "string"

AMOUNT_NOT_POSITIVE.params.value​

readonly value: "string"

AMOUNT_NOT_POSITIVE.phase​

readonly phase: "pre_send"

AMOUNT_NOT_POSITIVE.template​

readonly template: "Invalid {field}: must be positive (got {value})"

AT_MOST_ONE_OF_ALLOWED​

readonly AT_MOST_ONE_OF_ALLOWED: object

AT_MOST_ONE_OF_ALLOWED.params​

readonly params: object

AT_MOST_ONE_OF_ALLOWED.params.first​

readonly first: "string"

AT_MOST_ONE_OF_ALLOWED.params.second​

readonly second: "string"

AT_MOST_ONE_OF_ALLOWED.phase​

readonly phase: "pre_send"

AT_MOST_ONE_OF_ALLOWED.template​

readonly template: "Provide at most one of {first} or {second}."

BOUNDS_VIOLATION​

readonly BOUNDS_VIOLATION: object

BOUNDS_VIOLATION.params​

readonly params: object

BOUNDS_VIOLATION.params.serverMessage​

readonly serverMessage: "string"

BOUNDS_VIOLATION.phase​

readonly phase: "post_send"

BOUNDS_VIOLATION.template​

readonly template: "The gateway rejected a numeric, tick, symbol or range bound: {serverMessage}"

CHAIN_DISPATCH_FAILED​

readonly CHAIN_DISPATCH_FAILED: object

CHAIN_DISPATCH_FAILED.params​

readonly params: object

CHAIN_DISPATCH_FAILED.params.errorKey​

readonly errorKey: "string"

CHAIN_DISPATCH_FAILED.params.serverMessage​

readonly serverMessage: "string"

CHAIN_DISPATCH_FAILED.phase​

readonly phase: "post_send"

CHAIN_DISPATCH_FAILED.template​

readonly template: "The chain dispatch failed (chain error key "{errorKey}"): {serverMessage}"

CHAIN_REJECTED​

readonly CHAIN_REJECTED: object

CHAIN_REJECTED.params​

readonly params: object

CHAIN_REJECTED.params.errorKey​

readonly errorKey: "string"

CHAIN_REJECTED.params.serverMessage​

readonly serverMessage: "string"

CHAIN_REJECTED.phase​

readonly phase: "post_send"

CHAIN_REJECTED.template​

readonly template: "GalaChain error {errorKey}: {serverMessage}"

CONFIRMATION_ABORTED​

readonly CONFIRMATION_ABORTED: object

CONFIRMATION_ABORTED.params​

readonly params: object

CONFIRMATION_ABORTED.phase​

readonly phase: "post_send"

CONFIRMATION_ABORTED.template​

readonly template: "Transaction confirmation was aborted."

CONFIRMATION_FAILED​

readonly CONFIRMATION_FAILED: object

CONFIRMATION_FAILED.params​

readonly params: object

CONFIRMATION_FAILED.params.serverMessage​

readonly serverMessage: "string"

CONFIRMATION_FAILED.params.status​

readonly status: "number"

CONFIRMATION_FAILED.phase​

readonly phase: "post_send"

CONFIRMATION_FAILED.template​

readonly template: "Transaction confirmation failed with HTTP {status}."

CONFIRMATION_FAILED.unrendered​

readonly unrendered: readonly ["serverMessage"]

CONFIRMATION_KEY_MISMATCH​

readonly CONFIRMATION_KEY_MISMATCH: object

CONFIRMATION_KEY_MISMATCH.params​

readonly params: object

CONFIRMATION_KEY_MISMATCH.phase​

readonly phase: "post_send"

CONFIRMATION_KEY_MISMATCH.template​

readonly template: "Apply result key did not match the requested key."

CONFIRMATION_MALFORMED​

readonly CONFIRMATION_MALFORMED: object

CONFIRMATION_MALFORMED.params​

readonly params: object

CONFIRMATION_MALFORMED.phase​

readonly phase: "post_send"

CONFIRMATION_MALFORMED.template​

readonly template: "Transaction confirmation returned a malformed body."

CONFIRMATION_TIMEOUT​

readonly CONFIRMATION_TIMEOUT: object

CONFIRMATION_TIMEOUT.params​

readonly params: object

CONFIRMATION_TIMEOUT.phase​

readonly phase: "post_send"

CONFIRMATION_TIMEOUT.template​

readonly template: "Transaction confirmation timed out; the trade may still apply. Confirm the same uniqueKey again later instead of resubmitting."

CREATE_POOL_NEEDS_CLASS_KEY​

readonly CREATE_POOL_NEEDS_CLASS_KEY: object

CREATE_POOL_NEEDS_CLASS_KEY.params​

readonly params: object

CREATE_POOL_NEEDS_CLASS_KEY.params.token​

readonly token: "string"

CREATE_POOL_NEEDS_CLASS_KEY.phase​

readonly phase: "pre_send"

CREATE_POOL_NEEDS_CLASS_KEY.template​

readonly template: "createPool needs each token as a class key; {token} is a bare trading symbol, which does not carry one."

DTO_INVALID​

readonly DTO_INVALID: object

DTO_INVALID.params​

readonly params: object

DTO_INVALID.params.serverMessage​

readonly serverMessage: "string"

DTO_INVALID.phase​

readonly phase: "post_send"

DTO_INVALID.template​

readonly template: "The gateway rejected the DTO shape: {serverMessage}"

DTO_NOT_CANONICAL​

readonly DTO_NOT_CANONICAL: object

DTO_NOT_CANONICAL.params​

readonly params: object

DTO_NOT_CANONICAL.params.method​

readonly method: "string"

DTO_NOT_CANONICAL.phase​

readonly phase: "pre_send"

DTO_NOT_CANONICAL.template​

readonly template: "The {method} DTO is not in the form the SDK builders produce; build it with the matching build function and submit that."

EXACT_AMOUNT_REQUIRED​

readonly EXACT_AMOUNT_REQUIRED: object

EXACT_AMOUNT_REQUIRED.params​

readonly params: object

EXACT_AMOUNT_REQUIRED.params.field​

readonly field: "string"

EXACT_AMOUNT_REQUIRED.phase​

readonly phase: "pre_send"

EXACT_AMOUNT_REQUIRED.template​

readonly template: "{field} is required for this swap."

EXACTLY_ONE_OF_REQUIRED​

readonly EXACTLY_ONE_OF_REQUIRED: object

EXACTLY_ONE_OF_REQUIRED.params​

readonly params: object

EXACTLY_ONE_OF_REQUIRED.params.first​

readonly first: "string"

EXACTLY_ONE_OF_REQUIRED.params.second​

readonly second: "string"

EXACTLY_ONE_OF_REQUIRED.phase​

readonly phase: "pre_send"

EXACTLY_ONE_OF_REQUIRED.template​

readonly template: "Provide exactly one of {first} or {second}."

GATEWAY_DATA_MISSING​

readonly GATEWAY_DATA_MISSING: object

GATEWAY_DATA_MISSING.params​

readonly params: object

GATEWAY_DATA_MISSING.phase​

readonly phase: "post_send"

GATEWAY_DATA_MISSING.template​

readonly template: "The gateway response is missing its data object."

GATEWAY_MODE_INVALID​

readonly GATEWAY_MODE_INVALID: object

GATEWAY_MODE_INVALID.params​

readonly params: object

GATEWAY_MODE_INVALID.phase​

readonly phase: "post_send"

GATEWAY_MODE_INVALID.template​

readonly template: "Gateway response must contain data.mode="sync" with data.result, or data.mode="queued"."

GATEWAY_REJECTED​

readonly GATEWAY_REJECTED: object

GATEWAY_REJECTED.params​

readonly params: object

GATEWAY_REJECTED.params.gatewayCode​

readonly gatewayCode: "string"

GATEWAY_REJECTED.params.serverMessage​

readonly serverMessage: "string"

GATEWAY_REJECTED.phase​

readonly phase: "post_send"

GATEWAY_REJECTED.template​

readonly template: "Gateway rejected {gatewayCode}: {serverMessage}"

GATEWAY_REPORTED_ERROR​

readonly GATEWAY_REPORTED_ERROR: object

GATEWAY_REPORTED_ERROR.params​

readonly params: object

GATEWAY_REPORTED_ERROR.params.serverMessage​

readonly serverMessage: "string"

GATEWAY_REPORTED_ERROR.phase​

readonly phase: "post_send"

GATEWAY_REPORTED_ERROR.template​

readonly template: "The gateway reported an error for this write: {serverMessage}"

GATEWAY_SYNC_REQUEST_TRADE​

readonly GATEWAY_SYNC_REQUEST_TRADE: object

GATEWAY_SYNC_REQUEST_TRADE.params​

readonly params: object

GATEWAY_SYNC_REQUEST_TRADE.phase​

readonly phase: "post_send"

GATEWAY_SYNC_REQUEST_TRADE.template​

readonly template: "The gateway executed RequestTrade synchronously, which this SDK refuses; RequestTrade must be queued."

HTTP_ERROR​

readonly HTTP_ERROR: object

HTTP_ERROR.params​

readonly params: object

HTTP_ERROR.params.serverMessage​

readonly serverMessage: "string"

HTTP_ERROR.params.status​

readonly status: "number"

HTTP_ERROR.params.url​

readonly url: "string"

HTTP_ERROR.phase​

readonly phase: "post_send"

HTTP_ERROR.template​

readonly template: "Unexpected HTTP error {status} from {url}."

HTTP_ERROR.unrendered​

readonly unrendered: readonly ["serverMessage"]

INCOMPLETE_TOKEN_CLASS_KEY​

readonly INCOMPLETE_TOKEN_CLASS_KEY: object

INCOMPLETE_TOKEN_CLASS_KEY.params​

readonly params: object

INCOMPLETE_TOKEN_CLASS_KEY.params.compositeKey​

readonly compositeKey: "string"

INCOMPLETE_TOKEN_CLASS_KEY.params.part​

readonly part: "string"

INCOMPLETE_TOKEN_CLASS_KEY.phase​

readonly phase: "pre_send"

INCOMPLETE_TOKEN_CLASS_KEY.template​

readonly template: "Token class key "{compositeKey}" is missing {part}."

INSUFFICIENT_LIQUIDITY​

readonly INSUFFICIENT_LIQUIDITY: object

INSUFFICIENT_LIQUIDITY.params​

readonly params: object

INSUFFICIENT_LIQUIDITY.params.fee​

readonly fee: "string"

INSUFFICIENT_LIQUIDITY.params.tokenIn​

readonly tokenIn: "string"

INSUFFICIENT_LIQUIDITY.params.tokenOut​

readonly tokenOut: "string"

INSUFFICIENT_LIQUIDITY.phase​

readonly phase: "post_send"

INSUFFICIENT_LIQUIDITY.template​

readonly template: "The selected pool has insufficient liquidity for {tokenIn}/{tokenOut} (fee tier {fee})."

INVALID_CHAIN_RESPONSE​

readonly INVALID_CHAIN_RESPONSE: object

INVALID_CHAIN_RESPONSE.params​

readonly params: object

INVALID_CHAIN_RESPONSE.params.resource​

readonly resource: "string"

INVALID_CHAIN_RESPONSE.phase​

readonly phase: "post_send"

INVALID_CHAIN_RESPONSE.template​

readonly template: "Backend returned an invalid {resource}."

INVALID_DTO​

readonly INVALID_DTO: object

INVALID_DTO.params​

readonly params: object

INVALID_DTO.params.expected​

readonly expected: "string"

INVALID_DTO.params.field​

readonly field: "string"

INVALID_DTO.params.method​

readonly method: "string"

INVALID_DTO.phase​

readonly phase: "pre_send"

INVALID_DTO.template​

readonly template: "{method} DTO field {field} is invalid (expected {expected})."

INVALID_FEE​

readonly INVALID_FEE: object

INVALID_FEE.params​

readonly params: object

INVALID_FEE.params.allowed​

readonly allowed: "string"

INVALID_FEE.params.field​

readonly field: "string"

INVALID_FEE.params.value​

readonly value: "number"

INVALID_FEE.phase​

readonly phase: "pre_send"

INVALID_FEE.template​

readonly template: "Invalid {field}: {value} is not a supported fee tier; must be one of {allowed}."

INVALID_LIMIT​

readonly INVALID_LIMIT: object

INVALID_LIMIT.params​

readonly params: object

INVALID_LIMIT.params.max​

readonly max: "number"

INVALID_LIMIT.params.min​

readonly min: "number"

INVALID_LIMIT.params.value​

readonly value: "number"

INVALID_LIMIT.phase​

readonly phase: "pre_send"

INVALID_LIMIT.template​

readonly template: "limit must be an integer from {min} to {max} (got {value})."

INVALID_MARKET_TOKEN​

readonly INVALID_MARKET_TOKEN: object

INVALID_MARKET_TOKEN.params​

readonly params: object

INVALID_MARKET_TOKEN.params.token​

readonly token: "string"

INVALID_MARKET_TOKEN.phase​

readonly phase: "pre_send"

INVALID_MARKET_TOKEN.template​

readonly template: "A market read names a token by a symbol or class key of 1 to 120 letters, digits and . _ $ + / : | - characters (got "{token}")."

INVALID_PAGE​

readonly INVALID_PAGE: object

INVALID_PAGE.params​

readonly params: object

INVALID_PAGE.params.value​

readonly value: "number"

INVALID_PAGE.phase​

readonly phase: "pre_send"

INVALID_PAGE.template​

readonly template: "page must be an integer of at least 1 (got {value})."

INVALID_POLL_INTERVAL​

readonly INVALID_POLL_INTERVAL: object

INVALID_POLL_INTERVAL.params​

readonly params: object

INVALID_POLL_INTERVAL.params.value​

readonly value: "string"

INVALID_POLL_INTERVAL.phase​

readonly phase: "pre_send"

INVALID_POLL_INTERVAL.template​

readonly template: "intervalMs must be a finite number of milliseconds of at least 1 (got {value})."

INVALID_POSITION_RESPONSE​

readonly INVALID_POSITION_RESPONSE: object

INVALID_POSITION_RESPONSE.params​

readonly params: object

INVALID_POSITION_RESPONSE.params.reason​

readonly reason: "string"

INVALID_POSITION_RESPONSE.phase​

readonly phase: "post_send"

INVALID_POSITION_RESPONSE.template​

readonly template: "Backend returned an invalid position ({reason})."

INVALID_PRICE_BOUNDS​

readonly INVALID_PRICE_BOUNDS: object

INVALID_PRICE_BOUNDS.params​

readonly params: object

INVALID_PRICE_BOUNDS.params.maxPrice​

readonly maxPrice: "string"

INVALID_PRICE_BOUNDS.params.minPrice​

readonly minPrice: "string"

INVALID_PRICE_BOUNDS.phase​

readonly phase: "pre_send"

INVALID_PRICE_BOUNDS.template​

readonly template: "Price bounds must be finite and positive (minPrice {minPrice}, maxPrice {maxPrice})."

INVALID_PRICE_RANGE​

readonly INVALID_PRICE_RANGE: object

INVALID_PRICE_RANGE.params​

readonly params: object

INVALID_PRICE_RANGE.params.lowerPrice​

readonly lowerPrice: "string"

INVALID_PRICE_RANGE.params.upperPrice​

readonly upperPrice: "string"

INVALID_PRICE_RANGE.phase​

readonly phase: "pre_send"

INVALID_PRICE_RANGE.template​

readonly template: "Invalid price range: lower price {lowerPrice} must be less than or equal to upper price {upperPrice}"

INVALID_PRICE_VALUES​

readonly INVALID_PRICE_VALUES: object

INVALID_PRICE_VALUES.params​

readonly params: object

INVALID_PRICE_VALUES.params.lowerPrice​

readonly lowerPrice: "string"

INVALID_PRICE_VALUES.params.spotPrice​

readonly spotPrice: "string"

INVALID_PRICE_VALUES.params.upperPrice​

readonly upperPrice: "string"

INVALID_PRICE_VALUES.phase​

readonly phase: "pre_send"

INVALID_PRICE_VALUES.template​

readonly template: "Invalid price values: all prices must be finite and positive (spot {spotPrice}, lower {lowerPrice}, upper {upperPrice})"

INVALID_SEASON_ID​

readonly INVALID_SEASON_ID: object

INVALID_SEASON_ID.params​

readonly params: object

INVALID_SEASON_ID.params.value​

readonly value: "string"

INVALID_SEASON_ID.phase​

readonly phase: "pre_send"

INVALID_SEASON_ID.template​

readonly template: "seasonId must be an integer of at least 1 (got {value})."

INVALID_SORT_BY​

readonly INVALID_SORT_BY: object

INVALID_SORT_BY.params​

readonly params: object

INVALID_SORT_BY.params.allowed​

readonly allowed: "string"

INVALID_SORT_BY.params.value​

readonly value: "string"

INVALID_SORT_BY.phase​

readonly phase: "pre_send"

INVALID_SORT_BY.template​

readonly template: "sortBy "{value}" is not allowed; it must be one of {allowed}."

INVALID_SORT_ORDER​

readonly INVALID_SORT_ORDER: object

INVALID_SORT_ORDER.params​

readonly params: object

INVALID_SORT_ORDER.params.value​

readonly value: "string"

INVALID_SORT_ORDER.phase​

readonly phase: "pre_send"

INVALID_SORT_ORDER.template​

readonly template: "sortOrder "{value}" is not allowed; it must be asc or desc."

INVALID_SQRT_PRICE​

readonly INVALID_SQRT_PRICE: object

INVALID_SQRT_PRICE.params​

readonly params: object

INVALID_SQRT_PRICE.params.sqrtPrice​

readonly sqrtPrice: "string"

INVALID_SQRT_PRICE.phase​

readonly phase: "pre_send"

INVALID_SQRT_PRICE.template​

readonly template: "Cannot invert a non-positive sqrt price ({sqrtPrice})."

INVALID_STARTING_PRICE​

readonly INVALID_STARTING_PRICE: object

INVALID_STARTING_PRICE.params​

readonly params: object

INVALID_STARTING_PRICE.params.value​

readonly value: "string"

INVALID_STARTING_PRICE.phase​

readonly phase: "pre_send"

INVALID_STARTING_PRICE.template​

readonly template: "Starting price must be finite and positive (got {value})."

INVALID_TICK_RANGE​

readonly INVALID_TICK_RANGE: object

INVALID_TICK_RANGE.params​

readonly params: object

INVALID_TICK_RANGE.params.tickLower​

readonly tickLower: "number"

INVALID_TICK_RANGE.params.tickUpper​

readonly tickUpper: "number"

INVALID_TICK_RANGE.phase​

readonly phase: "pre_send"

INVALID_TICK_RANGE.template​

readonly template: "Invalid tick range: tickLower {tickLower} must be less than tickUpper {tickUpper}"

INVALID_TICK_SPACING​

readonly INVALID_TICK_SPACING: object

INVALID_TICK_SPACING.params​

readonly params: object

INVALID_TICK_SPACING.params.value​

readonly value: "number"

INVALID_TICK_SPACING.phase​

readonly phase: "pre_send"

INVALID_TICK_SPACING.template​

readonly template: "Invalid tick spacing: must be a positive integer (got {value})"

INVALID_TIMEFRAME​

readonly INVALID_TIMEFRAME: object

INVALID_TIMEFRAME.params​

readonly params: object

INVALID_TIMEFRAME.params.allowed​

readonly allowed: "string"

INVALID_TIMEFRAME.params.value​

readonly value: "string"

INVALID_TIMEFRAME.phase​

readonly phase: "pre_send"

INVALID_TIMEFRAME.template​

readonly template: "timeframe "{value}" is not allowed; it must be one of {allowed}."

INVALID_TOKEN_CLASS_KEY​

readonly INVALID_TOKEN_CLASS_KEY: object

INVALID_TOKEN_CLASS_KEY.params​

readonly params: object

INVALID_TOKEN_CLASS_KEY.params.tokenClassKey​

readonly tokenClassKey: "string"

INVALID_TOKEN_CLASS_KEY.phase​

readonly phase: "pre_send"

INVALID_TOKEN_CLASS_KEY.template​

readonly template: "Invalid token class key "{tokenClassKey}": expected a collection followed by category, type and additionalKey"

INVALID_TOKEN_DECIMALS​

readonly INVALID_TOKEN_DECIMALS: object

INVALID_TOKEN_DECIMALS.params​

readonly params: object

INVALID_TOKEN_DECIMALS.params.field​

readonly field: "string"

INVALID_TOKEN_DECIMALS.params.value​

readonly value: "number"

INVALID_TOKEN_DECIMALS.phase​

readonly phase: "pre_send"

INVALID_TOKEN_DECIMALS.template​

readonly template: "Invalid {field}: must be a non-negative integer (got {value})"

INVALID_TRADING_SYMBOL​

readonly INVALID_TRADING_SYMBOL: object

INVALID_TRADING_SYMBOL.params​

readonly params: object

INVALID_TRADING_SYMBOL.params.symbol​

readonly symbol: "string"

INVALID_TRADING_SYMBOL.phase​

readonly phase: "pre_send"

INVALID_TRADING_SYMBOL.template​

readonly template: "Invalid trading symbol "{symbol}": must be 1-32 ASCII letters and digits and not a reserved word (Token, Unit, none)."

METHOD_NOT_ALLOWED​

readonly METHOD_NOT_ALLOWED: object

METHOD_NOT_ALLOWED.params​

readonly params: object

METHOD_NOT_ALLOWED.params.serverMessage​

readonly serverMessage: "string"

METHOD_NOT_ALLOWED.phase​

readonly phase: "post_send"

METHOD_NOT_ALLOWED.template​

readonly template: "The gateway does not expose this contract method: {serverMessage}"

METHOD_NOT_SUPPORTED​

readonly METHOD_NOT_SUPPORTED: object

METHOD_NOT_SUPPORTED.params​

readonly params: object

METHOD_NOT_SUPPORTED.params.method​

readonly method: "string"

METHOD_NOT_SUPPORTED.phase​

readonly phase: "pre_send"

METHOD_NOT_SUPPORTED.template​

readonly template: "The method {method} is not supported; swaps are queued through RequestTrade."

MISSING_UNIQUE_KEY​

readonly MISSING_UNIQUE_KEY: object

MISSING_UNIQUE_KEY.params​

readonly params: object

MISSING_UNIQUE_KEY.phase​

readonly phase: "post_send"

MISSING_UNIQUE_KEY.template​

readonly template: "The gateway acknowledged RequestTrade without echoing its uniqueKey, so it cannot be tied to the signed request."

MISSING_WALLET_ADDRESS​

readonly MISSING_WALLET_ADDRESS: object

MISSING_WALLET_ADDRESS.params​

readonly params: object

MISSING_WALLET_ADDRESS.phase​

readonly phase: "pre_send"

MISSING_WALLET_ADDRESS.template​

readonly template: "Invalid wallet address: No wallet address provided. Either provide a wallet address to the function you are calling, or set one when instantiating GSwapSDK."

NO_POOL_AVAILABLE​

readonly NO_POOL_AVAILABLE: object

NO_POOL_AVAILABLE.params​

readonly params: object

NO_POOL_AVAILABLE.params.fee​

readonly fee: "string"

NO_POOL_AVAILABLE.params.tokenIn​

readonly tokenIn: "string"

NO_POOL_AVAILABLE.params.tokenOut​

readonly tokenOut: "string"

NO_POOL_AVAILABLE.phase​

readonly phase: "post_send"

NO_POOL_AVAILABLE.template​

readonly template: "No pool is available for {tokenIn}/{tokenOut} (fee tier {fee})."

NO_SIGNER​

readonly NO_SIGNER: object

NO_SIGNER.params​

readonly params: object

NO_SIGNER.phase​

readonly phase: "pre_send"

NO_SIGNER.template​

readonly template: "This method requires a signer. Please provide a signer to the GSwap constructor."

NO_VALID_TRADING_SYMBOL​

readonly NO_VALID_TRADING_SYMBOL: object

NO_VALID_TRADING_SYMBOL.params​

readonly params: object

NO_VALID_TRADING_SYMBOL.params.classKey​

readonly classKey: "string"

NO_VALID_TRADING_SYMBOL.params.displaySymbol​

readonly displaySymbol: "string"

NO_VALID_TRADING_SYMBOL.phase​

readonly phase: "pre_send"

NO_VALID_TRADING_SYMBOL.template​

readonly template: "No valid trading symbol for token class {classKey}: "{displaySymbol}" is not an acceptable symbol and none is registered"

NO_WALLET_ADDRESS​

readonly NO_WALLET_ADDRESS: object

NO_WALLET_ADDRESS.params​

readonly params: object

NO_WALLET_ADDRESS.phase​

readonly phase: "post_send"

NO_WALLET_ADDRESS.template​

readonly template: "Cannot confirm this write: no walletAddress was provided to the GSwap constructor, so the resulting position cannot be looked up to confirm it landed on chain."

NON_CANONICAL_PAIR​

readonly NON_CANONICAL_PAIR: object

NON_CANONICAL_PAIR.params​

readonly params: object

NON_CANONICAL_PAIR.params.token0​

readonly token0: "string"

NON_CANONICAL_PAIR.params.token1​

readonly token1: "string"

NON_CANONICAL_PAIR.phase​

readonly phase: "pre_send"

NON_CANONICAL_PAIR.template​

readonly template: "The pair {token0}/{token1} is not in canonical order: token0 must sort before token1."

POOL_MISMATCH​

readonly POOL_MISMATCH: object

POOL_MISMATCH.params​

readonly params: object

POOL_MISMATCH.params.poolToken0​

readonly poolToken0: "string"

POOL_MISMATCH.params.poolToken1​

readonly poolToken1: "string"

POOL_MISMATCH.params.tokenIn​

readonly tokenIn: "string"

POOL_MISMATCH.params.tokenOut​

readonly tokenOut: "string"

POOL_MISMATCH.phase​

readonly phase: "pre_send"

POOL_MISMATCH.template​

readonly template: "tokenIn {tokenIn} and tokenOut {tokenOut} must be the two tokens of the pinned pool {poolToken0}/{poolToken1}."

PRICE_BOUNDS_ORDER​

readonly PRICE_BOUNDS_ORDER: object

PRICE_BOUNDS_ORDER.params​

readonly params: object

PRICE_BOUNDS_ORDER.params.maxPrice​

readonly maxPrice: "string"

PRICE_BOUNDS_ORDER.params.minPrice​

readonly minPrice: "string"

PRICE_BOUNDS_ORDER.phase​

readonly phase: "pre_send"

PRICE_BOUNDS_ORDER.template​

readonly template: "minPrice {minPrice} must be less than or equal to maxPrice {maxPrice}."

PRICE_VALUES_IS_JS_NUMBER​

readonly PRICE_VALUES_IS_JS_NUMBER: object

PRICE_VALUES_IS_JS_NUMBER.params​

readonly params: object

PRICE_VALUES_IS_JS_NUMBER.phase​

readonly phase: "pre_send"

PRICE_VALUES_IS_JS_NUMBER.template​

readonly template: "Invalid price values: use decimal strings or BigNumber values, not JavaScript numbers"

RATE_LIMITED​

readonly RATE_LIMITED: object

RATE_LIMITED.params​

readonly params: object

RATE_LIMITED.params.serverMessage​

readonly serverMessage: "string"

RATE_LIMITED.phase​

readonly phase: "post_send"

RATE_LIMITED.template​

readonly template: "The gateway rate-limited this signer: {serverMessage}"

REQUEST_FAILED​

readonly REQUEST_FAILED: object

REQUEST_FAILED.params​

readonly params: object

REQUEST_FAILED.params.operation​

readonly operation: "string"

REQUEST_FAILED.phase​

readonly phase: "in_flight"

REQUEST_FAILED.template​

readonly template: "The {operation} request failed."

SEARCH_TOO_LONG​

readonly SEARCH_TOO_LONG: object

SEARCH_TOO_LONG.params​

readonly params: object

SEARCH_TOO_LONG.params.length​

readonly length: "number"

SEARCH_TOO_LONG.params.maxLength​

readonly maxLength: "number"

SEARCH_TOO_LONG.phase​

readonly phase: "pre_send"

SEARCH_TOO_LONG.template​

readonly template: "search must be at most {maxLength} characters (got {length})."

SHADOW_NOT_QUEUED​

readonly SHADOW_NOT_QUEUED: object

SHADOW_NOT_QUEUED.params​

readonly params: object

SHADOW_NOT_QUEUED.phase​

readonly phase: "post_send"

SHADOW_NOT_QUEUED.template​

readonly template: "The swap backend did not queue the shadow request."

SHADOW_SUBMIT_NEEDS_WALLET_ADDRESS​

readonly SHADOW_SUBMIT_NEEDS_WALLET_ADDRESS: object

SHADOW_SUBMIT_NEEDS_WALLET_ADDRESS.params​

readonly params: object

SHADOW_SUBMIT_NEEDS_WALLET_ADDRESS.phase​

readonly phase: "pre_send"

SHADOW_SUBMIT_NEEDS_WALLET_ADDRESS.template​

readonly template: "A shadow submission needs a walletAddress (the X-Wallet-Address header): pass one to the GSwap constructor or to this call."

SIGNATURE_INVALID​

readonly SIGNATURE_INVALID: object

SIGNATURE_INVALID.params​

readonly params: object

SIGNATURE_INVALID.params.serverMessage​

readonly serverMessage: "string"

SIGNATURE_INVALID.phase​

readonly phase: "post_send"

SIGNATURE_INVALID.template​

readonly template: "The gateway could not verify the signature: {serverMessage}"

SIGNER_MISMATCH​

readonly SIGNER_MISMATCH: object

SIGNER_MISMATCH.params​

readonly params: object

SIGNER_MISMATCH.params.serverMessage​

readonly serverMessage: "string"

SIGNER_MISMATCH.phase​

readonly phase: "post_send"

SIGNER_MISMATCH.template​

readonly template: "The recovered signer does not match an actor named by the operation: {serverMessage}"

STREAM_API_KEY_UNUSABLE​

readonly STREAM_API_KEY_UNUSABLE: object

STREAM_API_KEY_UNUSABLE.params​

readonly params: object

STREAM_API_KEY_UNUSABLE.phase​

readonly phase: "pre_send"

STREAM_API_KEY_UNUSABLE.template​

readonly template: "GdexStreamConfig.apiKey needs a non-empty key and an explicit webSocketImpl that accepts upgrade headers as its third argument (the "ws" package, or React Native). A browser WebSocket cannot send x-api-key, so the key would be silently dropped."

STREAM_CLOSED_BEFORE_CONNECT​

readonly STREAM_CLOSED_BEFORE_CONNECT: object

STREAM_CLOSED_BEFORE_CONNECT.params​

readonly params: object

STREAM_CLOSED_BEFORE_CONNECT.params.closeCode​

readonly closeCode: "number"

STREAM_CLOSED_BEFORE_CONNECT.phase​

readonly phase: "in_flight"

STREAM_CLOSED_BEFORE_CONNECT.template​

readonly template: "GDEX stream closed before connecting (code {closeCode})."

STREAM_CONNECT_FAILED​

readonly STREAM_CONNECT_FAILED: object

STREAM_CONNECT_FAILED.params​

readonly params: object

STREAM_CONNECT_FAILED.params.url​

readonly url: "string"

STREAM_CONNECT_FAILED.phase​

readonly phase: "in_flight"

STREAM_CONNECT_FAILED.template​

readonly template: "Failed to connect to GDEX stream at {url}."

STREAM_CONNECTION_CLOSED​

readonly STREAM_CONNECTION_CLOSED: object

STREAM_CONNECTION_CLOSED.params​

readonly params: object

STREAM_CONNECTION_CLOSED.params.closeCode​

readonly closeCode: "number"

STREAM_CONNECTION_CLOSED.phase​

readonly phase: "in_flight"

STREAM_CONNECTION_CLOSED.template​

readonly template: "GDEX stream connection closed (code {closeCode})."

STREAM_DISCONNECTED​

readonly STREAM_DISCONNECTED: object

STREAM_DISCONNECTED.params​

readonly params: object

STREAM_DISCONNECTED.phase​

readonly phase: "in_flight"

STREAM_DISCONNECTED.template​

readonly template: "GDEX stream disconnected."

STREAM_NOT_CONNECTED​

readonly STREAM_NOT_CONNECTED: object

STREAM_NOT_CONNECTED.params​

readonly params: object

STREAM_NOT_CONNECTED.phase​

readonly phase: "pre_send"

STREAM_NOT_CONNECTED.template​

readonly template: "GDEX stream is not connected. Call connect() first."

STREAM_REQUEST_TIMEOUT​

readonly STREAM_REQUEST_TIMEOUT: object

STREAM_REQUEST_TIMEOUT.params​

readonly params: object

STREAM_REQUEST_TIMEOUT.params.method​

readonly method: "string"

STREAM_REQUEST_TIMEOUT.params.timeoutMs​

readonly timeoutMs: "number"

STREAM_REQUEST_TIMEOUT.phase​

readonly phase: "in_flight"

STREAM_REQUEST_TIMEOUT.template​

readonly template: "GDEX request "{method}" timed out after {timeoutMs} ms."

STREAM_WEBSOCKET_UNAVAILABLE​

readonly STREAM_WEBSOCKET_UNAVAILABLE: object

STREAM_WEBSOCKET_UNAVAILABLE.params​

readonly params: object

STREAM_WEBSOCKET_UNAVAILABLE.phase​

readonly phase: "pre_send"

STREAM_WEBSOCKET_UNAVAILABLE.template​

readonly template: "GdexStreamService requires a standards-compatible WebSocket constructor. Node.js versions before 22 must provide one with config.webSocketImpl (for example, from the "ws" package)."

SUBMISSION_OUTCOME_UNKNOWN​

readonly SUBMISSION_OUTCOME_UNKNOWN: object

SUBMISSION_OUTCOME_UNKNOWN.params​

readonly params: object

SUBMISSION_OUTCOME_UNKNOWN.params.reason​

readonly reason: readonly ["timeout", "transport"]

SUBMISSION_OUTCOME_UNKNOWN.phase​

readonly phase: "in_flight"

SUBMISSION_OUTCOME_UNKNOWN.template​

readonly template: "The submission outcome is unknown ({reason}): the request may have reached the gateway. Confirm before retrying."

SYMBOL_CONFLICT​

readonly SYMBOL_CONFLICT: object

SYMBOL_CONFLICT.params​

readonly params: object

SYMBOL_CONFLICT.params.serverMessage​

readonly serverMessage: "string"

SYMBOL_CONFLICT.phase​

readonly phase: "post_send"

SYMBOL_CONFLICT.template​

readonly template: "The CreatePool symbol is already owned by another class: {serverMessage}"

SYMBOL_DISAGREES_WITH_REGISTRY​

readonly SYMBOL_DISAGREES_WITH_REGISTRY: object

SYMBOL_DISAGREES_WITH_REGISTRY.params​

readonly params: object

SYMBOL_DISAGREES_WITH_REGISTRY.params.registeredSymbol​

readonly registeredSymbol: "string"

SYMBOL_DISAGREES_WITH_REGISTRY.params.suppliedSymbol​

readonly suppliedSymbol: "string"

SYMBOL_DISAGREES_WITH_REGISTRY.params.token​

readonly token: "string"

SYMBOL_DISAGREES_WITH_REGISTRY.phase​

readonly phase: "pre_send"

SYMBOL_DISAGREES_WITH_REGISTRY.template​

readonly template: "Supplied symbol {suppliedSymbol} for {token} disagrees with the registered trading symbol {registeredSymbol}."

SYMBOL_NOT_FOUND​

readonly SYMBOL_NOT_FOUND: object

SYMBOL_NOT_FOUND.params​

readonly params: object

SYMBOL_NOT_FOUND.params.token​

readonly token: "string"

SYMBOL_NOT_FOUND.phase​

readonly phase: "pre_send"

SYMBOL_NOT_FOUND.template​

readonly template: "Token {token} could not be resolved to a trading symbol."

TICKS_NOT_ALIGNED​

readonly TICKS_NOT_ALIGNED: object

TICKS_NOT_ALIGNED.params​

readonly params: object

TICKS_NOT_ALIGNED.params.spacing​

readonly spacing: "number"

TICKS_NOT_ALIGNED.params.tickLower​

readonly tickLower: "number"

TICKS_NOT_ALIGNED.params.tickUpper​

readonly tickUpper: "number"

TICKS_NOT_ALIGNED.phase​

readonly phase: "pre_send"

TICKS_NOT_ALIGNED.template​

readonly template: "Ticks {tickLower} and {tickUpper} must be aligned to spacing {spacing}."

TICKS_NOT_INTEGERS​

readonly TICKS_NOT_INTEGERS: object

TICKS_NOT_INTEGERS.params​

readonly params: object

TICKS_NOT_INTEGERS.params.tickLower​

readonly tickLower: "number"

TICKS_NOT_INTEGERS.params.tickUpper​

readonly tickUpper: "number"

TICKS_NOT_INTEGERS.phase​

readonly phase: "pre_send"

TICKS_NOT_INTEGERS.template​

readonly template: "Invalid tick values: ticks must be integers (got {tickLower} and {tickUpper})"

TICKS_OUT_OF_BOUNDS​

readonly TICKS_OUT_OF_BOUNDS: object

TICKS_OUT_OF_BOUNDS.params​

readonly params: object

TICKS_OUT_OF_BOUNDS.params.maxTick​

readonly maxTick: "number"

TICKS_OUT_OF_BOUNDS.params.minTick​

readonly minTick: "number"

TICKS_OUT_OF_BOUNDS.params.tickLower​

readonly tickLower: "number"

TICKS_OUT_OF_BOUNDS.params.tickUpper​

readonly tickUpper: "number"

TICKS_OUT_OF_BOUNDS.phase​

readonly phase: "pre_send"

TICKS_OUT_OF_BOUNDS.template​

readonly template: "Invalid tick range: ticks {tickLower} and {tickUpper} must be between {minTick} and {maxTick}"

TOKEN_RESOLUTION_FAILED​

readonly TOKEN_RESOLUTION_FAILED: object

TOKEN_RESOLUTION_FAILED.params​

readonly params: object

TOKEN_RESOLUTION_FAILED.params.token​

readonly token: "string"

TOKEN_RESOLUTION_FAILED.phase​

readonly phase: "pre_send"

TOKEN_RESOLUTION_FAILED.template​

readonly template: "Token {token} could not be looked up; nothing was sent."

TOKEN_SYMBOL_NOT_REGISTERED​

readonly TOKEN_SYMBOL_NOT_REGISTERED: object

TOKEN_SYMBOL_NOT_REGISTERED.params​

readonly params: object

TOKEN_SYMBOL_NOT_REGISTERED.params.token​

readonly token: "string"

TOKEN_SYMBOL_NOT_REGISTERED.phase​

readonly phase: "pre_send"

TOKEN_SYMBOL_NOT_REGISTERED.template​

readonly template: "Token {token} is not registered in the trading-symbol registry yet; pass token0Symbol/token1Symbol (the token class symbol) to propose one. A symbol cannot be derived from a class key."

UNIQUE_KEY_MISMATCH​

readonly UNIQUE_KEY_MISMATCH: object

UNIQUE_KEY_MISMATCH.params​

readonly params: object

UNIQUE_KEY_MISMATCH.phase​

readonly phase: "post_send"

UNIQUE_KEY_MISMATCH.template​

readonly template: "Gateway response data.uniqueKey must match the signed RequestTrade uniqueKey."

UNKNOWN_TOKEN​

readonly UNKNOWN_TOKEN: object

UNKNOWN_TOKEN.params​

readonly params: object

UNKNOWN_TOKEN.params.token​

readonly token: "string"

UNKNOWN_TOKEN.phase​

readonly phase: "pre_send"

UNKNOWN_TOKEN.template​

readonly template: "Token {token} is not registered on the DEX contract: it has no trading symbol."

UNORDERABLE_SYMBOLS​

readonly UNORDERABLE_SYMBOLS: object

UNORDERABLE_SYMBOLS.params​

readonly params: object

UNORDERABLE_SYMBOLS.params.received​

readonly received: "string"

UNORDERABLE_SYMBOLS.phase​

readonly phase: "pre_send"

UNORDERABLE_SYMBOLS.template​

readonly template: "Unable to order trading symbols: expected a pair of symbols, got {received}."

UPDATE_REQUIRED​

readonly UPDATE_REQUIRED: object

UPDATE_REQUIRED.params​

readonly params: object

UPDATE_REQUIRED.params.status​

readonly status: "number"

UPDATE_REQUIRED.phase​

readonly phase: "post_send"

UPDATE_REQUIRED.template​

readonly template: "The backend refused this app version and requires an update (HTTP {status}); nothing was queued."