Swapping

This tutorial will walk you through Astroport's swap functionality using CosmJS.

Setup

Step 1: Import Necessary Libraries

Import the required libraries to connect to the chain and perform transactions.

import { SigningCosmWasmClient } from "@cosmjs/cosmwasm-stargate";
import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
import { GasPrice } from "@cosmjs/stargate";

Step 2: Define Constants

Specify the required constants, such as the RPC URL, mnemonic, and factory contract address.

NOTE

This tutorial includes the mnemonic directly in the code for quick setup. While convenient for testing, this exposes a sensitive piece of information and is not secure for production use. Always follow secure key management practices and never expose the mnemonic in real-world scenarios.

const rpc = '<rpc-url>'
const mnemonic = ''
const pairContractAddress = 'neutron...'

Step 3: Create a Wallet

Create a wallet using the mnemonic for the specific chain prefix.

const wallet = await DirectSecp256k1HdWallet.fromMnemonic(
    mnemonic, { 
        prefix: "neutron" // neutron, or terra
    });

Step 4: Retrieve Wallet Address

Get the wallet address from the wallet.

const firstAccount = await wallet.getAccounts();
const walletAddress = firstAccount[0].address

Step 5: Set Up the Signing Client

Configure the signing client for connecting to the chain.

const signingClient = await SigningCosmWasmClient.connectWithSigner(
    rpc, 
    wallet, 
    { gasPrice: GasPrice.fromString("0.0053untrn") }
)

Step 6: Wrap Code Inside an Async Function with Error Handling

Wrap the code inside a start() function, marked as async, to handle the asynchronous operations throughout the code. Also, include a try/catch block for robust error handling. This structure enables the use of await with async functions and ensures proper management of any errors that may occur.

const start = async () => {
    try {
        // Place all the code inside this try block
        // ...
    } catch (error) {
        console.error('An error occurred:', error);
    }
}
start();

Swap

Astroport implements the same smart contracts API for swapping across its various pool types (xyk, stable, pcl). The swap function performs a direct swap between two assets in a liquidity pool.

Step 1: Define the Swap Message

Create the swap message with asset details.

const swapMsg = {
    "swap": {
        "offer_asset": {
            "info": {
                "token": {
                    "contract_addr": "..."
                }
            }, 
            "amount": "10000000"
        }, 
        "ask_asset_info": {
            "native_token": {
                "denom": "..."
            }
        },
        "belief_price": beliefPrice, 
        "max_spread": "0.1",
        "to": "...."
    }
};

Params	Type	Description
[`offer_asset`]	`Asset`	Offer asset
[`ask_asset_info`]	`Option<AssetInfo>`	Information about an asset stored in a [`AssetInfo`] struct
[`belief_price`]	`Option<Decimal>`	Belief price
[`max_spread`]	`Option<Decimal>`	The difference between the ask amount before and after the swap operation. If the swap spread exceeds the provided max limit, the swap will fail. If `belief_price` is provided in combination with `max_spread`, the pool will check the difference between the return amount (using `belief_price`) and the real pool price.
[`to`]	`Option<String>`	Address receiving tokens (if different from sender)

`Asset`

This enum contains asset info and a token amount.

json

asset.rs

{
    "info": {
        "token": {
            "contract_addr": "..."
        }
    }, 
    "amount": "100000"
}

Params	Type	Description
`info`	`AssetInfo`	Information about an asset stored in a [`AssetInfo`] struct
`amount`	`Uint128`	A token amount

`AssetInfo`

AssetInfo is a convenience wrapper to represent whether a token is the native one (from a specific chain, like LUNA for Terra) or not. It also returns the contract address of that token.

asset.rs

pub enum AssetInfo {
    Token { contract_addr: Addr },
    NativeToken { denom: String },
}

Variants	Description
`Token`	Non-native Token
`NativeToken`	Native token

`Simulation` Enpoint

Astroport's native solution for calculating the belief_price is the simulation query.

The query takes in an offer_asset which contains information about the native token and an amount to send.

const simulationQuery = await client.queryContractSmart(
    pairContract,
    {
        "simulation": {
            "offer_asset": {
            "info": {
                "native_token": {
                "denom": "uluna"
                }
            },
            "amount": "100000"
            }
        }
    }
);
console.log(simulationQuery);

Depending on the token decimal for the assets you are swapping, you may need to normalize the response from the simulation query before passing it into your swap message.

beliefPrice = String(beliefPrice * 1000000);

Step 2: Execute Swap

Execute the swap transaction.

const executeSwap = await signingClient.execute(
    walletAddress,
    pairContractAddress,
    swapMsg,
    "auto", // fee
    "" // memo
);
console.log(JSON.stringify(executeSwap));

Swapping

Setup​

Step 1: Import Necessary Libraries​

Step 2: Define Constants​

Step 3: Create a Wallet​

Step 4: Retrieve Wallet Address​

Step 5: Set Up the Signing Client​

Step 6: Wrap Code Inside an Async Function with Error Handling​

Swap​

Step 1: Define the Swap Message​

Asset​

AssetInfo​

Simulation Enpoint​

Step 2: Execute Swap​