2️⃣Set up SDK
After you have installed the SDK, you first need to set it up.
SDK Initiation
After installation, you will need to initialize the SDK.
Set up after CDN installation
const config = {
rpcProviders: {
BSC: {
rpcList: ['https://bsc-dataseed.binance.org/', ...]
},
POLYGON: {
rpcList: ['https://polygon-rpc.com', ...]
},
TRON: {
rpcList: [
{
fullHost: '<tron-api>',
headers: { "TRON-PRO-API-KEY": 'your api key' }
}
]
}
}
};
const rubicSdk = await RubicSDK.SDK.createSDK(config);
Set up after npm installation
In case of npm installation, you have to import SDK
from rubic-sdk
package. Then you can initiate it:
import SDK, { BLOCKCHAIN_NAME, Configuration } from 'rubic-sdk';
const config: Configuration = {
rpcProviders: {
BSC: {
rpcList: ['https://bsc-dataseed.binance.org/', ...]
},
POLYGON: {
rpcList: ['https://polygon-rpc.com', ...]
},
TRON: {
rpcList: [
{
fullHost: '<tron-api>',
headers: { "TRON-PRO-API-KEY": 'your api key' }
}
]
}
}
};
const rubicSDK = await SDK.createSDK(config)
Configuration providing
To create SDK instance you should provide config
parameter, this is an object containing the rpc, wallets, http client settings, and your personal integrator wallet address.
interface Configuration {
readonly rpcProviders: RpcProviders;
readonly walletProvider?: WalletProvider;
readonly httpClient?: HttpClient;
readonly providerAddress?: Partial<ProviderAddress>;
}
Providing RPC options
RpcProviders
is Rpc data to connect to blockchains you will use. You have to pass rpcProvider
for each blockchain you will use with sdk, as presented in example below:
type RpcProviders = Partial<
Record<EvmBlockchainName, RpcProvider<string>> &
Record<TronBlockchainName, RpcProvider<TronWebProvider>> &
Record<SolanaBlockchainName, RpcProvider<string>>
>;
interface RpcProvider<T> {
/**
* Rpc links. Copy it from your rpc provider website
* (like Infura, Quicknode, Getblock, Moralis, etc).
*/
readonly rpcList: T[];
}
Providing wallet options
If at the time when you initiating SDK, users have already logged into your platform, you can provide walletProvider
object, but it is no necessary, until you want to swap with SDK:
type WalletProvider = Partial<{
readonly [CHAIN_TYPE.EVM]?: WalletProviderCore<provider | Web3>;
readonly [CHAIN_TYPE.TRON]?: WalletProviderCore<typeof TronWeb>;
readonly [CHAIN_TYPE.SOLANA]?: WalletProviderCore<SolanaWeb3>;
}>;
interface WalletProviderCore<T> {
/**
* Core provider.
*/
readonly core: T;
/**
* User wallet address.
*/
readonly address: string;
}
If user with address 0xB72DE277A5s577C945B0C52acD8fD2a7cFDaFD18
logged in with Ethereum network, right walletProvider object should be as follows:.
const walletProvider = {
[CHAIN_TYPE.EVM]: {
core: window.ethereum,
address: '0x0123....89'
}
};
Your own client for HTTP requests
You can also pass your own http client as httpClient
parameter (e.g. HttpClient in Angular) if you have it, to not duplicate http clients and decrease bundle size.
Your wallet address as integrator
This is one of the most important steps, please send to the Rubic team the providerAddress
- the wallet address to which the fees will be credited. To make it work properly, you need to contact us so that we can whitelist you.
Update SDK configuration
When user finally connects the walet, you have to notify SDK about it.
const defaultConfig = {
rpcProviders: {
BSC: {
rpcList: ['https://bsc-dataseed.binance.org/', ...]
},
POLYGON: {
rpcList: ['https://polygon-rpc.com', ...]
},
TRON: {
rpcList: [
{
fullHost: '<tron-api>',
headers: { "TRON-PRO-API-KEY": 'your api key' }
}
]
}
}
};
const rubicSDK = await SDK.createSDK(defaultConfig);
const newConfig = {
...defaultConfig,
walletProvider: {
[CHAIN_TYPE.EVM]: {
core: window.ethereum,
address: '0x0123....89'
}
}
};
await rubicSDK.updateConfiguration(newConfig);
You should do it on every address and network change events
SDK object
When SDK was initiated, you are able to refer it's fields and methods.
interface SDK {
/**
* On-chain manager object. Use it to calculate and create on-chain trades.
*/
public readonly onChainManager: OnChainManager;
/**
* Cross-chain trades manager object. Use it to calculate and create cross-chain trades.
*/
public readonly crossChainManager: CrossChainManager;
/**
* On-chain status manager object. Use it for special providers, which requires more than one trade.
*/
public readonly onChainStatusManager: OnChainStatusManager;
/**
* Cross-chain status manager object. Use it to get trade statuses on source and target network.
*/
public readonly crossChainStatusManager: CrossChainStatusManager;
/**
* Cross-chain symbiosis manager object. Use it to get pending trades in symbiosis and revert them.
*/
public readonly crossChainSymbiosisManager: CrossChainSymbiosisManager;
/**
* Deflation token manager object. Use it to check specific token for fees or deflation.
*/
public readonly deflationTokenManager: DeflationTokenManager;
/**
* Use it to create limit order.
*/
public readonly limitOrderManager: LimitOrderManager;
/**
* Can be used to get `Web3Public` instance by blockchain name to get public information from blockchain.
*/
public get web3PublicService(): Web3PublicService {
return Injector.web3PublicService;
}
/**
* Can be used to send transactions and execute smart contracts methods.
*/
public get web3PrivateService(): Web3PrivateService {
return Injector.web3PrivateService;
}
/**
* Use it to get gas price information.
*/
public get gasPriceApi(): GasPriceApi {
return Injector.gasPriceApi;
}
/**
* Use it to get coingecko price information.
*/
public get coingeckoApi(): CoingeckoApi {
return Injector.coingeckoApi;
}
/**
* Updates sdk configuration and sdk entities dependencies.
*/
public async updateConfiguration(configuration: Configuration): Promise<void> {
const [web3PublicService, web3PrivateService, httpClient] = await Promise.all([
SDK.createWeb3PublicService(configuration),
SDK.createWeb3PrivateService(configuration),
SDK.createHttpClient(configuration)
]);
Injector.createInjector(web3PublicService, web3PrivateService, httpClient);
}
public updateWalletProvider(walletProvider: WalletProvider): void {
Injector.web3PrivateService.updateWeb3PrivateStorage(walletProvider);
}
public updateWalletProviderCore(
chainType: keyof WalletProvider,
walletProviderCore: WalletProviderCore
): void {
Injector.web3PrivateService.updateWeb3Private(chainType, walletProviderCore);
}
public updateWalletAddress(chainType: keyof WalletProvider, address: string): void {
Injector.web3PrivateService.updateWeb3PrivateAddress(chainType, address);
}
}
Last updated
Was this helpful?