@deserialize/multi-vm-wallet 1.0.0

package/utils/svm/svm.ts

@@ -0,0 +1,75 @@
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import { SVMDeriveChildPrivateKey } from "../bip32";
+import { VM } from "../vm";
+import { ChainWallet } from "../IChainWallet";
+import { Balance, ChainWalletConfig, TokenInfo, TransactionResult } from "../types";
+import { getSvmNativeBalance, getTokenBalance, getTransferNativeTransaction, getTransferTokenTransaction, signAndSendTransaction } from "./utils";
+import BN from "bn.js";
+
+export class SVMVM extends VM<PublicKey, Keypair, Connection> {
+    derivationPath = "m/44'/501'/"; // Default EVM derivation path
+
+    constructor(mnemonic: string) {
+        super(mnemonic, "SVM");
+    }
+    static validateAddress(address: PublicKey): boolean {
+        return PublicKey.isOnCurve(address.toBuffer());
+    }
+    static getNativeBalance(address: PublicKey, connection: Connection): Promise<Balance> {
+        return getSvmNativeBalance(address, connection);
+    }
+    static async getTokenBalance(address: PublicKey, tokenAddress: PublicKey, connection: Connection): Promise<Balance> {
+        const balance = await getTokenBalance(address, tokenAddress, connection);
+        if (balance === 0) {
+            return { balance: new BN(0), formatted: 0, decimal: 0 };
+        }
+        return { balance: new BN(balance.amount), formatted: balance.uiAmount || parseInt(balance.amount) / 10 ** balance.decimals, decimal: balance.decimals };
+    }
+
+    static signAndSendTransaction = signAndSendTransaction
+    generatePrivateKey(index: number, seedPhrase = this.mnemonic, derivationPath = this.derivationPath) {
+        const seed = this.mnemonicToSeed(seedPhrase);
+        const privateKey = SVMDeriveChildPrivateKey(seed, index, derivationPath);
+        return { privateKey, index };
+    }
+
+}
+
+export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection> {
+    constructor(config: ChainWalletConfig, privateKey: Keypair, index: number) {
+        super(config, privateKey, index);
+        this.address = privateKey.publicKey;
+        this.privateKey = privateKey;
+        this.connection = new Connection(config.rpcUrl)
+    }
+    generateAddress() {
+        return this.address;
+    }
+    async getNativeBalance(): Promise<Balance> {
+        // Implement native balance retrieval logic here
+        return await SVMVM.getNativeBalance(this.address, this.connection!)
+    }
+
+    async getTokenBalance(tokenAddress: PublicKey): Promise<Balance> {
+        // Implement token balance retrieval logic here
+        return await SVMVM.getTokenBalance(this.address, (tokenAddress), this.connection!);
+    }
+
+    async transferNative(to: PublicKey, amount: number): Promise<TransactionResult> {
+        // Implement native transfer logic here
+        const transaction = await getTransferNativeTransaction(this.privateKey, to, amount, this.connection!)
+        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection!, [this.privateKey]);
+        return { success: true, hash } // Placeholder
+    }
+
+    async transferToken(token: TokenInfo, to: PublicKey, amount: number): Promise<TransactionResult> {
+        // Implement token transfer logic here
+        const transaction = await getTransferTokenTransaction(this.privateKey, new PublicKey(to), token, (amount), this.connection!);
+        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection!, [this.privateKey]);
+        return { success: true, hash }; // Placeholder
+    }
+}
+
+
+//swaps jupiter swap here
+

