API Reference
Complete API documentation for @tetherto/wdk-wallet-ton
API Reference
Table of Contents
WalletManagerTon
The main class for managing TON wallets.
Extends WalletManager from @tetherto/wdk-wallet.
Constructor
new WalletManagerTon(seed, config)Parameters:
seed(string | Uint8Array): BIP-39 mnemonic seed phrase or seed bytesconfig(object): Configuration objecttonClient(object | TonClient): TON client configuration or instanceurl(string): TON Center API URL (e.g., 'https://toncenter.com/api/v3')secretKey(string, optional): API key for TON Center
transferMaxFee(number, optional): Maximum fee amount for transfer operations (in nanotons)
Example:
const wallet = new WalletManagerTon(seedPhrase, {
tonClient: {
url: 'https://toncenter.com/api/v3',
secretKey: 'your-api-key'
},
transferMaxFee: 1000000000 // Maximum fee in nanotons (1 TON)
})Methods
getAccount(index)
Returns a wallet account at the specified index
Promise<WalletAccountTon>
getAccountByPath(path)
Returns a wallet account at the specified BIP-44 derivation path
Promise<WalletAccountTon>
getFeeRates()
Returns current fee rates for transactions
Promise<{normal: number, fast: number}>
dispose()
Disposes all wallet accounts, clearing private keys from memory
void
getAccount(index)
Returns a wallet account at the specified index.
Parameters:
index(number, optional): The index of the account to get (default: 0)
Returns: Promise<WalletAccountTon> - The wallet account
Example:
const account = await wallet.getAccount(0)getAccountByPath(path)
Returns a wallet account at the specified BIP-44 derivation path.
Parameters:
path(string): The derivation path (e.g., "0'/0/0")
Returns: Promise<WalletAccountTon> - The wallet account
Example:
const account = await wallet.getAccountByPath("0'/0/1")getFeeRates()
Returns current fee rates for normal and fast transactions.
Returns: Promise<FeeRates> - Object containing normal and fast fee rates
Example:
const feeRates = await wallet.getFeeRates()
console.log('Normal fee rate:', feeRates.normal, 'nanotons')
console.log('Fast fee rate:', feeRates.fast, 'nanotons')dispose()
Disposes all wallet accounts, clearing private keys from memory.
Example:
wallet.dispose()Properties
seed
The wallet's seed phrase.
Type: string | Uint8Array
Example:
console.log('Seed phrase:', wallet.seed)WalletAccountTon
Individual TON wallet account implementation. Extends WalletAccountReadOnlyTon and implements IWalletAccount.
Constructor
new WalletAccountTon(seed, path, config)Parameters:
seed(string | Uint8Array): BIP-39 mnemonic seed phrase or seed bytespath(string): BIP-44 derivation path (e.g., "0'/0/0")config(object): Configuration objecttonClient(object | TonClient): TON client configuration or instanceurl(string): TON Center API URLsecretKey(string, optional): API key for TON Center
transferMaxFee(number, optional): Maximum fee amount for transfer operations
Example:
const account = new WalletAccountTon(seedPhrase, "0'/0/0", {
tonClient: {
url: 'https://toncenter.com/api/v3',
secretKey: 'your-api-key'
},
transferMaxFee: 10000000 // Maximum fee in nanotons (e.g., 0.01 TON)
})Methods
getAddress()
Returns the account's TON address
Promise<string>
sign(message)
Signs a message using the account's private key
Promise<string>
verify(message, signature)
Verifies a message signature
Promise<boolean>
sendTransaction(tx)
Sends a TON transaction
Promise<{hash: string, fee: number}>
quoteSendTransaction(tx)
Estimates the fee for a TON transaction
Promise<{fee: number}>
transfer(options)
Transfers Jetton tokens to another address
Promise<{hash: string, fee: number}>
quoteTransfer(options)
Estimates the fee for a Jetton transfer
Promise<{fee: number}>
getBalance()
Returns the native TON balance (in nanotons)
Promise<number>
getTokenBalance(tokenAddress)
Returns the balance of a specific Jetton token
Promise<number>
dispose()
Disposes the wallet account, clearing private keys from memory
void
getAddress()
Returns the account's address.
Returns: Promise<string> - The account's TON address
Example:
const address = await account.getAddress()
console.log('Account address:', address)sign(message)
Signs a message using the account's private key.
Parameters:
message(string): The message to sign
Returns: Promise<string> - The message signature
Example:
const signature = await account.sign('Hello, World!')
console.log('Signature:', signature)verify(message, signature)
Verifies a message signature.
Parameters:
message(string): The original messagesignature(string): The signature to verify
Returns: Promise<boolean> - True if the signature is valid
Example:
const isValid = await account.verify('Hello, World!', signature)
console.log('Signature valid:', isValid)sendTransaction(tx)
Sends a TON transaction and returns the result with hash and fee.
Parameters:
tx(object): The transaction objectto(string): Recipient TON address (e.g., 'EQ...')value(number): Amount in nanotons (1 TON = 1,000,000,000 nanotons)bounceable(boolean, optional): Whether the address is bounceable (TON-specific, optional)
Returns: Promise<{hash: string, fee: number}> - Object containing hash and fee (in nanotons)
Example:
const result = await account.sendTransaction({
to: 'EQ...', // TON address
value: 1000000000 // 1 TON in nanotons
});
console.log('Transaction hash:', result.hash);
console.log('Transaction fee:', result.fee, 'nanotons');quoteSendTransaction(tx)
Estimates the fee for a transaction.
Parameters:
tx(object): The transaction object (same as sendTransaction)to(string): Recipient TON address (e.g., 'EQ...')value(number): Amount in nanotons (1 TON = 1,000,000,000 nanotons)bounceable(boolean, optional): Whether the address is bounceable (TON-specific, optional)
Returns: Promise<{fee: number}> - Object containing fee estimate (in nanotons)
Example:
const quote = await account.quoteSendTransaction({
to: 'EQ...', // TON address
value: 1000000000 // 1 TON in nanotons
});
console.log('Estimated fee:', quote.fee, 'nanotons');transfer(options)
Transfers Jettons (TON tokens) to another address.
Parameters:
options(object): Transfer optionstoken(string): Jetton master contract address (TON format, e.g., 'EQ...')recipient(string): Recipient TON address (e.g., 'EQ...')amount(number): Amount in Jetton's base units
Returns: Promise<{hash: string, fee: number}> - Object containing hash and fee (in nanotons)
Example:
const result = await account.transfer({
token: 'EQ...', // Jetton master contract address
recipient: 'EQ...', // Recipient's TON address
amount: 1000000000 // Amount in Jetton's base units
});
console.log('Transfer hash:', result.hash);
console.log('Transfer fee:', result.fee, 'nanotons');quoteTransfer(options)
Estimates the fee for a Jetton (TON token) transfer.
Parameters:
options(object): Transfer options (same as transfer)token(string): Jetton master contract address (TON format, e.g., 'EQ...')recipient(string): Recipient TON address (e.g., 'EQ...')amount(number): Amount in Jetton's base units
Returns: Promise<{fee: number}> - Object containing fee estimate (in nanotons)
Example:
const quote = await account.quoteTransfer({
token: 'EQ...', // Jetton master contract address
recipient: 'EQ...', // Recipient's TON address
amount: 1000000000 // Amount in Jetton's base units
});
console.log('Transfer fee estimate:', quote.fee, 'nanotons');getBalance()
Returns the native TON balance (in nanotons).
Returns: Promise<number> - Balance in nanotons
Example:
const balance = await account.getBalance();
console.log('Balance:', balance, 'nanotons');getTokenBalance(tokenAddress)
Returns the balance of a specific Jetton (TON token).
Parameters:
tokenAddress(string): The Jetton master contract address (TON format, e.g., 'EQ...')
Returns: Promise<number> - Token balance in base units
Example:
const tokenBalance = await account.getTokenBalance('EQ...');
console.log('Token balance:', tokenBalance, 'nanotons');dispose()
Disposes the wallet account, clearing private keys from memory.
Example:
account.dispose()Properties
index
number
The derivation path's index of this account
path
string
The full derivation path of this account
keyPair
{publicKey: Buffer, privateKey: Buffer}
The account's public and private key pair as buffers
Example:
const { publicKey, privateKey } = account.keyPair
console.log('Public key length:', publicKey.length)
console.log('Private key length:', privateKey.length)Types
TonTransaction
interface TonTransaction {
/**
* Recipient's TON address in base64 format
* @example 'EQD4FPq...'
*/
to: string;
/**
* Amount to send in nanotons (1 TON = 1,000,000,000 nanotons)
* @example 1000000000 // 1 TON
*/
value: number;
/**
* Whether the destination address is bounceable
* @default true
*/
bounceable?: boolean;
/**
* Optional message payload
*/
payload?: string;
/**
* Optional contract initialization state
*/
stateInit?: Cell | null;
}TransferOptions
interface TransferOptions {
/**
* Jetton master contract address
* @example 'EQD4FPq...'
*/
token: string;
/**
* Recipient's TON address
* @example 'EQD4FPq...'
*/
recipient: string;
/**
* Amount in Jetton's base units
* @example 1000000000 // Amount depends on token decimals
*/
amount: number;
}TransactionResult
interface TransactionResult {
/**
* Transaction hash in base64 format
* @example 'EQD4FPq...'
*/
hash: string;
/**
* Transaction fee in nanotons
* @example 100000 // 0.0001 TON
*/
fee: number;
}FeeRates
interface FeeRates {
/**
* Fee rate for normal priority transactions (in nanotons)
* @example 100000000 // 0.1 TON
*/
normal: number;
/**
* Fee rate for high priority transactions (in nanotons)
* @example 200000000 // 0.2 TON
*/
fast: number;
}KeyPair
interface KeyPair {
/**
* Ed25519 public key
*/
publicKey: Buffer;
/**
* Ed25519 private key (sensitive data)
* @security Never expose or log this value
*/
privateKey: Buffer;
}TonWalletConfig
interface TonWalletConfig {
/**
* TON Center client configuration
*/
tonClient?: {
/**
* TON Center API endpoint
* @example 'https://toncenter.com/api/v3'
*/
url: string;
/**
* Optional API key for higher rate limits
*/
secretKey?: string;
};
/**
* Maximum allowed fee for transfers (in nanotons)
* @example 1000000000 // 1 TON
*/
transferMaxFee?: number;
}