navi-sdk
Version:
The NAVI SDK Client provides tools for interacting with the Sui blockchain networks, designed for handling transactions, accounts, and smart contracts efficiently. This documentation covers the setup, account management, and transaction handling within th
197 lines (174 loc) • 8.9 kB
text/typescript
import { AccountManager } from "./libs/AccountManager";
import { initializeParams, CoinInfo, Pool, PoolConfig, OptionType, SwapOptions, Quote } from "./types";
import { getPoolInfo, getUserRewardHistory } from './libs/PoolInfo';
import * as bip39 from "@scure/bip39";
import { wordlist } from "@scure/bip39/wordlists/english";
import { pool } from "./address";
import { getAvailableRewards } from './libs/PTB';
import { getQuote } from './libs/Aggregator/getQuote';
export class NAVISDKClient {
public account!: AccountManager;
public accounts: AccountManager[] = [];
public mnemonic: string = "";
public networkType: string = "";
/**
* Constructs a new instance of the NAVISDKClient.
*
* @param {Object} params - The initialization parameters.
* @param {string} [params.mnemonic=""] - The mnemonic for account generation. If not provided, a new one will be generated.
* @param {string} params.networkType - The network type to connect to. Defaults to "mainnet" if not specified.
* @param {number} [params.wordLength=12] - The word length for the mnemonic. Can be 12 or 24.
* @param {number} [params.numberOfAccounts=10] - The number of accounts to generate.
* @param {string[]} [params.privateKeyList=[""]] - A list of private keys for account initialization.
*/
constructor({ mnemonic = "", networkType, wordLength = 12, numberOfAccounts = 10, privateKeyList = [""] }: initializeParams = {}) {
this.networkType = networkType || "mainnet";
if (privateKeyList && privateKeyList.length > 0 && privateKeyList[0] !== "") {
// Initialize accounts using provided private keys
this.accounts = privateKeyList.map(privateKey => new AccountManager({ privateKey: privateKey, network: this.networkType }));
} else {
// Generate a new mnemonic if not provided
this.mnemonic = mnemonic !== "" ? mnemonic : bip39.generateMnemonic(wordlist, wordLength === 12 ? 128 : 256);
// Generate accounts using the mnemonic
for (let i = 0; i < numberOfAccounts; i++) {
this.account = new AccountManager({ mnemonic: this.mnemonic, network: this.networkType, accountIndex: i });
this.accounts.push(this.account);
}
}
console.log("Network Type:", this.networkType);
}
/**
* Retrieves all accounts stored in the Navi SDK.
* @returns An array of all accounts.
*/
getAllAccounts() {
this.accounts.forEach((account, index) => {
console.log(`index: ${index}, address: ${account.getPublicKey()}`);
});
return this.accounts;
}
/**
* Retrieves the mnemonic associated with the Navi SDK instance.
* @returns The mnemonic string.
*/
getMnemonic() {
console.log(`mnemonic: ${this.mnemonic}`);
return this.mnemonic;
}
/**
* Retrieves the pool information for a specific coin symbol.
* If no coin symbol is provided, it retrieves the pool information for all coins.
* @param coinType - The data type of the coin for which to retrieve the pool information.
* @returns A Promise that resolves to the pool information.
*/
async getPoolInfo(coinType?: CoinInfo) {
return getPoolInfo(coinType, this.accounts[0].client);
}
/**
* Retrieves the reserve detail for a given asset ID.
* @param coinType - The CoinInfo data type for which to retrieve the reserve detail.
* @returns A Promise that resolves when the reserve detail is retrieved.
*/
async getReserveDetail(coinType: CoinInfo) {
const reserve: PoolConfig = pool[coinType.symbol as keyof Pool];
return this.accounts[0].getReservesDetail(reserve.assetId);
}
/**
* Retrieves the health factor for a given address.
* @param address - The address for which to retrieve the health factor.
* @returns A promise that resolves to the health factor value.
*/
async getHealthFactor(address: string) {
if (this.accounts.length === 0) {
this.account = new AccountManager();
this.accounts.push(this.account);
await this.accounts[0].getHealthFactor(address);
this.accounts.splice(0, 1);
}
return this.accounts[0].getHealthFactor(address);
}
/**
* Retrieves the dynamic health factor for a given address and pool.
* @param address - The address to retrieve the dynamic health factor for.
* @param coinType - The type of the pool.
* @param estimateSupply - The estimated supply value.
* @param estimateBorrow - The estimated borrow value.
* @param isIncrease - A boolean indicating whether the estimated supply or borrow is increasing (default: true).
* @returns A Promise that resolves to the dynamic health factor.
*/
async getDynamicHealthFactor(address: string, coinType: CoinInfo, estimateSupply: number, estimateBorrow: number, isIncrease: boolean = true) {
if (this.accounts.length === 0) {
this.account = new AccountManager();
this.accounts.push(this.account);
await this.accounts[0].getDynamicHealthFactor(address, coinType, estimateSupply, estimateBorrow, isIncrease);
this.accounts.splice(0, 1);
}
return this.accounts[0].getDynamicHealthFactor(address, coinType, estimateSupply, estimateBorrow, isIncrease);
}
/**
* Retrieves all NAVI portfolios for the accounts.
* @returns A promise that resolves to an array of results for each account.
*/
async getAllNaviPortfolios() {
const results = await Promise.all(this.accounts.map(account => account.getNAVIPortfolio(account.address, false)));
const balanceMap = new Map<string, { borrowBalance: number, supplyBalance: number }>();
results.forEach(result => {
result.forEach((value, key) => {
const balance = balanceMap.get(key) || { borrowBalance: 0, supplyBalance: 0 };
balance.borrowBalance += value.borrowBalance;
balance.supplyBalance += value.supplyBalance;
balanceMap.set(key, balance);
});
});
return balanceMap;
}
/**
* Retrieves the balances of all accounts.
* @returns A record containing the balances of each coin.
*/
async getAllBalances() {
const balancePromises = this.accounts.map(account => account.getWalletBalance(false));
const balancesAll = await Promise.all(balancePromises);
const coinBalances: Record<string, number> = {};
balancesAll.forEach(balance => {
Object.entries(balance).forEach(([coin, amount]) => {
coinBalances[coin] = (coinBalances[coin] || 0) + amount;
});
});
return coinBalances;
}
/**
* Checks the available rewards for a given address.
* @param address - The address to check rewards for.
* @param option - The option type for rewards.
* @returns A promise that resolves with the available rewards.
*/
async getAddressAvailableRewards(address: string = this.accounts[0].address, option = [1,]) {
const client = this.accounts[0].client;
return getAvailableRewards(client, address, option, true);
}
/**
* Retrieves the claimed rewards history for a given user address.
* @param userAddress - The address of the user to retrieve the rewards history for. Defaults to the first account's address.
* @param page - The page number to retrieve. Defaults to 1.
* @param size - The number of records per page. Defaults to 400.
* @returns A promise that resolves with the user's claimed rewards history.
*/
async getClaimedRewardsHistory(userAddress: string = this.accounts[0].address, page: number = 1, size: number = 400) {
return getUserRewardHistory(userAddress, page, size);
}
/**
* Retrieves a quote for swapping one coin to another.
* @param fromCoinAddress - The address of the coin to swap from.
* @param toCoinAddress - The address of the coin to swap to.
* @param amountIn - The amount of the fromCoin to swap. Can be a number, string, or bigint.
* @param apiKey - The API key for authentication.
* @param swapOptions - Optional. The options for the swap, including baseUrl, dexList, byAmountIn, and depth.
* @returns A promise that resolves with the quote for the swap.
*/
async getQuote(fromCoinAddress: string, toCoinAddress: string, amountIn: number | string | bigint, apiKey?: string,
swapOptions: SwapOptions = { baseUrl: undefined, dexList: [], byAmountIn: true, depth: 3 },
): Promise<Quote> {
return getQuote(fromCoinAddress, toCoinAddress, amountIn, apiKey, swapOptions);
}
}