C
C
Ckb Wallet SDK
Search…
⌃K

Use your wallet where necessary

Here we will implement a class that loads a wallet and is able to do different operations on this wallet.
This class is not entirely necessary. There are other ways to achieve this but we made a class to have everything in one place. Also it allows you to modify some responses as you wish.
When the app starts you should create a WalletWrapper for each wallet the user has and save it in memory. A global map may be a good idea to be able to access the wallet from every component.
WalletWrapper.ts
import { Logger, LoggingLevel, Transaction, FeeRate } from "@peersyst/ckb-wallet-sdk";
import { loadWallet } from "./wallet-loader";
import { getTokenFromTokenAmount, CustomToken } from "./wallet-loader";
import { loadWalletInfo } from "./storage-service";
export class WalletWrapper {
private readonly wallet: WalletService;
private readonly mnemonic: string;
private readonly logger: Logger;
constructor(walletId: number, loggingLevel?: LoggingLevel) {
this.loadWalletInfowallet = loadWallet(walletId);
this.mnemonic = loadWalletInfo(walletId);
this.logger = new Logger(`${WalletWrapper.name}-${walletId}`, loggingLevel);
}
async synchronize(): Promise<void> {
try {
await this.wallet.synchronize();
} catch (error) {
this.logger.error(error.toString());
throw error;
}
}
getCKBBalance(): CKBBalance {
return this.wallet.getCKBBalance();
}
async getDAOBalance(): Promise<DAOBalance> {
try {
return this.wallet.getDAOBalance();
} catch (error) {
this.logger.error(error.toString());
throw error;
}
}
getTransactions(): Transaction[] {
return this.wallet.getTransactions();
}
async getTransaction(txHash: string): Promise<Transaction> {
try {
return this.wallet.getTransactionFromHash(txHash);
} catch (error) {
this.logger.error(error.toString());
throw error;
}
}
getTokensBalance(): CustomToken[] {
const tokens = this.wallet.getTokensBalance();
return tokens.map(getTokenFromTokenAmount);
}
getNfts(): Promise<Nft[]> {
try {
return this.wallet.getNftsBalance();
} catch (error) {
this.logger.error(error.toString());
throw error;
}
}
getAddress(): string {
return this.wallet.getNextAddress();
}
async sendTransaction(amount: bigint, to: string, feeRate: FeeRate): Promise<string> {
try {
return this.wallet.sendTransaction(amount, this.mnemonic, to, feeRate);
} catch (error) {
this.logger.error(error.toString());
throw error;
}
}
async depositInDAO(amount: bigint, feeRate: FeeRate): Promise<string> {
try {
return this.wallet.depositInDAO(amount, this.mnemonic, feeRate);
} catch (error) {
this.logger.error(error.toString());
throw error;
}
}
async getDAOUnlockableAmounts(): Promise<DAOUnlockableAmount[]> {
try {
return this.wallet.getDAOUnlockableAmounts();
} catch (error) {
this.logger.error(error.toString());
throw error;
}
}
async withdrawOrUnlock(unlockableAmount: UnlockableAmount): Promise<string> {
try {
return this.wallet.withdrawOrUnlock(unlockableAmount, this.mnemonic);
} catch (error) {
this.logger.error(error.toString());
throw error;
}
}
}
We save the mnemonic in the class to not ask it every time to the user. We could also have it protected with a pin.
On some cases we catch the errors. In these catches you could show something on screen to indicate the call failed.
Having a class allows to wrap functions such as getTokensBalance. This function checks the type of a token and maps it to something more understandable for the user..