@deserialize/multi-vm-wallet 1.5.35 → 1.6.1

package/dist/utils.js

@@ -1,9 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPrivateKeyFromAnother = void 0;
+exports.getAddressPortfolioValue = exports.detectVmTypeFromAddress = exports.getPrivateKeyFromAnother = void 0;
 const evm_1 = require("./evm");
 const svm_1 = require("./svm");
 const sha2_1 = require("@noble/hashes/sha2");
+const web3_js_1 = require("@solana/web3.js");
+const utils_1 = require("./evm/utils");
+const utils_2 = require("./svm/utils");
+const bn_js_1 = __importDefault(require("bn.js"));
+const price_1 = require("./price");
 const getPrivateKeyFromAnother = (privateKey, fromVm, toVm) => {
     if (fromVm === "EVM") {
         if (toVm === "SVM") {
@@ -20,3 +28,193 @@ const getPrivateKeyFromAnother = (privateKey, fromVm, toVm) => {
     }
 };
 exports.getPrivateKeyFromAnother = getPrivateKeyFromAnother;
+const EVM_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+const detectVmTypeFromAddress = (address) => {
+    if (EVM_ADDRESS_REGEX.test(address)) {
+        return "EVM";
+    }
+    try {
+        new web3_js_1.PublicKey(address);
+        return "SVM";
+    }
+    catch {
+        throw new Error(`Could not infer VM type from address: ${address}`);
+    }
+};
+exports.detectVmTypeFromAddress = detectVmTypeFromAddress;
+const normalizePriceMap = (prices) => {
+    const priceMap = new Map();
+    for (const item of prices) {
+        if (!item?.tokenAddress || typeof item.price !== "number")
+            continue;
+        priceMap.set(item.tokenAddress.toLowerCase(), item.price);
+    }
+    return priceMap;
+};
+const enrichWithUsdValues = (items, priceMap) => {
+    return items.map((item) => {
+        const key = String(item.tokenAddress).toLowerCase();
+        const priceUsd = priceMap.get(key) ?? null;
+        const valueUsd = priceUsd === null ? null : item.balanceFormatted * priceUsd;
+        return {
+            ...item,
+            priceUsd,
+            valueUsd,
+        };
+    });
+};
+const buildTotals = (items) => {
+    let valueUsd = 0;
+    let pricedItems = 0;
+    let unpricedItems = 0;
+    for (const item of items) {
+        if (item.valueUsd === null) {
+            unpricedItems += 1;
+            continue;
+        }
+        pricedItems += 1;
+        valueUsd += item.valueUsd;
+    }
+    return { valueUsd, pricedItems, unpricedItems };
+};
+const getAddressPortfolioValue = async (params) => {
+    const { chain, address, includeNative = true, tokenAddresses } = params;
+    const vmType = params.vmType ?? (0, exports.detectVmTypeFromAddress)(address);
+    if (vmType === "EVM" && !EVM_ADDRESS_REGEX.test(address)) {
+        throw new Error(`Invalid EVM address: ${address}`);
+    }
+    if (vmType === "SVM") {
+        new web3_js_1.PublicKey(address);
+    }
+    if (vmType === "EVM") {
+        const client = (0, utils_1.createPublicClientFromChainConfig)(chain);
+        const items = [];
+        const priceTargets = new Set();
+        if (includeNative) {
+            const nativeBalance = await (0, utils_1.getNativeBalance)(address, client);
+            const nativeRaw = nativeBalance.balance.toString();
+            items.push({
+                tokenAddress: "native",
+                symbol: chain.nativeToken.symbol,
+                decimals: chain.nativeToken.decimals,
+                balanceRaw: nativeRaw,
+                balanceFormatted: nativeBalance.formatted,
+            });
+            priceTargets.add("native");
+        }
+        if (tokenAddresses && tokenAddresses.length > 0) {
+            const tokenResults = await Promise.all(tokenAddresses.map(async (tokenAddress) => {
+                const balance = await (0, utils_1.getTokenBalance)(tokenAddress, address, client);
+                const raw = balance.balance.toString();
+                return {
+                    tokenAddress,
+                    symbol: tokenAddress,
+                    decimals: balance.decimal,
+                    balanceRaw: raw,
+                    balanceFormatted: balance.formatted,
+                };
+            }));
+            for (const token of tokenResults) {
+                items.push(token);
+                priceTargets.add(token.tokenAddress);
+            }
+        }
+        else {
+            const discovered = await (0, utils_1.discoverTokens)(address, chain);
+            for (const token of discovered) {
+                const raw = String(token.balance);
+                const decimals = token.decimals ?? 0;
+                const rawBn = new bn_js_1.default(raw);
+                const divisor = Math.pow(10, decimals);
+                const formatted = divisor === 0 ? 0 : Number(rawBn.toString()) / divisor;
+                items.push({
+                    tokenAddress: token.address,
+                    symbol: token.symbol,
+                    decimals,
+                    balanceRaw: raw,
+                    balanceFormatted: formatted,
+                });
+                priceTargets.add(token.address);
+            }
+        }
+        const priceResult = await (0, price_1.fetchPrices)({
+            vm: "EVM",
+            chainId: chain.chainId,
+            tokenAddresses: Array.from(priceTargets),
+        });
+        const priceMap = normalizePriceMap(priceResult.data?.prices ?? []);
+        const enrichedItems = enrichWithUsdValues(items, priceMap);
+        return {
+            address,
+            vmType,
+            chainId: chain.chainId,
+            items: enrichedItems,
+            totals: buildTotals(enrichedItems),
+        };
+    }
+    const svmAddress = new web3_js_1.PublicKey(address);
+    const connection = new web3_js_1.Connection(chain.rpcUrl);
+    const items = [];
+    const priceTargets = new Set();
+    if (includeNative) {
+        const nativeBalance = await (0, utils_2.getSvmNativeBalance)(svmAddress, connection);
+        items.push({
+            tokenAddress: "native",
+            symbol: chain.nativeToken.symbol,
+            decimals: chain.nativeToken.decimals,
+            balanceRaw: nativeBalance.balance.toString(),
+            balanceFormatted: nativeBalance.formatted,
+        });
+        priceTargets.add("native");
+    }
+    if (tokenAddresses && tokenAddresses.length > 0) {
+        const tokenResults = await Promise.all(tokenAddresses.map(async (tokenAddress) => {
+            const pubkey = new web3_js_1.PublicKey(tokenAddress);
+            const tokenBalance = await svm_1.SVMVM.getTokenBalance(svmAddress, pubkey, connection);
+            return {
+                tokenAddress,
+                symbol: tokenAddress,
+                decimals: tokenBalance.decimal,
+                balanceRaw: tokenBalance.balance.toString(),
+                balanceFormatted: tokenBalance.formatted,
+            };
+        }));
+        for (const token of tokenResults) {
+            items.push(token);
+            priceTargets.add(token.tokenAddress);
+        }
+    }
+    else {
+        const discovered = await (0, utils_2.discoverTokens)(svmAddress, connection);
+        for (const token of discovered) {
+            const raw = String(token.balance);
+            const decimals = token.decimals ?? 0;
+            const rawBn = new bn_js_1.default(raw);
+            const divisor = Math.pow(10, decimals);
+            const formatted = divisor === 0 ? 0 : Number(rawBn.toString()) / divisor;
+            items.push({
+                tokenAddress: token.address,
+                symbol: token.symbol,
+                decimals,
+                balanceRaw: raw,
+                balanceFormatted: formatted,
+            });
+            priceTargets.add(token.address);
+        }
+    }
+    const priceResult = await (0, price_1.fetchPrices)({
+        vm: "SVM",
+        chainId: chain.chainId,
+        tokenAddresses: Array.from(priceTargets),
+    });
+    const priceMap = normalizePriceMap(priceResult.data?.prices ?? []);
+    const enrichedItems = enrichWithUsdValues(items, priceMap);
+    return {
+        address,
+        vmType,
+        chainId: chain.chainId,
+        items: enrichedItems,
+        totals: buildTotals(enrichedItems),
+    };
+};
+exports.getAddressPortfolioValue = getAddressPortfolioValue;

package/dist/walletBip32.js

@@ -87,7 +87,7 @@ function GenerateSeed(_mnemonic) {
 function EVMDeriveChildPrivateKey(seed, index, derivationPath) {
     vm_validation_1.VMValidation.validateSeed(seed);
     vm_validation_1.VMValidation.validateIndex(index, 'Wallet index');
-    const path = `${derivationPath}${index}'`;
+    const path = derivationPath.endsWith("/") ? `${derivationPath}${index}` : derivationPath;
     const scureNode = bip32_1.HDKey.fromMasterSeed(buffer_1.Buffer.from(seed, "hex"));
     const child = scureNode.derive(path);
     if (!child.privateKey) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deserialize/multi-vm-wallet",
-  "version": "1.5.35",
+  "version": "1.6.1",
   "devDependencies": {
     "@types/bn.js": "^5.2.0",
     "@types/crypto-js": "^4.2.2",

package/utils/constant.ts

@@ -15,7 +15,21 @@ export const DefaultChains: ChainWalletConfig[] = [{
     logoUrl: "https://solana.com/src/img/branding/solanaLogoMark.svg",
     vmType: "SVM",
     savings: {
-        tokens: []
+        supported: true,
+        tokens: [
+            {
+                name: "USDC",
+                symbol: "USDC",
+                decimals: 6,
+                address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+            },
+            {
+                name: "USDT",
+                symbol: "USDT",
+                decimals: 6,
+                address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
+            }
+        ]
     }
 }
 
@@ -34,6 +48,7 @@ export const DefaultChains: ChainWalletConfig[] = [{
     logoUrl: "https://push.org/assets/website/favicons/favicon.svg",
     vmType: "EVM",
     savings: {
+        supported: false,
         tokens: []
     }
 }
@@ -53,7 +68,24 @@ export const DefaultChains: ChainWalletConfig[] = [{
     },
     testnet: false,
     logoUrl: "https://etherscan.io/images/svg/brands/ethereum-original-light.svg",
-    vmType: "EVM"
+    vmType: "EVM",
+    savings: {
+        supported: true,
+        tokens: [{
+            name: "USDC",
+            symbol: "USDC",
+            decimals: 6,
+            address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+        },
+        {
+            name: "USDT",
+            symbol: "USDT",
+            decimals: 6,
+            address: "0xdac17f958d2ee523a2206206994597c13d831ec7"
+        }
+
+        ]
+    }
 }, {
     chainId: 56,
     name: "BSC",
@@ -68,7 +100,18 @@ export const DefaultChains: ChainWalletConfig[] = [{
     logoUrl: "https://bscscan.com/assets/bsc/images/svg/logos/token-light.svg?v=25.10.5.0",
     vmType: "EVM",
     savings: {
-        tokens: []
+        supported: true,
+        tokens: [
+
+            {
+                name: "BUSD",
+                symbol: "BUSD",
+                decimals: 6,
+                address: "0x55d398326f99059fF775485246999027B3197955"
+            }
+
+
+        ]
     }
 },
 
@@ -101,7 +144,15 @@ export const DefaultChains: ChainWalletConfig[] = [{
     logoUrl: "https://avatars.githubusercontent.com/u/108554348?s=200&v=4",
     vmType: "EVM",
     savings: {
-        tokens: []
+        supported: true,
+        tokens: [
+            {
+                name: "USDC",
+                symbol: "USDC",
+                decimals: 6,
+                address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+            }
+        ]
     }
 },
 
@@ -119,6 +170,7 @@ export const DefaultChains: ChainWalletConfig[] = [{
     logoUrl: "https://avatars.githubusercontent.com/u/119917794?s=280&v=4",
     vmType: "EVM",
     savings: {
+        supported: false,
         tokens: []
     }
 },
@@ -136,6 +188,7 @@ export const DefaultChains: ChainWalletConfig[] = [{
     logoUrl: "https://avatars.githubusercontent.com/u/58791460?s=280&v=4",
     vmType: "EVM",
     savings: {
+        supported: false,
         tokens: []
     }
 },
@@ -155,6 +208,7 @@ export const DefaultChains: ChainWalletConfig[] = [{
     logoUrl: "https://polygonscan.com/images/svg/brands/polygon-light.svg?v=0.0.36",
     vmType: "EVM",
     savings: {
+        supported: false,
         tokens: []
     }
 }

package/utils/evm/evm.ts

@@ -806,7 +806,7 @@ export class EVMVM extends VM<string, string, PublicClient> {
             try {
                 // Pocket derivation: m/44'/60'/{accountIndex+1}'/0/{walletIndex}
                 const pocketIndex = accountIndex + 1;
-                const derivationPath = `m/44'/60'/${pocketIndex}'/0/${walletIndex}'`;
+                const derivationPath = `m/44'/60'/${pocketIndex}'/0/${walletIndex}`;
 
                 // Derive pocket
                 const { privateKey } = EVMDeriveChildPrivateKey(this.seed, walletIndex, `m/44'/60'/${pocketIndex}'/0/`);

package/utils/savings/evm-savings.ts

@@ -119,9 +119,10 @@ export class EVMSavingsManager extends SavingsManager<Hex, PublicClient, WalletC
 
         // Add 1 to preserve index 0 for main wallet
         const pocketIndex = accountIndex + 1;
-        const derivationPath = `${this.derivationPathBase}${pocketIndex}'/0/${this.walletIndex}`;
+        const derivationPathBase = `${this.derivationPathBase}${pocketIndex}'/0/`;
+        const derivationPath = `${derivationPathBase}${this.walletIndex}'`;
         const seed = mnemonicToSeed(this.mnemonic);
-        const { privateKey } = EVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPath);
+        const { privateKey } = EVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPathBase);
         const wallet = new ethers.Wallet(privateKey);
 
         const pocket: Pocket<Hex> = {
@@ -142,9 +143,10 @@ export class EVMSavingsManager extends SavingsManager<Hex, PublicClient, WalletC
      */
     getMainWallet() {
         this.checkNotDisposed();
-        const derivationPath = `${this.derivationPathBase}0'/0/${this.walletIndex}`;
+        const derivationPathBase = `${this.derivationPathBase}0'/0/`;
+        const derivationPath = `${derivationPathBase}${this.walletIndex}'`;
         const seed = mnemonicToSeed(this.mnemonic);
-        const { privateKey } = EVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPath);
+        const { privateKey } = EVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPathBase);
         const wallet = new ethers.Wallet(privateKey);
 
         return {

package/utils/savings/multi-chain-savings.ts

@@ -10,6 +10,7 @@ import { SVMSavingsManager } from "./svm-savings";
 import { ChainWalletConfig, Balance } from "../types";
 import { Hex } from "viem";
 import { PublicKey } from "@solana/web3.js";
+import { fetchPrices } from "../price";
 
 /**
  * Chain type identifier
@@ -46,6 +47,8 @@ export interface PocketBalance {
         token: string;
         /** Balance information */
         balance: Balance;
+        /** Balance in USD (if unavailable, defaults to 0) */
+        balanceInUsd: number;
     }[];
 }
 
@@ -90,6 +93,44 @@ export class MultiChainSavingsManager {
     // Track chain configs
     private chainConfigs: Map<string, ChainConfig> = new Map();
 
+    private getTokenKey(tokenAddress: string, chainType: ChainType): string {
+        if (chainType === 'EVM') {
+            return tokenAddress.toLowerCase();
+        }
+        return tokenAddress;
+    }
+
+    private normalizePriceMap(
+        prices: Array<{ tokenAddress: string; price: number }>,
+        chainType: ChainType
+    ): Map<string, number> {
+        const priceMap = new Map<string, number>();
+        for (const item of prices) {
+            if (!item?.tokenAddress || typeof item.price !== 'number') continue;
+            priceMap.set(this.getTokenKey(item.tokenAddress, chainType), item.price);
+        }
+        return priceMap;
+    }
+
+    private async getPriceMap(
+        chain: ChainConfig,
+        tokenAddresses: string[]
+    ): Promise<Map<string, number>> {
+        const chainWithId = chain.config as Partial<ChainWalletConfig>;
+        if (typeof chainWithId.chainId !== 'number') {
+            return new Map();
+        }
+
+        const uniqueTokenAddresses = Array.from(new Set(tokenAddresses));
+        const priceResult = await fetchPrices({
+            vm: chain.type,
+            chainId: chainWithId.chainId,
+            tokenAddresses: uniqueTokenAddresses
+        });
+
+        return this.normalizePriceMap(priceResult.data?.prices ?? [], chain.type);
+    }
+
     /**
      * Create a new MultiChainSavingsManager
      *
@@ -132,14 +173,13 @@ export class MultiChainSavingsManager {
             throw new Error(`Chain with id '${chain.id}' already exists`);
         }
 
-        this.chainConfigs.set(chain.id, chain);
-
         if (chain.type === 'EVM') {
             const manager = new EVMSavingsManager(
                 this.mnemonic,
                 chain.config as ChainWalletConfig,
                 this.walletIndex
             );
+            this.chainConfigs.set(chain.id, chain);
             this.evmManagers.set(chain.id, manager);
         } else if (chain.type === 'SVM') {
             const config = chain.config as { rpcUrl: string };
@@ -151,6 +191,7 @@ export class MultiChainSavingsManager {
                 config.rpcUrl,
                 this.walletIndex
             );
+            this.chainConfigs.set(chain.id, chain);
             this.svmManagers.set(chain.id, manager);
         } else {
             throw new Error(`Unknown chain type: ${chain.type}`);
@@ -253,30 +294,52 @@ export class MultiChainSavingsManager {
             const manager = this.evmManagers.get(chainId)!;
             const balances = await manager.getPocketBalance(pocketIndex, tokens);
             const pocket = manager.getPocket(pocketIndex);
+            const balanceRows = balances.map(b => ({
+                token: b.address === 'native' ? 'native' : b.address,
+                balance: b.balance
+            }));
+            const priceMap = await this.getPriceMap(
+                chain,
+                balanceRows.map(row => row.token)
+            );
 
             return {
                 chainId,
                 chainType: 'EVM',
                 pocketIndex,
                 address: pocket.address,
-                balances: balances.map(b => ({
-                    token: b.address === 'native' ? 'native' : b.address,
-                    balance: b.balance
+                balances: balanceRows.map(row => ({
+                    token: row.token,
+                    balance: row.balance,
+                    balanceInUsd:
+                        row.balance.formatted *
+                        (priceMap.get(this.getTokenKey(row.token, 'EVM')) ?? 0)
                 }))
             };
         } else {
             const manager = this.svmManagers.get(chainId)!;
             const balances = await manager.getPocketBalance(pocketIndex, tokens);
             const pocket = manager.getPocket(pocketIndex);
+            const balanceRows = balances.map(b => ({
+                token: b.address === 'native' ? 'native' : b.address.toBase58(),
+                balance: b.balance
+            }));
+            const priceMap = await this.getPriceMap(
+                chain,
+                balanceRows.map(row => row.token)
+            );
 
             return {
                 chainId,
                 chainType: 'SVM',
                 pocketIndex,
                 address: pocket.address.toBase58(),
-                balances: balances.map(b => ({
-                    token: b.address === 'native' ? 'native' : b.address.toBase58(),
-                    balance: b.balance
+                balances: balanceRows.map(row => ({
+                    token: row.token,
+                    balance: row.balance,
+                    balanceInUsd:
+                        row.balance.formatted *
+                        (priceMap.get(this.getTokenKey(row.token, 'SVM')) ?? 0)
                 }))
             };
         }

package/utils/savings/saving-manager.ts

@@ -1,4 +1,4 @@
-import { EVMDeriveChildPrivateKey, GenerateSeed, mnemonicToSeed } from "../walletBip32";
+import { EVMDeriveChildPrivateKey, mnemonicToSeed } from "../walletBip32";
 import { ethers } from "ethers";
 import { WalletClient, PublicClient, Hex, Chain, createWalletClient, createPublicClient, http } from "viem";
 import { } from "../utils";
@@ -141,11 +141,12 @@ export class BaseSavingsManager {
 
         //? for the sake of derivation we will add one to the index of the pocket that was passed so as to preserve the index 0 as the main wallet index
         const pocketIndex = accountIndex + 1
-        const derivationPath = `m/44'/60'/${pocketIndex}'/0/${this.walletIndex}`;
-        const { privateKey } = EVMDeriveChildPrivateKey(mnemonicToSeed(this.mnemonic), this.walletIndex, derivationPath);
+        const derivationPathBase = `m/44'/60'/${pocketIndex}'/0/`;
+        const derivationPath = `${derivationPathBase}${this.walletIndex}'`;
+        const { privateKey } = EVMDeriveChildPrivateKey(mnemonicToSeed(this.mnemonic), this.walletIndex, derivationPathBase);
         const wallet = new ethers.Wallet(privateKey);
         const pocket = { privateKey, address: wallet.address, derivationPath, index: pocketIndex };
-        this.pockets.set(pocketIndex, pocket);
+        this.pockets.set(accountIndex, pocket);
         return pocket;
     }
 
@@ -164,8 +165,13 @@ export class BaseSavingsManager {
      * ```
      */
     getMainWallet() {
-        const mainWalletDerivationPath = `m/44'/60'/0'/0/${this.walletIndex}`;
-        const { privateKey } = EVMDeriveChildPrivateKey(this.mnemonic, this.walletIndex, mainWalletDerivationPath);
+        const mainWalletDerivationPathBase = `m/44'/60'/0'/0/`;
+        const mainWalletDerivationPath = `${mainWalletDerivationPathBase}${this.walletIndex}'`;
+        const { privateKey } = EVMDeriveChildPrivateKey(
+            mnemonicToSeed(this.mnemonic),
+            this.walletIndex,
+            mainWalletDerivationPathBase
+        );
         const wallet = new ethers.Wallet(privateKey);
         return { privateKey, address: wallet.address, derivationPath: mainWalletDerivationPath };
     }
@@ -185,8 +191,7 @@ export class BaseSavingsManager {
      */
     getMainWalletAddress(): Hex {
         if (this.masterAddress) return this.masterAddress;
-        const { privateKey } = this.getMainWallet()
-        return new ethers.Wallet(privateKey).address as Hex
+        return this.getMainWallet().address as Hex
     }
 
     /**
@@ -342,8 +347,8 @@ export class BaseSavingsManager {
      * ```
      */
     accountFromPocketId(p: number): Account {
-        // Validation is done in derivePocket
-        return privateKeyToAccount(`0x${this.derivePocket(p).privateKey}`)
+        // Validation is done in getPocket
+        return privateKeyToAccount(`0x${this.getPocket(p).privateKey}`)
     }
 
     /**
@@ -599,16 +604,13 @@ export class SavingsManager extends BaseSavingsManager {
      * Withdraws either native tokens or ERC-20 tokens from a pocket to the main wallet.
      *
      * @param pocketIndex - Index of the pocket to withdraw from
-     * @param amountInEther - Amount to send (interpreted as bigint, not actual ether units)
+     * @param amount - Amount to send in base units
      * @param token - Token address or "native" for native blockchain token
      * @returns Transaction result containing hash and success status
      *
      * @throws Error if validation fails
      *
      * @remarks
-     * Despite the parameter name, amountInEther is actually interpreted as a raw bigint value,
-     * not converted from ether units. Consider renaming to `amount` for clarity.
-     *
      * @example
      * ```typescript
      * // Send native token from pocket to main wallet
@@ -626,13 +628,11 @@ export class SavingsManager extends BaseSavingsManager {
      * );
      * ```
      */
-    async sendToMainWallet(pocketIndex: number, amountInEther: number, token: Hex | "native"): Promise<TransactionResult> {
+    async sendToMainWallet(pocketIndex: number, amount: bigint, token: Hex | "native"): Promise<TransactionResult> {
         // Validate inputs
         SavingsValidation.validateAccountIndex(pocketIndex);
 
-        if (typeof amountInEther !== 'number' || amountInEther <= 0) {
-            throw new Error(`Amount must be a positive number, got: ${amountInEther}`);
-        }
+        SavingsValidation.validateAmount(amount, 'Transfer amount');
 
         if (token !== 'native') {
             SavingsValidation.validateAddress(token, 'Token address');
@@ -648,9 +648,9 @@ export class SavingsManager extends BaseSavingsManager {
             }
         )
         if (token === "native") {
-            return await sendNativeToken(walletClient, this.client, mainWalletAddress, BigInt(amountInEther))
+            return await sendNativeToken(walletClient, this.client, mainWalletAddress, amount)
         }
-        const res = await sendERC20Token(walletClient, this.client, token, mainWalletAddress as Hex, BigInt(amountInEther))
+        const res = await sendERC20Token(walletClient, this.client, token, mainWalletAddress as Hex, amount)
         return res
     }
 }