package/utils/svm/transactionSender.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionSenderAndConfirmationWaiter = transactionSenderAndConfirmationWaiter;
+const web3_js_1 = require("@solana/web3.js");
+const promise_retry_1 = __importDefault(require("promise-retry"));
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const SEND_OPTIONS = {
+    skipPreflight: false,
+};
+async function transactionSenderAndConfirmationWaiter({ connection, serializedTransaction, blockhashWithExpiryBlockHeight, }) {
+    const txid = await connection.sendRawTransaction(serializedTransaction, SEND_OPTIONS);
+    const controller = new AbortController();
+    const abortSignal = controller.signal;
+    const abortableResender = async () => {
+        while (true) {
+            await wait(2000);
+            if (abortSignal.aborted)
+                return;
+            try {
+                await connection.sendRawTransaction(serializedTransaction, SEND_OPTIONS);
+            }
+            catch (e) {
+                console.warn(`Failed to resend transaction: ${e}`);
+            }
+        }
+    };
+    try {
+        abortableResender();
+        const lastValidBlockHeight = blockhashWithExpiryBlockHeight.lastValidBlockHeight - 150;
+        // this would throw TransactionExpiredBlockheightExceededError
+        await Promise.race([
+            connection.confirmTransaction({
+                ...blockhashWithExpiryBlockHeight,
+                lastValidBlockHeight,
+                signature: txid,
+                abortSignal,
+            }, "confirmed"),
+            new Promise(async (resolve) => {
+                // in case ws socket died
+                while (!abortSignal.aborted) {
+                    await wait(2000);
+                    const tx = await connection.getSignatureStatus(txid, {
+                        searchTransactionHistory: false,
+                    });
+                    if (tx?.value?.confirmationStatus === "confirmed") {
+                        resolve(tx);
+                    }
+                }
+            }),
+        ]);
+    }
+    catch (e) {
+        if (e instanceof web3_js_1.TransactionExpiredBlockheightExceededError) {
+            // we consume this error and getTransaction would return null
+            return null;
+        }
+        else {
+            // invalid state from web3.js
+            throw e;
+        }
+    }
+    finally {
+        controller.abort();
+    }
+    // in case rpc is not synced yet, we add some retries
+    const response = (0, promise_retry_1.default)(async (retry) => {
+        const response = await connection.getTransaction(txid, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0,
+        });
+        if (!response) {
+            retry(response);
+        }
+        return response;
+    }, {
+        retries: 5,
+        minTimeout: 1e3,
+    });
+    return response;
+}

package/utils/svm/transactionSender.ts

@@ -0,0 +1,108 @@
+import {
+    BlockhashWithExpiryBlockHeight,
+    Connection,
+    TransactionExpiredBlockheightExceededError,
+    VersionedTransactionResponse,
+} from "@solana/web3.js";
+import promiseRetry from "promise-retry";
+const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+type TransactionSenderAndConfirmationWaiterArgs = {
+    connection: Connection;
+    serializedTransaction: Buffer;
+    blockhashWithExpiryBlockHeight: BlockhashWithExpiryBlockHeight;
+};
+
+const SEND_OPTIONS = {
+    skipPreflight: false,
+};
+
+export async function transactionSenderAndConfirmationWaiter({
+    connection,
+    serializedTransaction,
+    blockhashWithExpiryBlockHeight,
+}: TransactionSenderAndConfirmationWaiterArgs): Promise<VersionedTransactionResponse | null> {
+    const txid = await connection.sendRawTransaction(
+        serializedTransaction,
+        SEND_OPTIONS
+    );
+
+    const controller = new AbortController();
+    const abortSignal = controller.signal;
+
+    const abortableResender = async () => {
+        while (true) {
+            await wait(2_000);
+            if (abortSignal.aborted) return;
+            try {
+                await connection.sendRawTransaction(
+                    serializedTransaction,
+                    SEND_OPTIONS
+                );
+            } catch (e) {
+                console.warn(`Failed to resend transaction: ${e}`);
+            }
+        }
+    };
+
+    try {
+        abortableResender();
+        const lastValidBlockHeight =
+            blockhashWithExpiryBlockHeight.lastValidBlockHeight - 150;
+
+        // this would throw TransactionExpiredBlockheightExceededError
+        await Promise.race([
+            connection.confirmTransaction(
+                {
+                    ...blockhashWithExpiryBlockHeight,
+                    lastValidBlockHeight,
+                    signature: txid,
+                    abortSignal,
+                },
+                "confirmed"
+            ),
+            new Promise(async (resolve) => {
+                // in case ws socket died
+                while (!abortSignal.aborted) {
+                    await wait(2_000);
+                    const tx = await connection.getSignatureStatus(txid, {
+                        searchTransactionHistory: false,
+                    });
+                    if (tx?.value?.confirmationStatus === "confirmed") {
+                        resolve(tx);
+                    }
+                }
+            }),
+        ]);
+    } catch (e) {
+        if (e instanceof TransactionExpiredBlockheightExceededError) {
+            // we consume this error and getTransaction would return null
+            return null;
+        } else {
+            // invalid state from web3.js
+            throw e;
+        }
+    } finally {
+        controller.abort();
+    }
+
+    // in case rpc is not synced yet, we add some retries
+    const response = promiseRetry(
+        async (retry) => {
+            const response = await connection.getTransaction(txid, {
+                commitment: "confirmed",
+                maxSupportedTransactionVersion: 0,
+            });
+            if (!response) {
+                retry(response);
+            }
+            return response;
+        },
+        {
+            retries: 5,
+            minTimeout: 1e3,
+        }
+    );
+
+    return response;
+}

