Getting Started

Install the library using npm or yarn:

npm install @skip-go/client

  yarn add viem @solana/web3.js

To start integrating with the Skip Go API, initialize a SkipClient instance. This skipClient provides helper methods for common actions such as querying assets and chains, constructing routes, and executing transactions.

import { SkipClient } from "@skip-go/client";

const skipClient = new SkipClient({
  // Signers will be set up in the following section
});

The SkipClient constructor accepts an optional configuration object of type SkipClientOptions. Here’s a brief overview:

• apiURL?: string: Override the default API URL
• endpointOptions?: EndpointOptions: Provide RPC and REST endpoints for specific chains
• aminoTypes?: AminoConverters: Additional amino types to be for message encoding
• registryTypes?: Iterable<[string, GeneratedType]>: Additional registry types

To execute transactions, you need to set up signers for the ecosystems you plan to interact with. Below are examples for Cosmos SDK, EVM, and Solana (SVM). Note that for EVM and SVM, you’ll need to install additional libraries.

​

Signer Setup

// For Cosmos transactions, we'll use Keplr wallet from the window object
const getCosmosSigner = async (chainID: string) => {
  const key = await window.keplr?.getKey(chainID);
  if (!key) throw new Error("Keplr not installed or chain not added");

  return key.isNanoLedger
        ? window.keplr?.getOfflineSignerOnlyAmino(chainID)
        : window.keplr?.getOfflineSigner(chainID);
};

​

Finalizing the Client Initialization

Now, pass the signers and your optional configuration options into your SkipClient instance:

const skipClient = new SkipClient({
  getCosmosSigner,
  getEVMSigner,
  getSVMSigner,
  // ...configOptions,
});

With your client initialized, you can query balances, supported chains and assets.

// returns a Chain[] of all supported Cosmos mainnet chains
const cosmosChains = await skipClient.chains();

// include EVM and SVM chains
const allChains = await skipClient.chains({
  includeEVM: true,
  includeSVM: true,
});

// only show testnet chains
const testnetChains = await skipClient.chains({
  onlyTestnets: true
});

Once you’ve selected your source and destination chains and tokens, you can generate a route and get a quote. See it in context here.

const route = await skipClient.route({
  amountIn: "1000000", // Desired amount in smallest denomination (e.g., uatom)
  sourceAssetDenom: "uatom",
  sourceAssetChainID: "cosmoshub-4",
  destAssetDenom: "uosmo",
  destAssetChainID: "osmosis-1",
  cumulativeAffiliateFeeBPS: '0',
});

After generating a route, you need to provide user addresses for the required chains. The route.requiredChainAddresses array lists the chain IDs for which addresses are needed.

We recommend storing the user’s addresses and creating a function like getAddress that retrieves the address based on the chain ID.

// get user addresses for each requiredChainAddress to execute the route
  const userAddresses = await Promise.all(
  route.requiredChainAddresses.map(async (chainID) => ({
    chainID,
    address: await getAddress(chainID),
  }))
);

Once you have a route, you can execute it in a single function call by passing in the route, the user addresses for at least the chains the route includes, and optional callback functions. This also registers the transaction for tracking.

await skipClient.executeRoute({
  route,
  userAddresses,
  // Executes after all of the operations triggered by a user's signature complete.
  // For multi-tx routes that require multiple user signatures, this will be called once for each tx in sequence
  onTransactionCompleted: async (chainID, txHash, status) => {
    console.log(
      `Route completed with tx hash: ${txHash} & status: ${status.state}`
    );
  },
  // called after the transaction that the user signs gets broadcast on chain
  onTransactionBroadcast: async ({ txHash, chainID }) => {
    console.log(`Transaction broadcasted with tx hash: ${txHash}`);
  },
  // called after the transaction that the user signs is successfully registered for tracking
  onTransactionTracked: async ({ txHash, chainID }) => {
    console.log(`Transaction tracked with tx hash: ${txHash}`);
  },
  // called after the user signs a transaction
  onTransactionSigned: async ({ chainID }) => {
    console.log(`Transaction signed with chain ID: ${chainID}`);
  },
  // validate gas balance on each chain
  onValidateGasBalance: async ({ chainID, txIndex, status }) => {
    console.log(`Validating gas balance for chain ${chainID}...`);
  },
});

For routes that consist of multiple transactions, this will monitor each transaction until it completes, then generate the transaction for the next step and prompt the user to sign it.

Once the user has signed a transaction to execute a cross-chain action, you can track it with:

• skipClient.trackTransaction: Requests tracking for a transaction that’s already been submitted to the network through an RPC, using the transaction hash
• skipClient.submitTransaction: Publishes the signed transaction to the network & begins tracking the cross-chain actions this transaction produces

After you’ve used one of these two functions to kick-off realtime tracking for a cross-chain action, you can request the current status of the transaction using skipClient.transactionStatus.

We also provide a waitForTransaction helper function that hangs until the entire cross-chain action flow has completed, which you can use instead of configuring your own polling via transactionStatus.