​
General / Background

​
How can I get help using Skip Go?

You can reach us easily at our discord or in our developer support channel on Telegram

​
Who uses Skip Go?

Many teams use Skip Go to make it easier for them to build multi-chain flows, including:
  • Every major interchain wallet (Keplr, Leap, IBC wallet, Terra Station, all the metamask snap teams)
  • Osmosis asset deposit page
  • Many major interchain dapps (e.g. Stargaze, Stride, Astroport, Cosmos Millions)
  • Many interchain defi frontends (e.g. Coinhall, fortytwo.money)
  • TrustWallet
  • Our own frontend (https://go.skip.build)
  • …and many more

​
How many chains does Skip Go API support?

More than 70+. We support:
  • Almost every IBC-enabled chain
  • Every EVM chain Axelar supports
  • Every EVM chain and rollup Hyperlane supports
  • Every chain CCTP supports
…with more coming soon!

​
Which bridges and message passing protocols does Skip Go support?

  • IBC
  • Hyperlane
  • Axelar
  • CCTP
  • Neutron’s native bridge
  • Stargate
  • Layerzero
  • Eureka
  • GoFast
…with more coming soon!

​
What DEXes does the Skip Go support?

  • Osmosis
  • Astroport across Terra, Neutron, Sei, and Injective
  • White Whale across Terra, Migaloo, and Chihuahua
  • Uniswap v2/v3
  • Aerodrome
  • Velodrome
  • Tower
  • Elys
  • Dojoswap
…with many more coming soon

​
How do I get Skip Go API to support my chain?

Please see the Chain Support Requirements document to ensure your chain meets the necessary requirements and submit the chain support request form linked in that doc.

​
How do I get the Skip Go API to support my token?

Please complete the necessary steps detailed in the Token & Route Support Requirements doc.

​
How do I get the Skip Go API to support a route for a particular token to a remote chain?

Please complete the necessary steps detailed in the Token & Route Support Requirements doc for the destination chain and token in question.

​
How do I get the Skip Go API to route swaps to my swap venue or DEX?

Please see the Swap Venue Requirements page to ensure your DEX meets the necessary requirements then submit the swap venue request form linked in that doc.

​
How long does it take to build an application with Skip Go?

5-30 minutes

​
Why do I keep getting rate limited?

You need to request an API key from the core team to use Skip Go without limitations. Pass your API key into all requests with the client_id parameter.

​
Does the Skip Go API cost anything?

No, not at this time. We offer unlimited usage at zero cost. In the future we will introduce two pricing plans:
  1. Fee revenue sharing, unlimited usage: For customers who use Skip Go API’s fee functionality to charge their end-users fees on swaps, we will collect a portion of the fee revenue that you earn. Higher volume users will unlock lower fee tiers.
  2. API Usage Pricing: For customers who do not charge fees, we will offer monthly and annual plans that allow usage of the API up to some number of requests per month. We will offer several pricing tiers, where higher tiers support higher rate limits and more monthly requests (similar to coingecko, infura, etc..)

​
I have questions, comments, or concerns about Skip Go. How can I get in touch with you?

Join our Discord and select the “Skip Go Developer” role to share your questions and feedback.

​
Refunds and other financial policies

​
Does Skip ever refund users for swaps or transfers with “bad prices”?

No. Users are responsible for the transactions they sign in all cases:
  1. If our smart contracts behave as expected (i.e. amount_out exceeds min_amount_out signed by the user or amount_in is less than max_amount_in signed), Skip will not offer users refunds, slippage rebates, or any other form of compensation for any reason. Skip does not accept or bare any financial, legal, or practical responsibility for lost funds in the event a user or integrator believes a particular route is inadequate, bad, supoptimal, low liquidity, or otherwise not performant enough.
  2. If the smart contracts Skip Go depends on do not behave as expected, users who encounter and suffer bugs may report them in exchange for a bug bounty payment. See the section on our bug bounty policy below.
Integrators are solely and completely responsible for building UIs that maximally protect users from harming themselves by swapping or transferring at unfavorable prices. To help facilitate this goal, we provide:
  • Detailed information about quote quality, on-chain liquidity, fees, and price estimates in our API response objects (e.g. estimates of the USD value of amount in and amount out, on-chain price impact, etc…)
  • Extensive guidance about how to build S.A.F.E. interfaces in our docs: SAFE Swapping: How to protect users from harming themselves
  • Hands-on interface design feedback based on years of working with dozens of top interfaces

​
Does Skip provide refunds to users if an interface created an transaction that called a Skip contract incorrectly?

No
  1. If an integrator or end user misuses one of our contracts intentionally or by accident (e.g. calls the contract with incorrect call data, sends tokens to a contract not designed to receive tokens), Skip bares no financial, legal, or operational responsibility for funds that may be lost as a result.
  2. Skip and its affiliates do not have the ability to upgrade contracts to receive or “unstick” lost funds even if we wanted to. We do not own or control the contracts in Skip Go any more than you do.

​
Are there any circumstances under which Skip would offer a refund to an end user for any reason?

No Skip accepts no legal, financial, or operational responsibility for the applications the integrators of the Skip Go API create using its data and services. Skip also accepts no legal, financial, or operational responsibility for the positive or negative financial outcomes of the swaps, transfers, and other transactions that end users may create in these interfaces. Even in the event a user lost funds as a result of a bug, Skip does not claim any legal, financial, or practical liability for lost funds. In these cases, users may report the bug to Skip’s bug bounty program.

​
Bug Bounty Policy

​
Does Skip Go offer bug bounties?

Skip may provide a financial bug bounty of up to $25,000 as compensation to users who report a reproducible catastrophic failure of a smart contract or other piece of software that the Skip team developed. Examples of catastrophic failures include:
  • Receiving fewer tokens in the output of a swap than specified and signed over in the min_amount_out field of the transaction calldata
  • Total loss of funds resulting from a transaction where the call data is correctly formed — in other words, where the contract call data matches the specification provided by the Skip team and generated by the Skip Go API product
The size of the bug payment is determined at Skip’s sole discretion. It may depend on a variety of factors, including: quality, accuracy, and timeliness of the report & severity/exploitability of the bug. Skip is not legally obligated to provide any payment amount. In the event a user lost funds as a result of a bug, Skip does not claim any legal, financial, or practical liability for lost funds. The size of the bug bounty will not depend directly or indirectly on the amount of funds the user lost. The bug bounty does not constitute a refund under any definition. It is a reward for identifying and characterizing gross failures in intended behavior of the Skip software.

​
How do I report a bug to the bug bounty program?

Please get in touch with our team on Discord if you believe you have a bug to report.

​
Technical Support

​
Is go.skip.build open source? Where can I find the code?

  • Yes! The code for go.skip.build — our multi-chain DEX aggregator + swapping/transferring interface is open source
  • You can find the code at https://github.com/skip-mev/skip-go-app — Feel free to use it to guide your own integration

​
Where is the OpenAPI Swagger?

You can find the Swagger page here: https://api-swagger.skip.build. And you can find the OpenAPI generating doc here: https://api-swagger.skip.build/swagger.yml.

​
What’s the default IBC-Transfer timeout on the messages returned by /fungible/msgs and /fungible/msgs_direct?

  • 5 minutes

​
What technologies does Skip Go use under the hood?

  • IBC and…
    • ibc-hooks: Enables the Skip Go swap contracts to be executed as callbacks of IBC transfers, which enables constructing transactions that can transfer tokens to a chain with a swap venue, perform a swap, and transfer them out — without multiple signing events / transactions.
      • Skip Go will likely not support DEXes on any chains that do not have ibc-hooks or equivalent functionality
    • Packet-forward-middleware(PFM): Enables incoming IBC transfers from one chain to atomically initiate outgoing transfers to other chains. This allows the chain with PFM to function as the intermediate chain on a multi-hop route. This is especially valuable for chains that issue assets for use throughout the interchain (e.g. Stride + stATOM, Noble + USDC, Axelar + axlUSDC)
    • (This article we wrote goes into more detail about both technologies and how to adopt them on your chain)
  • Axelar: A cross-chain messaging protocol that supports a wide variety of EVM chains and connects to Cosmos
  • CCTP: A cross-chain messaging protocol built by Circle (the issuer of USDC) to move USDC between chains without trusting any parties other than Circle (which USDC users already trust implicitly)
  • Hyperlane: A cross-chain messaging protocol that allows developers to deploy permissionlessly and choose their own security module
  • Go Fast: A decentralized bridging protocol that enables faster-than-finality cross-chain actions across EVM and Cosmos
  • Eureka: IBC v2 that enables seamless interoperability between Cosmos and Ethereum ecosystem
  • Stargate: Support for routing over the Stargate V2 bridge on EVM chains incl. Sei EVM
  • Layerzero: A omnichain messaging protocol that sends data and instructions between different blockchains

​
How do affiliate fees work?

  • Affiliate fees are fees developers using Skip Go charge their end-users on swaps. We support multiple parties taking and sharing fees. For example, if a defi frontend uses the widget a wallet team builds and distributes, the makers of the widget and the users of the widget can separately charge affiliate fees.
  • Fees are calculated in basis points or “bps”. One basis point equals one one-hundredth of a percent. So 100 bps = 1% fee
  • Affiliate fees are calculated based off the minimum amount out and are taken/denominated in the output token. For example, consider an ATOM to OSMO swap where min amount out is 10 uosmo and the cumulative fees are 1000 bps or 10%. If the swap successfully executes, the affiliate fee will be 1 uosmo. It will be 1 uosmo regardless of whether the user actually gets 10, 11, or 12 uosmo out of the swap.
  • When performing a swap with an exact amount in, affiliate fees are accounted for in the amount_out returned by /route. More plainly, the Skip Go API subtracts off expected affiliate fees prior to the amount_out calculation, so that it represents an accurate estimate of what the user will receive at the end of the swap, net of fees. To be exact, the user will probably receive more than the amount out because the actual fee is not known at the time of this calculation / estimate. It’s not known until later when slippage is set. So the user will end up paying slippage_percent*amount_out less than the API predicts. This is good for the user because the estimated amount out will likely be lower than the actual amount they receive, offering a buffer that protects the user from the effects of slippage.

​
Why does /assets_from_source only return assets that are reachable via transfers but not swaps?

We’re considering adding support for swappable destinations to /assets_from_source, but we’re not prioritizing it because almost every asset is reachable via swapping from every other asset. So for 99.99% of use cases, this endpoint would just return a massive amount of fairly uninformative data, if we added destinations reachable via swaps.

​
Why does the Skip Go API sometimes say a route doesn’t exist when it should (e.g. transferring ATOM to Stargaze)?

There are two common reasons Skip Go API is missing a route that a user thinks might exist:
  1. No one has ever used it: By default, the Skip Go API does not recommend channels that have never been used or denoms that it has not seen. For example, if no one has transferred Neutron to Stargaze, the Skip Go API will not recommend a route to do so — even if a direct connection exists between the two chains.
  2. Expired clients: Frequently, existing connections between chains expire when they’re not used for a period of time that exceeds the “light client trusting period. The Skip Go API indexes all chains every couple of hours to identify these cases and prevent users from accidentally attempting transfers.
A common gotcha: /assets_from_source only returns assets reachable in a single transaction by default. If you’d like to have access to routes that require multiple transactions, set the allow_multi_tx flag to true in the input.

​
How long does relaying an IBC packet take?

It depends on many factors, including how many relayers are covering a particular channel, block times, the time-to-finality of the source chain, whether relayers are live, how many packets relayers are waiting to batch together, and much more… In short, it can range from several seconds to minutes (or never) in the worst case. After a timeout window, a packet won’t be valid on the destination chain when it gets relayed. This timeout is set to 5 minutes for all packets created via the Skip Go API. It’s important to understand what happens to user tokens in the event of timeouts. You can read about that in Cross-chain Failure Cases For now, we recommend making a small warning or disclaimer to users on your application, similar to the following:
This swap contains at least one IBC transfer. IBC transfers usually take 10-30 seconds, depending on block times + how quickly relayers ferry packets. But relayers frequently crash or fail to relay packets for hours or days on some chains (especially chains with low IBC volume). At this time, [OUR APPLICATION]does not relay packets itself, so your swap/transfer may hang in an incomplete state. If this happens, your funds are stuck, not lost. They will be returned to you once a relayer comes back online and informs the source chain that the packet has timed out. Timeouts are set to 5 minutes but relayers may take longer to come online and process the timeout.

​
Why is the time to relay a packet so variable? And why can IBC relaying be unreliable today?

IBC relayers do not receive payments for relaying user packets or for relaying light client updates. In fact, they have to pay gas for the every packet they relay. That means relaying is strictly a charitable, money-losing operation with fixed infrastructure costs from running nodes + the relayer process, as well as variable costs from user gas.

​
How long does it take to transfer between Cosmos and EVM ecosystem?

In general, transfers take as long as it takes for the source chain to “finalize”. That means:
  • Transfers originating on EVM chains will take 30 minutes or more. The reason is that most EVM chains take a long time (30+ minutes) to finalize, which means the bridges we rely on do not register the tokens on the source chain as “locked” in the bridge for at least that long.
  • Transfers originating on Cosmos chains will finish in less than 30 seconds usually (barring IBC relayer failures) because Cosmos chains have “fast” or “single slot finality”. Almost as soon as the block that contains your transfer gets created, its included irreversibly in the chain

​
If Skip doesn’t charge fees, how come some simple transfers seem to have a fee taken out of them?

This happens because many of the bridges (which Skip rely on) take fees to pay for gas and the cost of operating their protocol. 
import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";

const txRaw = await signAmino(
	client,
  signer as OfflineAminoSigner,
  msgJSON.sender,
  [
  	{
  		typeUrl: multiHopMsg.msg_type_url,
  		value: msg.value,
  	},
  ],
    {
      amount: [coin(0, feeInfo.denom)],
      gas: `${simulatedGas * 1.2}`,
    },
      "",
        {
        accountNumber: acc?.accountNumber ?? 0,
        sequence: acc?.sequence ?? 0,
        chainId: multiHopMsg.chain_id,
      }
);

const txBytes = TxRaw.encode(txRaw).finish();

tx = await client.broadcastTx(txBytes, undefined, undefined);

​
How should I set gas prices for Cosmos transactions?

We recommend setting Cosmos chain gas prices using the chainapsis keplr-chain-registry: https://github.com/chainapsis/keplr-chain-registry. In our experience, this registry overestimates gas prices somewhat — but this leads to a very good UX in Cosmos because:
  • Transactions almost always make it on chain
  • Gas prices are very cheap — so overestimation is not costly
Soon, the Skip Go API will surface recommended gas price too, and we will release a client-side library that will abstract away this area of concern.

​
How should I set gas amount for Cosmos transactions?

We recommend using the Gas and Fee Tooling available in the Skip Go Client TypeScript Package.

​
What does it mean when the docs say an endpoint is in “ALPHA” or “BETA”?

This means we may make breaking changes to them at any time.

​
What are the Skip Go app environments?

The Skip Go app is available in three environments: mainnet, testnet, and dev. The mainnet/production user facing app runs at https://go.skip.build. It connects to mainnet chains and uses the production API. This is the version that most users interact with. The testnet app runs at https://testnet.go.skip.build. It connects to testnet chains but still uses the production API. This setup is useful when you want to test on testnet without changing API behavior. The dev app runs at https://dev.go.skip.build. It connects to mainnet chains but uses a development version of the API that hasn’t been released to production yet.

​
What does cumulative_fee_bps in /route mean?

This is where you specify the fee amount in bps aka “bips”. (1 bp = 1 / 100th of a percent; 100 bps = 1%) By specifying it in route, the Skip Go API can adjust the quote that it gives back to you, so that it shows output token estimate net of fees. This ensures the amount the end user gets out of the swap always aligns with their expectations. The parameter uses the word “cumulative” (i.e. summing over a set) because the API supports multiple partners charging affiliate fees. This parameter should be set to the sum of all of those component fees. (For example, if a widget provider charges a 5 bp fee, and the frontend developer integrating that widget charges a 10 bp fee, cumulative_fee_bps=15)

​
Misc

​
Is Skip doing anything to make IBC relaying more reliable?

  • In the short term, we are adding real time data about relayer + channel health to Skip Go API, so we can accurately predict how long it will take to relay a packet over a channel + the packet tracking + relaying into the API.
  • In the medium term, we’re going to enable multi-chain relaying through Skip Go API. This will be a paid service.
  • In the long term, we’re working to build better incentives for relaying, so relayers don’t need to run as charities. (Relayers do not receive fees or payment of any kind today and subsidize gas for users cross-chain)