package/utils/svm/utils.js

@@ -0,0 +1,161 @@
+"use strict";
+//we will write all the svm utils function here
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signAndSendTransaction = exports.getTransferTokenTransaction = exports.getTransferTokenInx = exports.getTransferNativeTransaction = exports.getTransferNativeInx = exports.getTokenAccountAccount = exports.getTokenBalance = exports.getSvmNativeBalance = exports.getProgramIdOfToken = exports.getSureAssociatedTokenAddressAndAccount = exports.createAtaAndIx = exports.createV0Transaction = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const transactionSender_1 = require("./transactionSender");
+const bn_js_1 = require("bn.js");
+const createV0Transaction = async (connection, inX, signers, payerPubKey, blockHash) => {
+    const blockhash = blockHash || (await connection.getLatestBlockhash()).blockhash;
+    const message = new web3_js_1.TransactionMessage({
+        payerKey: payerPubKey,
+        instructions: inX,
+        recentBlockhash: blockhash,
+    }).compileToV0Message();
+    const transaction = new web3_js_1.VersionedTransaction(message);
+    transaction.message.staticAccountKeys;
+    if (signers.length < 1) {
+        transaction.sign(signers);
+    }
+    return transaction;
+};
+exports.createV0Transaction = createV0Transaction;
+const createAtaAndIx = async (token, ownerPublicKey, tokenProgramId, connection) => {
+    let AtaTokenIx;
+    const associatedToken = (0, spl_token_1.getAssociatedTokenAddressSync)(token, ownerPublicKey, false, tokenProgramId);
+    const accountExist = await connection.getAccountInfo(associatedToken);
+    if (!accountExist) {
+        AtaTokenIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(ownerPublicKey, associatedToken, ownerPublicKey, token, tokenProgramId);
+    }
+    return {
+        AtaTokenIx,
+        associatedToken,
+    };
+};
+exports.createAtaAndIx = createAtaAndIx;
+const getSureAssociatedTokenAddressAndAccount = async (connection, token, owner) => {
+    let ATA;
+    let programId;
+    let tokenAccount;
+    try {
+        programId = token.equals(spl_token_1.NATIVE_MINT)
+            ? spl_token_1.TOKEN_PROGRAM_ID
+            : spl_token_1.TOKEN_2022_PROGRAM_ID;
+        ATA = (0, spl_token_1.getAssociatedTokenAddressSync)(token, owner, true, programId);
+        tokenAccount = await (0, spl_token_1.getAccount)(connection, ATA, "confirmed", programId);
+        return { ATA, programId, tokenAccount };
+    }
+    catch (error) {
+        programId = spl_token_1.TOKEN_PROGRAM_ID;
+        ATA = (0, spl_token_1.getAssociatedTokenAddressSync)(token, owner, true, programId);
+        tokenAccount = await (0, spl_token_1.getAccount)(connection, ATA, "confirmed", programId);
+        return { ATA, programId, tokenAccount };
+    }
+};
+exports.getSureAssociatedTokenAddressAndAccount = getSureAssociatedTokenAddressAndAccount;
+const getProgramIdOfToken = async (owner, token, connection) => {
+    if (token.equals(spl_token_1.NATIVE_MINT)) {
+        return spl_token_1.TOKEN_PROGRAM_ID;
+    }
+    let ATA;
+    let programId = spl_token_1.TOKEN_PROGRAM_ID;
+    let tokenAccount;
+    try {
+        ATA = (0, spl_token_1.getAssociatedTokenAddressSync)(token, owner, true, programId);
+        tokenAccount = await (0, spl_token_1.getAccount)(connection, ATA, "confirmed", programId);
+        return spl_token_1.TOKEN_PROGRAM_ID;
+    }
+    catch (error) {
+        return spl_token_1.TOKEN_2022_PROGRAM_ID;
+    }
+};
+exports.getProgramIdOfToken = getProgramIdOfToken;
+//get native balance 
+const getSvmNativeBalance = async (address, connection) => {
+    const balance = await connection.getBalance(address);
+    return { balance: new bn_js_1.BN(balance), formatted: balance / web3_js_1.LAMPORTS_PER_SOL, decimal: 9 };
+};
+exports.getSvmNativeBalance = getSvmNativeBalance;
+const getTokenBalance = async (address, token, connection) => {
+    try {
+        // Get the balance from the token account
+        const tokenAccount = await (0, exports.getTokenAccountAccount)(token, address, connection);
+        if (!tokenAccount) {
+            console.error("Token account not found");
+            return 0;
+        }
+        const tokenBalance = await connection.getTokenAccountBalance(tokenAccount.address);
+        if (!tokenBalance) {
+            console.error("Token balance not found");
+            return 0;
+        }
+        return tokenBalance.value;
+    }
+    catch (error) {
+        return 0;
+    }
+};
+exports.getTokenBalance = getTokenBalance;
+const getTokenAccountAccount = async (token, address, connection) => {
+    try {
+        // Get the associated token account address for the user and the token mint
+        const associatedTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(token, // The token mint address
+        address // The user's public key
+        );
+        // Fetch the token account information
+        const tokenAccount = await (0, spl_token_1.getAccount)(connection, associatedTokenAccount);
+        return tokenAccount;
+    }
+    catch (error) {
+        console.error("Error getting token balance:");
+        return null;
+    }
+};
+exports.getTokenAccountAccount = getTokenAccountAccount;
+const getTransferNativeInx = async (from, to, amount) => {
+    return web3_js_1.SystemProgram.transfer({
+        fromPubkey: from,
+        toPubkey: to,
+        lamports: amount * web3_js_1.LAMPORTS_PER_SOL, // Convert SOL to lamports
+    });
+};
+exports.getTransferNativeInx = getTransferNativeInx;
+const getTransferNativeTransaction = async (from, to, amount, connection) => {
+    const instruction = await (0, exports.getTransferNativeInx)(from.publicKey, to, amount);
+    const transaction = await (0, exports.createV0Transaction)(connection, [instruction], [from], from.publicKey);
+    return transaction;
+};
+exports.getTransferNativeTransaction = getTransferNativeTransaction;
+const getTransferTokenInx = async (from, to, token, amount, connection) => {
+    const inx = [];
+    const tokenToSend = new web3_js_1.PublicKey(token.address);
+    const { ATA: source, programId, tokenAccount } = await (0, exports.getSureAssociatedTokenAddressAndAccount)(connection, from, tokenToSend);
+    const { associatedToken: destination, AtaTokenIx } = await (0, exports.createAtaAndIx)(tokenToSend, to, programId, connection);
+    if (!tokenAccount) {
+        throw new Error("Token account not found");
+    }
+    if (AtaTokenIx) {
+        inx.push(AtaTokenIx);
+    }
+    const tInx = (0, spl_token_1.createTransferCheckedInstruction)(source, tokenToSend, destination, from, amount, token.decimals, undefined, programId);
+    inx.push(tInx);
+    return inx;
+};
+exports.getTransferTokenInx = getTransferTokenInx;
+const getTransferTokenTransaction = async (from, to, token, amount, connection) => {
+    const instruction = await (0, exports.getTransferTokenInx)(from.publicKey, to, token, amount, connection);
+    const transaction = await (0, exports.createV0Transaction)(connection, instruction, [from], from.publicKey);
+    return transaction;
+};
+exports.getTransferTokenTransaction = getTransferTokenTransaction;
+const signAndSendTransaction = async (transaction, connection, signers) => {
+    transaction.sign(signers);
+    const blockhash = await connection.getLatestBlockhash();
+    const res = await (0, transactionSender_1.transactionSenderAndConfirmationWaiter)({ connection, serializedTransaction: Buffer.from(transaction.serialize()), blockhashWithExpiryBlockHeight: { blockhash: blockhash.blockhash, lastValidBlockHeight: blockhash.lastValidBlockHeight } });
+    if (!res) {
+        throw new Error("Transaction failed to send or confirm");
+    }
+    return res.transaction.signatures[0];
+};
+exports.signAndSendTransaction = signAndSendTransaction;

