@deserialize/multi-vm-wallet 1.3.3 → 1.4.0

package/utils/helpers/index.ts

@@ -18,6 +18,12 @@ export class HelperAPI {
         return 'mainnet';
     }
 
+    static async getPrice(tokenOrNativeSymbol: string, chainId: number, vm: vmTypes) {
+        const res = await fetch("" + BASE_URL + `/${vm}/prices?chainId${chainId}tokenAddresses=${tokenOrNativeSymbol}`);
+        const data = await res.json();
+        return data;
+    }
+
     static async getUserToken(wallet: string, vm: vmTypes, chainId: number) {
         // Only try RouteScan for EVM chains
         if (vm === 'EVM') {

package/utils/index.ts

@@ -6,3 +6,4 @@ export * from "./svm"
 export * from "./constant"
 export * from "bs58"
 export * from "@solana/web3.js"
+export * from "./price"

package/utils/price.ts

@@ -0,0 +1,37 @@
+// packages/utils/price.ts
+import { PriceFetchingConfig, PriceFetchingResult, PriceResponse } from './price.types';
+
+const API_BASE_URL = 'https://helper.decane.app';
+
+export async function fetchPrices(config: PriceFetchingConfig): Promise<PriceFetchingResult> {
+  const { vm, chainId, tokenAddresses } = config;
+
+  if (tokenAddresses.length === 0) {
+    return { data: { vm, chainId, prices: [] } as PriceResponse };
+  }
+
+  const url = new URL(`${API_BASE_URL}/${vm}/prices`);
+  url.searchParams.append('chainId', String(chainId));
+  url.searchParams.append('tokenAddresses', tokenAddresses.join(','));
+
+  try {
+    const response = await fetch(url.toString());
+
+    if (!response.ok) {
+      const errorData = await response.json();
+      return { error: errorData };
+    }
+
+    const data = await response.json();
+    return { data: data.data };
+  } catch (error: any) {
+    return {
+      error: {
+        code: 500,
+        message: error.message || 'An unexpected error occurred',
+        stack: error.stack,
+        errors: [],
+      },
+    };
+  }
+}

package/utils/price.types.ts

@@ -0,0 +1,45 @@
+// price.types.ts
+
+export interface TokenPrice {
+    tokenAddress: string;
+    price: number;
+    priceChange24h?: number;
+    marketCap?: number;
+    volume24h?: number;
+    timestamp: number;
+  }
+  
+  export interface EvmPriceResponse {
+    chainId: number;
+    vm: 'EVM';
+    prices: TokenPrice[];
+  }
+  
+  export interface SvmPriceResponse {
+    chainId: number;
+    vm: 'SVM';
+    prices: (TokenPrice & { symbol?: string; name?: string })[];
+  }
+  
+  export type PriceResponse = EvmPriceResponse | SvmPriceResponse;
+  
+  export interface PriceApiError {
+    code: number;
+    message: string;
+    stack: string;
+    errors: any[];
+  }
+  
+  export type VmType = 'EVM' | 'SVM';
+  
+  export interface PriceFetchingConfig {
+    vm: VmType;
+    chainId: number;
+    tokenAddresses: string[];
+  }
+  
+  export interface PriceFetchingResult {
+    data?: PriceResponse;
+    error?: PriceApiError;
+  }
+  

package/utils/savings/index.ts

@@ -0,0 +1,28 @@
+// import { WalletClient, PublicClient } from "viem";
+// import { SavingsActions } from "./saving-actions";
+
+
+// export interface ExtendedWalletClient extends WalletClient {
+//     extendSavings?: (mnemonic: string, walletIndex?: number) => SavingsActions;
+//     savingsActions?: SavingsActions;
+// }
+
+// /**
+//  * Adds savings functionality to an existing WalletClient
+//  */
+// export function extendWalletClientWithSavings(
+//     wallet: WalletClient,
+//     client: PublicClient,
+//     walletIndex: number = 0
+// ): ExtendedWalletClient {
+//     const extended = wallet as ExtendedWalletClient;
+
+//     extended.extendSavings = (mnemonic: string, index: number = walletIndex) => {
+//         if (!extended.savingsActions) {
+//             extended.savingsActions = new SavingsActions(mnemonic, index);
+//         }
+//         return extended.savingsActions;
+//     };
+
+//     return extended;
+// }

package/utils/savings/saving-actions.ts

@@ -0,0 +1,77 @@
+import { EVMDeriveChildPrivateKey } from "../walletBip32";
+import { ethers } from "ethers";
+import { WalletClient, PublicClient, Hex, ChainConfig } from "viem";
+import { } from "../utils";
+import { TransactionResult } from "../types";
+import { sendERC20Token, sendNativeToken } from "../evm";
+
+/**
+ * Handles multi-pocket savings accounts for an EVM wallet
+ */
+export class SavingsManager {
+    private mnemonic: string;
+    private walletIndex: number;
+    private pockets: Map<number, { privateKey: string; address: string; derivationPath: string }> = new Map();
+
+    constructor(mnemonic: string, walletIndex: number = 0, chain: ChainConfig) {
+        this.mnemonic = mnemonic;
+        this.walletIndex = walletIndex;
+    }
+
+    getTotalTokenBalanceOfAllPockets(tokens: string[], pockets: number[]) {
+
+        const balances = pockets.map((p: number) => { })
+    }
+
+    getPocketTokenBalance(tokens: string[], pocket: number) {
+
+        const balances = tokens.map((t: string) => {
+
+        })
+    }
+
+    /**
+     * Derive a pocket (savings account) at accountIndex
+     */
+    derivePocket(accountIndex: number) {
+        const derivationPath = `m/44'/60'/${accountIndex}'/0/${this.walletIndex}`;
+        const { privateKey } = EVMDeriveChildPrivateKey(this.mnemonic, this.walletIndex, `m/44'/60'/${accountIndex}'/0/`);
+        const wallet = new ethers.Wallet(privateKey);
+
+        const pocket = { privateKey, address: wallet.address, derivationPath };
+        this.pockets.set(accountIndex, pocket);
+        return pocket;
+    }
+
+    getPocket(accountIndex: number) {
+        if (!this.pockets.has(accountIndex)) {
+            return this.derivePocket(accountIndex);
+        }
+        return this.pockets.get(accountIndex)!;
+    }
+    async transferToPocket(
+        mainWallet: WalletClient,
+        client: PublicClient,
+        accountIndex: number,
+        amount: string
+    ): Promise<TransactionResult> {
+        const pocket = this.getPocket(accountIndex);
+        return await sendNativeToken(mainWallet, client, pocket.address as Hex, amount, 5);
+    }
+
+    async transferTokenToPocket(
+        mainWallet: WalletClient,
+        client: PublicClient,
+        tokenAddress: string,
+        accountIndex: number,
+        amount: bigint
+    ): Promise<TransactionResult> {
+        const pocket = this.getPocket(accountIndex);
+        return await sendERC20Token(mainWallet, client, tokenAddress as Hex, pocket.address as Hex, amount, 5);
+    }
+
+    verifyPocketAddress(accountIndex: number, storedAddress: string) {
+        const pocket = this.getPocket(accountIndex);
+        return pocket.address.toLowerCase() === storedAddress.toLowerCase();
+    }
+}

package/utils/savings/savings-manager.ts

@@ -35,7 +35,7 @@ import {
  * 3. Transaction builders for deposits and withdrawals
  * 4. Batch auditing of stored addresses
  */
-export class SavingsManager {
+export class SavingsManagerOld {
     private vm: VM<any, any, any>;
 
     constructor(vm: VM<any, any, any>) {

package/utils/svm/svm.ts

@@ -24,6 +24,8 @@ import {
 import BN from "bn.js";
 import nacl from "tweetnacl";
 import base58 from "bs58";
+import { fetchPrices } from "../price";
+import { PriceResponse } from "../price.types";
 import { getSVMTransactionHistory, SVMTransactionHistoryItem } from "./transactionParsing";
 
 
@@ -107,8 +109,6 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
         const seed = VM.mnemonicToSeed(mnemonic)
         return new SVMVM(seed)
     }
-
-
 }
 
 export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection> {
@@ -202,6 +202,20 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         return await SVMVM.getTokenInfo(tokenAddress, this.connection!)
     }
 
+    async getPrices(tokenAddresses: string[]): Promise<PriceResponse> {
+        const result = await fetchPrices({
+            vm: 'SVM',
+            chainId: this.config.chainId,
+            tokenAddresses,
+        });
+
+        if (result.error) {
+            throw new Error(result.error.message);
+        }
+
+        return result.data as PriceResponse;
+    }
+
     async swap(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage: number = 50): Promise<TransactionResult> {
         try {
             if (amount <= 0) {

package/utils/test.ts

@@ -30,11 +30,11 @@ import { toSpendingLimitHook } from "@zerodev/hooks"
 // const seed = VM.mnemonicToSeed(mnemonic)
 const pKey = ""
 
-const testUserKeyPair = Keypair.fromSecretKey(base58.decode(pKey));
+// const testUserKeyPair = Keypair.fromSecretKey(base58.decode(pKey));
 // const x = testUserKeyPair instanceof Keypair;
 
-const evmPrivKey = ""
-const evmPrivateKeyExposed = ""
+const evmPrivKey = "0xc9ca95aa5f40bae8b0f741ec89acc07b837590b2f9f818d3439df98c6e4f8dbe"
+const evmPrivateKeyExposed = "0x92cccc7792024dcac5992e5d2986dade41770acfd3dab0fe98ee953ed1bf0c3a"
 // const vm = new SVMVM(seed)
 
 
@@ -69,7 +69,8 @@ const evmChainConfig: ChainWalletConfig = {
         enabled: true,
         entryPoints: [
             {
-                address: entryPoint07Address,
+                address: entryPoint07Address
+                ,
                 version: "0.7"
             }
         ],
@@ -205,6 +206,14 @@ const testModule = async () => {
 }
 
 
+const testPrice = async () => {
+
+    walletA.getPrices(['0x98d0baa52b2D063E780DE12F615f963Fe8537553']).then(console.log)
+}
+
+// testPrice()
+
+
 
 // console.log('wallet: ', wallet);
 // getTokenInfo(new PublicKey("9BB6NFEcjBCtnNLFko2FqVQBq8HHM13kCyYcdQbgpump"), wallet.connection!).then(e => console.log('token info: ', e))

package/utils/vm.ts

@@ -1,7 +1,8 @@
-
 import { Balance, ChainWalletConfig, TokenInfo, vmTypes } from "./types";
 import * as bip39 from "@scure/bip39";
 import CryptoJS from "crypto-js";
+import { PriceResponse } from "./price.types";
+
 // Abstract Base Classes
 export abstract class VM<AddressType, PrivateKeyType, ConnectionType> {
     protected seed: string;