Search…
⌃K

SDK

All any-to-any protocols in one SDK

Via SDK typescript

A small blazing fast wrapper over the Via Router API for on-chain and cross-chain swaps. Our API allows you to find the best route for moving funds between chains!

Feature List

feature
remark
method
get routes
Swaps/bridges cheapest routes
getRoutes
check allowance
Allowance to check whether it's needed or not to approve
getAllowanceStatus
build approval transaction
The transaction that approves the VIA contract to spend your token
buildApprovalTx
build transaction
The transaction that will perform a swap/bridge according to the route
buildTx
check transaction
Check the status of the transaction
checkTx

Installing

npm i @viaprotocol/router-sdk

Usage

First you need to initialize a VIA Client instance:
import {Via} from '@viaprotocol/router-sdk';
const DEFAULT_API_KEY = 'e3db93a3-ae1c-41e5-8229-b8c1ecef5583';
const cli = new Via({apiKey: DEFAULT_API_KEY, url: 'https://router-api.via.exchange', timeout: 30000});
Get the best routes.
const pagesNum = await cli.routesPages(); // cache me!
const baseParams = {
fromChainId: 1,
fromTokenAddress: '0x0000000000000000000000000000000000000000',
fromAmount: Math.pow(10, 18),
toChainId: 56,
toTokenAddress: '0x0000000000000000000000000000000000000000',
fromAddress: '0x856cc59aaE47997a1C8D5472Fc8dfef27821235d', // might be null
multiTx: false, // whether to return routes with multiple user transactions
limit: 1,
};
const params = [...Array(pagesNum)].map(
(_, i) => ({
...baseParams,
offset: i+1
})
);
const routes = await Promise.allSettled(
params.map(i => cli.getRoutes(i))
);
Request parameters description
Parameter
Description
fromChainId
Source chain id
fromTokenAddress
Source token address
fromAmount
Amount
toChainId
Target chain id
toTokenAddress
Target token address
fromAddress
Sender address
multiTx
whether to return routes with multiple user transactions
offset
Pagination offset
limit
Pagination limit
Pagination is needed because the request time for a specific page is faster than for all pages at once
Get allowance status
You must approve the contract to spend your token. You can get route_id from the route you like received above in the code snippet.
const firstNonEmptyPage = routes.find(i => i.value.routes.length > 0).value;
const route = firstNonEmptyPage.routes[0];
const routeId = route.routeId;
const chainId = fromChainId;
const owner = "YOUR_WALLET_ADDRESS";
const tokenAddress = fromTokenAddress;
const numAction = 0; // number of action in routes
const allowanceStatus = await cli.getAllowanceStatus(
{owner, routeId, numAction}
);
Build approval transaction. Returns the transaction that approves the Via API to spend your token.
const amount = fromAmount;
tx = await cli.buildApprovalTx(
{routeId, owner, numAction}
)
Now you can build the transaction that will perform a crosschain swap according to the route.
# amount out minimal, you can get it from get_routes as to_token_amount
output = firstNonEmptyPage.routes[0].toTokenAmount
tx = await cli.buildTx(
{
routeId,
fromAddress,
receiveAddress,
numAction
}
)
If you want to know the status of the transaction, then you need to tell us that you started it
await cli.startRoute(
{
fromAddress: fromAddress,
toAddress: receiveAddress,
routeId: route.routeId,
txHash: txHash
}
)
And start action (you can start from the second action because startRoute also handles first action)
await cli.startAction(
{
actionUuid: route.actions[numAction].uuid,
initialTxHash: actionTxHash
}
)
You can see the status of the transaction.
const txStatus = await cli.checkTx(
{
actionUuid: route.actions[numAction].uuid
}
)
You can use websocket
const v = new Via({apiKey: DEFAULT_API_KEY});
const wsProvider = v.getRoutesViaWs({
fromAddress: '0xD75183E452d6915356814454D2D64Df149853D38',
fromAmount: 148875000000000000,
fromChainId: 56,
toChainId: 56,
fromTokenAddress: '0x0000000000000000000000000000000000000000',
toTokenAddress: '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d',
multiTx: true
});
wsProvider.onopen = function open() {
console.log('connected');
};
wsProvider.onclose = function close() {
console.log('disconnected');
};
wsProvider.onmessage = function incoming(data) {
const res = JSON.parse(data.data as string);
let route: IRoute[];
let status: IRouteFetchStatus;
if (Array.isArray(res)) {
route = res;
console.log(route);
} else {
status = res.status;
console.log(status);
if (status.finished === status.all){
wsProvider.close()
}
}
};
Response parameters description
Parameter
Description
retry
Time to retry in ms
event
Status of the transaction
data.started
Started time of the transaction on source chain
data.finished
Finished time of the transaction on source chain
data.txHash
Hash of the destination transaction
data.actualAmount
Received amount

Multi-tx

With via.exchange it is possible to execute routes in several steps. This will help expand the number of available routes and, as a result, help you find the most profitable routes!
const pagesNum = await cli.routesPages(); // cache me!
const baseParams = {
fromChainId: 1,
fromTokenAddress: '0x0000000000000000000000000000000000000000',
fromAmount: Math.pow(10, 18),
toChainId: 56,
toTokenAddress: '0x0000000000000000000000000000000000000000',
fromAddress: '0x856cc59aaE47997a1C8D5472Fc8dfef27821235d', // might be null
multiTx: true, // !!
limit: 1,
};
const params = [...Array(pagesNum)].map(
(_, i) => ({
...baseParams,
offset: i+1
})
);
const routes = await Promise.allSettled(
params.map(i => cli.getRoutes(i))
);
Now all you need is to sequentially execute transactions for different numAction
const actionCount = firstNonEmptyPage.routes[0].length;
for (let numAction = 0; i < specified_len; i++) {
tx = await cli.buildTx(
{
routeId,
fromAddress,
receiveAddress,
numAction
}
);
}

Fees

Multi signature wallets

Multichain and Hyphen bridges don't support transfers from non-whitelist accounts. Therefore, it is necessary to filter routes with these bridges for users with multi0signature wallets.