package/utils/svm/utils.ts

@@ -0,0 +1,203 @@
+//we will write all the svm utils function here
+
+import { Account, createAssociatedTokenAccountIdempotentInstruction, createTransferCheckedInstruction, getAccount, getAssociatedTokenAddress, getAssociatedTokenAddressSync, NATIVE_MINT, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
+import { TokenInfo } from "../types";
+import { transactionSenderAndConfirmationWaiter } from "./transactionSender";
+import { BN } from "bn.js";
+export const createV0Transaction = async (
+    connection: Connection,
+    inX: TransactionInstruction[],
+    signers: Keypair[],
+    payerPubKey: PublicKey,
+    blockHash?: string
+) => {
+    const blockhash =
+        blockHash || (await connection.getLatestBlockhash()).blockhash;
+    const message = new TransactionMessage({
+        payerKey: payerPubKey,
+        instructions: inX,
+        recentBlockhash: blockhash,
+    }).compileToV0Message();
+
+    const transaction = new VersionedTransaction(message);
+    transaction.message.staticAccountKeys;
+    if (signers.length < 1) {
+        transaction.sign(signers);
+    }
+
+    return transaction;
+};
+
+export const createAtaAndIx = async (
+    token: PublicKey,
+    ownerPublicKey: PublicKey,
+    tokenProgramId: PublicKey,
+    connection: Connection,
+) => {
+    let AtaTokenIx;
+    const associatedToken = getAssociatedTokenAddressSync(
+        token,
+        ownerPublicKey,
+        false,
+        tokenProgramId
+    );
+
+    const accountExist = await connection.getAccountInfo(associatedToken);
+    if (!accountExist) {
+        AtaTokenIx = createAssociatedTokenAccountIdempotentInstruction(
+            ownerPublicKey,
+            associatedToken,
+            ownerPublicKey,
+            token,
+            tokenProgramId
+        );
+    }
+    return {
+        AtaTokenIx,
+        associatedToken,
+    };
+};
+export const getSureAssociatedTokenAddressAndAccount = async (
+    connection: Connection,
+    token: PublicKey,
+    owner: PublicKey,
+) => {
+    let ATA: PublicKey;
+    let programId: PublicKey;
+    let tokenAccount: Account;
+    try {
+        programId = token.equals(NATIVE_MINT)
+            ? TOKEN_PROGRAM_ID
+            : TOKEN_2022_PROGRAM_ID;
+        ATA = getAssociatedTokenAddressSync(token, owner, true, programId);
+        tokenAccount = await getAccount(connection, ATA, "confirmed", programId);
+        return { ATA, programId, tokenAccount };
+    } catch (error) {
+        programId = TOKEN_PROGRAM_ID;
+        ATA = getAssociatedTokenAddressSync(token, owner, true, programId);
+        tokenAccount = await getAccount(connection, ATA, "confirmed", programId);
+        return { ATA, programId, tokenAccount };
+    }
+};
+
+export const getProgramIdOfToken = async (owner: PublicKey, token: PublicKey, connection: Connection) => {
+    if (token.equals(NATIVE_MINT)) {
+        return TOKEN_PROGRAM_ID;
+    }
+    let ATA: PublicKey;
+    let programId: PublicKey = TOKEN_PROGRAM_ID
+    let tokenAccount: Account;
+    try {
+        ATA = getAssociatedTokenAddressSync(token, owner, true, programId);
+        tokenAccount = await getAccount(connection, ATA, "confirmed", programId);
+        return TOKEN_PROGRAM_ID
+    } catch (error) {
+        return TOKEN_2022_PROGRAM_ID;
+
+    }
+
+
+
+}
+//get native balance 
+
+export const getSvmNativeBalance = async (address: PublicKey, connection: Connection,) => {
+    const balance = await connection.getBalance(address);
+    return { balance: new BN(balance), formatted: balance / LAMPORTS_PER_SOL, decimal: 9 };
+};
+
+export const getTokenBalance = async (address: PublicKey, token: PublicKey, connection: Connection) => {
+
+    try {
+        // Get the balance from the token account
+        const tokenAccount = await getTokenAccountAccount(token, address, connection);
+        if (!tokenAccount) {
+            console.error("Token account not found");
+            return 0;
+        }
+        const tokenBalance = await connection.getTokenAccountBalance(
+            tokenAccount.address
+        );
+
+        if (!tokenBalance) {
+            console.error("Token balance not found");
+            return 0;
+        }
+
+        return tokenBalance.value;
+
+    } catch (error) {
+        return 0;
+    }
+}
+
+export const getTokenAccountAccount = async (token: PublicKey, address: PublicKey, connection: Connection): Promise<Account | null> => {
+    try {
+
+        // Get the associated token account address for the user and the token mint
+        const associatedTokenAccount = await getAssociatedTokenAddress(
+            token, // The token mint address
+            address // The user's public key
+        );
+        // Fetch the token account information
+        const tokenAccount = await getAccount(
+            connection,
+            associatedTokenAccount
+        );
+
+        return tokenAccount;
+    } catch (error) {
+        console.error("Error getting token balance:");
+        return null;
+    }
+};
+
+export const getTransferNativeInx = async (from: PublicKey, to: PublicKey, amount: number): Promise<TransactionInstruction> => {
+    return SystemProgram.transfer({
+        fromPubkey: from,
+        toPubkey: to,
+        lamports: amount * LAMPORTS_PER_SOL, // Convert SOL to lamports
+    })
+}
+
+export const getTransferNativeTransaction = async (from: Keypair, to: PublicKey, amount: number, connection: Connection) => {
+    const instruction = await getTransferNativeInx(from.publicKey, to, amount);
+    const transaction = await createV0Transaction(connection, [instruction], [from], from.publicKey);
+    return transaction;
+}
+
+export const getTransferTokenInx = async (from: PublicKey, to: PublicKey, token: TokenInfo, amount: number, connection: Connection): Promise<TransactionInstruction[]> => {
+    const inx: TransactionInstruction[] = []
+
+    const tokenToSend = new PublicKey(token.address);
+    const { ATA: source, programId, tokenAccount } = await getSureAssociatedTokenAddressAndAccount(connection, from, tokenToSend);
+    const { associatedToken: destination, AtaTokenIx } = await createAtaAndIx(tokenToSend, to, programId, connection);
+
+    if (!tokenAccount) {
+        throw new Error("Token account not found");
+    }
+    if (AtaTokenIx) {
+        inx.push(AtaTokenIx);
+    }
+    const tInx = createTransferCheckedInstruction(source, tokenToSend, destination, from, amount, token.decimals, undefined, programId)
+    inx.push(tInx);
+
+    return inx;
+
+}
+export const getTransferTokenTransaction = async (from: Keypair, to: PublicKey, token: TokenInfo, amount: number, connection: Connection): Promise<VersionedTransaction> => {
+    const instruction = await getTransferTokenInx(from.publicKey, to, token, amount, connection);
+    const transaction = await createV0Transaction(connection, instruction, [from], from.publicKey);
+    return transaction;
+}
+export const signAndSendTransaction = async (transaction: VersionedTransaction, connection: Connection, signers: Keypair[]) => {
+    transaction.sign(signers)
+    const blockhash = await connection.getLatestBlockhash()
+    const res = await transactionSenderAndConfirmationWaiter({ connection, serializedTransaction: Buffer.from(transaction.serialize()), blockhashWithExpiryBlockHeight: { blockhash: blockhash.blockhash, lastValidBlockHeight: blockhash.lastValidBlockHeight } })
+    if (!res) {
+        throw new Error("Transaction failed to send or confirm");
+    }
+    return res.transaction.signatures[0];
+
+}

package/utils/types.ts

@@ -0,0 +1,53 @@
+import BN from "bn.js"
+import { EVMVM } from "./evm";
+import { SVMVM } from "./svm";
+
+export interface ChainWalletConfig {
+    chainId: string | number;
+    name: string;
+    rpcUrl: string;
+    explorerUrl: string;
+
+    nativeToken: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    confirmationNo?: number
+    testnet?: boolean;
+}
+
+export interface TokenInfo {
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+}
+
+export interface NFTInfo {
+    tokenId: string;
+    contractAddress: string;
+    name?: string;
+    description?: string;
+    image?: string;
+}
+
+export interface TransactionResult {
+    hash: string;
+    success: boolean;
+    error?: string;
+}
+
+export interface Balance {
+    balance: BN;
+    formatted: number;
+    decimal: number
+}
+
+
+export const SUPPORTED_VM = {
+    'EVM': EVMVM,
+    'SVM': SVMVM
+} as const;
+
+export type vmTypes = keyof typeof SUPPORTED_VM;