@deserialize/multi-vm-wallet 1.5.11 → 1.5.21

package/dist/savings/index.d.ts

@@ -1 +1,9 @@
-export * from "./saving-manager";
+export * from "./savings-manager";
+export * from "./evm-savings";
+export * from "./svm-savings";
+export * from "./multi-chain-savings";
+export * from "./types";
+export * from "./validation";
+export { BaseSavingsManager as LegacyBaseSavingsManager, SavingsManager as LegacySavingsManager } from "./saving-manager";
+export * from "./smart-savings";
+export * from "./savings-operations";

package/dist/savings/index.js

@@ -14,4 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./saving-manager"), exports);
+exports.LegacySavingsManager = exports.LegacyBaseSavingsManager = void 0;
+__exportStar(require("./savings-manager"), exports);
+__exportStar(require("./evm-savings"), exports);
+__exportStar(require("./svm-savings"), exports);
+__exportStar(require("./multi-chain-savings"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./validation"), exports);
+var saving_manager_1 = require("./saving-manager");
+Object.defineProperty(exports, "LegacyBaseSavingsManager", { enumerable: true, get: function () { return saving_manager_1.BaseSavingsManager; } });
+Object.defineProperty(exports, "LegacySavingsManager", { enumerable: true, get: function () { return saving_manager_1.SavingsManager; } });
+__exportStar(require("./smart-savings"), exports);
+__exportStar(require("./savings-operations"), exports);

package/dist/savings/multi-chain-savings.d.ts

@@ -0,0 +1,48 @@
+import { EVMSavingsManager } from "./evm-savings";
+import { SVMSavingsManager } from "./svm-savings";
+import { ChainWalletConfig, Balance } from "../types";
+export type ChainType = 'EVM' | 'SVM';
+export interface ChainConfig {
+    id: string;
+    type: ChainType;
+    config: ChainWalletConfig | {
+        rpcUrl: string;
+    };
+}
+export interface PocketBalance {
+    chainId: string;
+    chainType: ChainType;
+    pocketIndex: number;
+    address: string;
+    balances: {
+        token: string;
+        balance: Balance;
+    }[];
+}
+export declare class MultiChainSavingsManager {
+    private mnemonic;
+    private walletIndex;
+    private evmManagers;
+    private svmManagers;
+    private chainConfigs;
+    constructor(mnemonic: string, chains: ChainConfig[], walletIndex?: number);
+    addChain(chain: ChainConfig): void;
+    removeChain(chainId: string): void;
+    getChains(): string[];
+    getChainConfig(chainId: string): ChainConfig;
+    getPocketAddress(chainId: string, pocketIndex: number): string;
+    getMainWalletAddress(chainId: string): string;
+    getPocketBalance(chainId: string, pocketIndex: number, tokens: string[]): Promise<PocketBalance>;
+    getPocketBalanceAcrossChains(pocketIndex: number, tokensByChain: Map<string, string[]>): Promise<PocketBalance[]>;
+    getAllPocketsBalanceAcrossChains(pocketIndices: number[], tokensByChain: Map<string, string[]>): Promise<Map<number, PocketBalance[]>>;
+    getEVMManager(chainId: string): EVMSavingsManager;
+    getSVMManager(chainId: string): SVMSavingsManager;
+    isEVMChain(chainId: string): boolean;
+    isSVMChain(chainId: string): boolean;
+    getEVMChains(): string[];
+    getSVMChains(): string[];
+    clearPocket(pocketIndex: number): void;
+    clearAllPockets(): void;
+    clearAllClients(): void;
+    dispose(): void;
+}

package/dist/savings/multi-chain-savings.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiChainSavingsManager = void 0;
+const evm_savings_1 = require("./evm-savings");
+const svm_savings_1 = require("./svm-savings");
+class MultiChainSavingsManager {
+    mnemonic;
+    walletIndex;
+    evmManagers = new Map();
+    svmManagers = new Map();
+    chainConfigs = new Map();
+    constructor(mnemonic, chains, walletIndex = 0) {
+        if (!mnemonic || typeof mnemonic !== 'string') {
+            throw new Error('Mnemonic must be a non-empty string');
+        }
+        if (!Array.isArray(chains) || chains.length === 0) {
+            throw new Error('Chains array must be non-empty');
+        }
+        this.mnemonic = mnemonic;
+        this.walletIndex = walletIndex;
+        for (const chain of chains) {
+            this.addChain(chain);
+        }
+    }
+    addChain(chain) {
+        if (!chain.id || !chain.type) {
+            throw new Error('Chain must have id and type');
+        }
+        if (this.chainConfigs.has(chain.id)) {
+            throw new Error(`Chain with id '${chain.id}' already exists`);
+        }
+        this.chainConfigs.set(chain.id, chain);
+        if (chain.type === 'EVM') {
+            const manager = new evm_savings_1.EVMSavingsManager(this.mnemonic, chain.config, this.walletIndex);
+            this.evmManagers.set(chain.id, manager);
+        }
+        else if (chain.type === 'SVM') {
+            const config = chain.config;
+            if (!config.rpcUrl) {
+                throw new Error(`SVM chain '${chain.id}' must have rpcUrl in config`);
+            }
+            const manager = new svm_savings_1.SVMSavingsManager(this.mnemonic, config.rpcUrl, this.walletIndex);
+            this.svmManagers.set(chain.id, manager);
+        }
+        else {
+            throw new Error(`Unknown chain type: ${chain.type}`);
+        }
+    }
+    removeChain(chainId) {
+        if (this.evmManagers.has(chainId)) {
+            this.evmManagers.get(chainId)?.dispose();
+            this.evmManagers.delete(chainId);
+        }
+        if (this.svmManagers.has(chainId)) {
+            this.svmManagers.get(chainId)?.dispose();
+            this.svmManagers.delete(chainId);
+        }
+        this.chainConfigs.delete(chainId);
+    }
+    getChains() {
+        return Array.from(this.chainConfigs.keys());
+    }
+    getChainConfig(chainId) {
+        const config = this.chainConfigs.get(chainId);
+        if (!config) {
+            throw new Error(`Chain not found: ${chainId}`);
+        }
+        return config;
+    }
+    getPocketAddress(chainId, pocketIndex) {
+        const chain = this.getChainConfig(chainId);
+        if (chain.type === 'EVM') {
+            const manager = this.evmManagers.get(chainId);
+            return manager.getPocket(pocketIndex).address;
+        }
+        else {
+            const manager = this.svmManagers.get(chainId);
+            return manager.getPocket(pocketIndex).address.toBase58();
+        }
+    }
+    getMainWalletAddress(chainId) {
+        const chain = this.getChainConfig(chainId);
+        if (chain.type === 'EVM') {
+            const manager = this.evmManagers.get(chainId);
+            return manager.getMainWalletAddress();
+        }
+        else {
+            const manager = this.svmManagers.get(chainId);
+            return manager.getMainWalletAddress().toBase58();
+        }
+    }
+    async getPocketBalance(chainId, pocketIndex, tokens) {
+        const chain = this.getChainConfig(chainId);
+        if (chain.type === 'EVM') {
+            const manager = this.evmManagers.get(chainId);
+            const balances = await manager.getPocketBalance(pocketIndex, tokens);
+            const pocket = manager.getPocket(pocketIndex);
+            return {
+                chainId,
+                chainType: 'EVM',
+                pocketIndex,
+                address: pocket.address,
+                balances: balances.map(b => ({
+                    token: b.address === 'native' ? 'native' : b.address,
+                    balance: b.balance
+                }))
+            };
+        }
+        else {
+            const manager = this.svmManagers.get(chainId);
+            const balances = await manager.getPocketBalance(pocketIndex, tokens);
+            const pocket = manager.getPocket(pocketIndex);
+            return {
+                chainId,
+                chainType: 'SVM',
+                pocketIndex,
+                address: pocket.address.toBase58(),
+                balances: balances.map(b => ({
+                    token: b.address === 'native' ? 'native' : b.address.toBase58(),
+                    balance: b.balance
+                }))
+            };
+        }
+    }
+    async getPocketBalanceAcrossChains(pocketIndex, tokensByChain) {
+        const promises = [];
+        for (const [chainId, tokens] of tokensByChain) {
+            promises.push(this.getPocketBalance(chainId, pocketIndex, tokens));
+        }
+        return await Promise.all(promises);
+    }
+    async getAllPocketsBalanceAcrossChains(pocketIndices, tokensByChain) {
+        const results = new Map();
+        await Promise.all(pocketIndices.map(async (pocketIndex) => {
+            const balances = await this.getPocketBalanceAcrossChains(pocketIndex, tokensByChain);
+            results.set(pocketIndex, balances);
+        }));
+        return results;
+    }
+    getEVMManager(chainId) {
+        const manager = this.evmManagers.get(chainId);
+        if (!manager) {
+            throw new Error(`EVM chain not found: ${chainId}`);
+        }
+        return manager;
+    }
+    getSVMManager(chainId) {
+        const manager = this.svmManagers.get(chainId);
+        if (!manager) {
+            throw new Error(`SVM chain not found: ${chainId}`);
+        }
+        return manager;
+    }
+    isEVMChain(chainId) {
+        return this.evmManagers.has(chainId);
+    }
+    isSVMChain(chainId) {
+        return this.svmManagers.has(chainId);
+    }
+    getEVMChains() {
+        return Array.from(this.evmManagers.keys());
+    }
+    getSVMChains() {
+        return Array.from(this.svmManagers.keys());
+    }
+    clearPocket(pocketIndex) {
+        for (const manager of this.evmManagers.values()) {
+            manager.clearPocket(pocketIndex);
+        }
+        for (const manager of this.svmManagers.values()) {
+            manager.clearPocket(pocketIndex);
+        }
+    }
+    clearAllPockets() {
+        for (const manager of this.evmManagers.values()) {
+            manager.clearAllPockets();
+        }
+        for (const manager of this.svmManagers.values()) {
+            manager.clearAllPockets();
+        }
+    }
+    clearAllClients() {
+        for (const manager of this.evmManagers.values()) {
+            manager.clearClient();
+        }
+        for (const manager of this.svmManagers.values()) {
+            manager.clearClient();
+        }
+    }
+    dispose() {
+        for (const manager of this.evmManagers.values()) {
+            manager.dispose();
+        }
+        for (const manager of this.svmManagers.values()) {
+            manager.dispose();
+        }
+        this.evmManagers.clear();
+        this.svmManagers.clear();
+        this.chainConfigs.clear();
+        this.mnemonic = '';
+    }
+}
+exports.MultiChainSavingsManager = MultiChainSavingsManager;

package/dist/savings/savings-manager.d.ts

@@ -0,0 +1,28 @@
+export interface Pocket<AddressType> {
+    privateKey: any;
+    address: AddressType;
+    derivationPath: string;
+    index: number;
+}
+export declare abstract class SavingsManager<AddressType, ClientType, WalletClientType> {
+    protected mnemonic: string;
+    protected walletIndex: number;
+    protected disposed: boolean;
+    abstract coinType: number;
+    abstract derivationPathBase: string;
+    protected pockets: Map<number, Pocket<AddressType>>;
+    constructor(mnemonic: string, walletIndex?: number);
+    abstract derivePocket(accountIndex: number): Pocket<AddressType>;
+    abstract getMainWallet(): {
+        privateKey: any;
+        address: AddressType;
+        derivationPath: string;
+    };
+    abstract createClient(rpcUrl: string): ClientType;
+    getPocket(accountIndex: number): Pocket<AddressType>;
+    clearPocket(accountIndex: number): void;
+    clearAllPockets(): void;
+    dispose(): void;
+    isDisposed(): boolean;
+    protected checkNotDisposed(): void;
+}

package/dist/savings/savings-manager.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SavingsManager = void 0;
+const validation_1 = require("./validation");
+class SavingsManager {
+    mnemonic;
+    walletIndex;
+    disposed = false;
+    pockets = new Map();
+    constructor(mnemonic, walletIndex = 0) {
+        validation_1.SavingsValidation.validateMnemonic(mnemonic);
+        validation_1.SavingsValidation.validateWalletIndex(walletIndex);
+        this.mnemonic = mnemonic;
+        this.walletIndex = walletIndex;
+    }
+    getPocket(accountIndex) {
+        this.checkNotDisposed();
+        validation_1.SavingsValidation.validateAccountIndex(accountIndex);
+        if (!this.pockets.has(accountIndex)) {
+            return this.derivePocket(accountIndex);
+        }
+        return this.pockets.get(accountIndex);
+    }
+    clearPocket(accountIndex) {
+        validation_1.SavingsValidation.validateAccountIndex(accountIndex);
+        if (this.pockets.has(accountIndex)) {
+            const pocket = this.pockets.get(accountIndex);
+            pocket.privateKey = '';
+            this.pockets.delete(accountIndex);
+        }
+    }
+    clearAllPockets() {
+        for (const [_, pocket] of this.pockets.entries()) {
+            pocket.privateKey = '';
+        }
+        this.pockets.clear();
+    }
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.clearAllPockets();
+        this.mnemonic = '';
+        this.disposed = true;
+    }
+    isDisposed() {
+        return this.disposed || !this.mnemonic || this.mnemonic === '';
+    }
+    checkNotDisposed() {
+        if (this.isDisposed()) {
+            throw new Error('SavingsManager has been disposed. Create a new instance to perform operations.');
+        }
+    }
+}
+exports.SavingsManager = SavingsManager;

package/dist/savings/svm-savings.d.ts

@@ -0,0 +1,40 @@
+import { SavingsManager, Pocket } from "./savings-manager";
+import { Connection, PublicKey, Keypair } from "@solana/web3.js";
+import { Balance, TransactionResult } from "../types";
+export declare class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Keypair> {
+    coinType: number;
+    derivationPathBase: string;
+    private rpcUrl;
+    private _client?;
+    constructor(mnemonic: string, rpcUrl: string, walletIndex?: number);
+    get client(): Connection;
+    createClient(rpcUrl: string): Connection;
+    clearClient(): void;
+    derivePocket(accountIndex: number): Pocket<PublicKey>;
+    getMainWallet(): {
+        privateKey: Keypair;
+        address: PublicKey;
+        derivationPath: string;
+    };
+    getMainWalletAddress(): PublicKey;
+    getPocketBalance(pocketIndex: number, tokens: string[]): Promise<{
+        address: PublicKey | 'native';
+        balance: Balance;
+    }[]>;
+    getTotalTokenBalanceOfAllPockets(tokens: string[], pockets: number[]): Promise<Array<{
+        address: PublicKey | 'native';
+        balance: Balance;
+    }[]>>;
+    transferToPocket(mainWallet: Keypair, pocketIndex: number, amount: bigint): Promise<TransactionResult>;
+    transferTokenToPocket(mainWallet: Keypair, tokenInfo: {
+        address: string;
+        decimals: number;
+    }, pocketIndex: number, amount: bigint): Promise<TransactionResult>;
+    accountFromPocketId(pocketIndex: number): Keypair;
+    verifyPocketAddress(accountIndex: number, storedAddress: string): boolean;
+    sendToMainWallet(pocketIndex: number, amount: bigint, token: {
+        address: string;
+        decimals: number;
+    } | "native"): Promise<TransactionResult>;
+    dispose(): void;
+}

package/dist/savings/svm-savings.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SVMSavingsManager = void 0;
+const savings_manager_1 = require("./savings-manager");
+const web3_js_1 = require("@solana/web3.js");
+const walletBip32_1 = require("../walletBip32");
+const svm_1 = require("../svm");
+const validation_1 = require("./validation");
+const bn_js_1 = __importDefault(require("bn.js"));
+class SVMSavingsManager extends savings_manager_1.SavingsManager {
+    coinType = 501;
+    derivationPathBase = "m/44'/501'/";
+    rpcUrl;
+    _client;
+    constructor(mnemonic, rpcUrl, walletIndex = 0) {
+        super(mnemonic, walletIndex);
+        if (!rpcUrl || typeof rpcUrl !== 'string') {
+            throw new Error('RPC URL must be a non-empty string');
+        }
+        this.rpcUrl = rpcUrl;
+    }
+    get client() {
+        if (!this._client) {
+            this._client = this.createClient(this.rpcUrl);
+        }
+        return this._client;
+    }
+    createClient(rpcUrl) {
+        return new web3_js_1.Connection(rpcUrl, 'confirmed');
+    }
+    clearClient() {
+        this._client = undefined;
+    }
+    derivePocket(accountIndex) {
+        this.checkNotDisposed();
+        validation_1.SavingsValidation.validateAccountIndex(accountIndex);
+        const pocketIndex = accountIndex + 1;
+        const derivationPath = `${this.derivationPathBase}${pocketIndex}'/0/${this.walletIndex}`;
+        const seed = (0, walletBip32_1.mnemonicToSeed)(this.mnemonic);
+        const keypair = (0, walletBip32_1.SVMDeriveChildPrivateKey)(seed, this.walletIndex, derivationPath);
+        const pocket = {
+            privateKey: keypair,
+            address: keypair.publicKey,
+            derivationPath,
+            index: pocketIndex
+        };
+        this.pockets.set(accountIndex, pocket);
+        return pocket;
+    }
+    getMainWallet() {
+        this.checkNotDisposed();
+        const derivationPath = `${this.derivationPathBase}0'/0/${this.walletIndex}`;
+        const seed = (0, walletBip32_1.mnemonicToSeed)(this.mnemonic);
+        const keypair = (0, walletBip32_1.SVMDeriveChildPrivateKey)(seed, this.walletIndex, derivationPath);
+        return {
+            privateKey: keypair,
+            address: keypair.publicKey,
+            derivationPath
+        };
+    }
+    getMainWalletAddress() {
+        return this.getMainWallet().address;
+    }
+    async getPocketBalance(pocketIndex, tokens) {
+        validation_1.SavingsValidation.validateAccountIndex(pocketIndex);
+        if (!Array.isArray(tokens)) {
+            throw new Error('Tokens must be an array');
+        }
+        const pocket = this.getPocket(pocketIndex);
+        const balances = [];
+        const nativeBalance = await (0, svm_1.getSvmNativeBalance)(pocket.address, this.client);
+        balances.push({ address: 'native', balance: nativeBalance });
+        await Promise.all(tokens.map(async (token) => {
+            try {
+                const tokenPubkey = new web3_js_1.PublicKey(token);
+                const tokenBalanceData = await (0, svm_1.getTokenBalance)(pocket.address, tokenPubkey, this.client);
+                if (tokenBalanceData === 0) {
+                    balances.push({
+                        address: tokenPubkey,
+                        balance: { balance: new bn_js_1.default(0), formatted: 0, decimal: 0 }
+                    });
+                }
+                else {
+                    const balance = {
+                        balance: new bn_js_1.default(tokenBalanceData.amount),
+                        formatted: tokenBalanceData.uiAmount || 0,
+                        decimal: tokenBalanceData.decimals
+                    };
+                    balances.push({ address: tokenPubkey, balance });
+                }
+            }
+            catch (error) {
+                balances.push({
+                    address: new web3_js_1.PublicKey(token),
+                    balance: { balance: new bn_js_1.default(0), formatted: 0, decimal: 0 }
+                });
+            }
+        }));
+        return balances;
+    }
+    async getTotalTokenBalanceOfAllPockets(tokens, pockets) {
+        if (!Array.isArray(tokens) || tokens.length === 0) {
+            throw new Error('Tokens array must be non-empty');
+        }
+        if (!Array.isArray(pockets) || pockets.length === 0) {
+            throw new Error('Pockets array must be non-empty');
+        }
+        pockets.forEach((pocket) => {
+            validation_1.SavingsValidation.validateAccountIndex(pocket);
+        });
+        const allBalances = await Promise.all(pockets.map((p) => this.getPocketBalance(p, tokens)));
+        return allBalances;
+    }
+    async transferToPocket(mainWallet, pocketIndex, amount) {
+        validation_1.SavingsValidation.validateAccountIndex(pocketIndex);
+        if (typeof amount !== 'bigint' || amount <= 0n) {
+            throw new Error(`Amount must be a positive bigint, got: ${amount}`);
+        }
+        const pocket = this.getPocket(pocketIndex);
+        const tx = await (0, svm_1.getTransferNativeTransaction)(mainWallet, pocket.address, Number(amount), this.client);
+        const hash = await (0, svm_1.signAndSendTransaction)(tx, this.client, mainWallet);
+        return { success: true, hash };
+    }
+    async transferTokenToPocket(mainWallet, tokenInfo, pocketIndex, amount) {
+        validation_1.SavingsValidation.validateAccountIndex(pocketIndex);
+        if (typeof amount !== 'bigint' || amount <= 0n) {
+            throw new Error(`Amount must be a positive bigint, got: ${amount}`);
+        }
+        const pocket = this.getPocket(pocketIndex);
+        const tx = await (0, svm_1.getTransferTokenTransaction)(mainWallet, pocket.address, tokenInfo, Number(amount), this.client);
+        const hash = await (0, svm_1.signAndSendTransaction)(tx, this.client, mainWallet);
+        return { success: true, hash };
+    }
+    accountFromPocketId(pocketIndex) {
+        const pocket = this.getPocket(pocketIndex);
+        return pocket.privateKey;
+    }
+    verifyPocketAddress(accountIndex, storedAddress) {
+        validation_1.SavingsValidation.validateAccountIndex(accountIndex);
+        if (!storedAddress || typeof storedAddress !== 'string') {
+            throw new Error('Stored address must be a non-empty string');
+        }
+        try {
+            const pocket = this.getPocket(accountIndex);
+            const storedPubkey = new web3_js_1.PublicKey(storedAddress);
+            return pocket.address.equals(storedPubkey);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async sendToMainWallet(pocketIndex, amount, token) {
+        validation_1.SavingsValidation.validateAccountIndex(pocketIndex);
+        if (typeof amount !== 'bigint' || amount <= 0n) {
+            throw new Error(`Amount must be a positive bigint, got: ${amount}`);
+        }
+        const pocket = this.getPocket(pocketIndex);
+        const mainWalletAddress = this.getMainWalletAddress();
+        if (token === "native") {
+            const tx = await (0, svm_1.getTransferNativeTransaction)(pocket.privateKey, mainWalletAddress, Number(amount), this.client);
+            const hash = await (0, svm_1.signAndSendTransaction)(tx, this.client, pocket.privateKey);
+            return { success: true, hash };
+        }
+        const tx = await (0, svm_1.getTransferTokenTransaction)(pocket.privateKey, mainWalletAddress, token, Number(amount), this.client);
+        const hash = await (0, svm_1.signAndSendTransaction)(tx, this.client, pocket.privateKey);
+        return { success: true, hash };
+    }
+    dispose() {
+        super.dispose();
+        this.clearClient();
+    }
+}
+exports.SVMSavingsManager = SVMSavingsManager;

package/dist/svm/index.d.ts

@@ -1 +1,2 @@
 export * from "./svm";
+export * from "./utils";

package/dist/svm/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./svm"), exports);
+__exportStar(require("./utils"), exports);