@octaflowlabs/onchain-sdk 1.0.0-test7 → 1.1.0

package/dist/blockchain/broadcastTransaction.d.ts

@@ -1,2 +1,2 @@
 import { BroadcastTransactionOptions } from '../types/common';
-export declare const broadcastTransaction: ({ signedTx, rpcUrl, waitConfirmations, }: BroadcastTransactionOptions) => Promise<string>;
+export declare const broadcastTransaction: ({ signedTx, rpcUrl, chainId, waitConfirmations, }: BroadcastTransactionOptions) => Promise<string>;

package/dist/blockchain/broadcastTransaction.js

@@ -2,8 +2,10 @@
 import { Transaction } from 'ethers';
 /** local imports */
 import { getProvider } from './getProvider';
-export const broadcastTransaction = async ({ signedTx, rpcUrl, waitConfirmations = 0, }) => {
-    const provider = getProvider(rpcUrl);
+export const broadcastTransaction = async ({ signedTx, rpcUrl, chainId, waitConfirmations = 0, }) => {
+    const provider = getProvider(rpcUrl, chainId);
+    if (!provider)
+        throw new Error('Could not create provider with given rpcUrl');
     try {
         Transaction.from(signedTx);
     }

package/dist/blockchain/buildUnsignedTransferTx.d.ts

@@ -1,2 +1,3 @@
-import { BuildUnsignedTransferTxOptions, UnsignedTransferTxResponse } from '../types/common';
+import { BuildMaxNativeTransferTxOptions, BuildMaxNativeTransferTxResponse, BuildUnsignedTransferTxOptions, UnsignedTransferTxResponse } from '../types/common';
 export declare const buildUnsignedTransferTx: (options: BuildUnsignedTransferTxOptions) => Promise<UnsignedTransferTxResponse>;
+export declare const buildMaxNativeTransferTx: (options: BuildMaxNativeTransferTxOptions) => Promise<BuildMaxNativeTransferTxResponse>;

package/dist/blockchain/buildUnsignedTransferTx.js

@@ -1,88 +1,132 @@
 /** npm imports */
-import { Interface, parseUnits } from 'ethers';
+import { Interface, formatUnits, parseUnits } from 'ethers';
 /** local imports */
 import { getProvider } from './getProvider';
 import { estimateGasLimitFromProvider } from './estimateGasLimitFromProvider';
 export const buildUnsignedTransferTx = async (options) => {
+    console.log({ options });
     const provider = getProvider(options.rpcUrl, options.chainId);
-    let unsignedTx = { to: options.tokenAddress };
-    const isNativeToken = !options.tokenAddress ||
-        options.tokenAddress?.toLowerCase() === '0x0000000000000000000000000000000000000000' ||
-        options.tokenAddress?.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
-    if (!isNativeToken) {
-        if (!options.tokenAddress)
-            throw new Error('Token address is required for token transfer');
-        const code = await provider.getCode(options.tokenAddress);
-        if (code === '0x' || code === '0x0')
-            throw new Error('Invalid token address');
-        const erc20Interface = new Interface(['function transfer(address to, uint256 amount)']);
-        const decimals = options.tokenDecimals ?? 18;
-        if (!options.value)
-            throw new Error('Value is required for token transfer');
-        const amountParsed = parseUnits(options.value, decimals);
-        unsignedTx = {
-            ...unsignedTx,
-            data: erc20Interface.encodeFunctionData('transfer', [options.toAddress, amountParsed]),
-            value: 0n,
-        };
-    }
-    else {
-        if (!options.value)
-            throw new Error('Native transfer requires value');
-        unsignedTx = {
-            to: options.toAddress,
-            data: '0x',
-            value: parseUnits(options.value, 18),
-        };
-    }
-    if (options.chainId)
-        unsignedTx.chainId = options.chainId;
-    const nonce = await provider.getTransactionCount(options.fromAddress, 'pending');
-    const estimateGas = await estimateGasLimitFromProvider({
-        provider: provider,
-        unsignedTx,
-        walletAddress: options.fromAddress,
-        defaultGasLimit: options.defaultGasLimit,
-    });
-    const unsignedTxToReturn = {
-        from: options.fromAddress,
-        to: unsignedTx.to,
-        data: unsignedTx.data,
-        value: unsignedTx.value?.toString(),
-        gasLimit: estimateGas.gasLimit.toString(),
-        chainId: unsignedTx.chainId,
-        nonce,
-        maxFeePerGas: estimateGas.feeData.maxFeePerGas?.toString(),
-        maxPriorityFeePerGas: estimateGas.feeData.maxPriorityFeePerGas?.toString(),
-    };
-    if (estimateGas.feeData.gasPrice)
-        unsignedTxToReturn.gasPrice = estimateGas.feeData.gasPrice.toString();
-    console.log('Built unsigned transfer transaction:', unsignedTxToReturn);
+    if (!provider)
+        throw new Error('Could not create provider with given rpcUrl and chainId');
     try {
-        await provider.call({
+        let unsignedTx = { to: options.tokenAddress };
+        const isNativeToken = !options.tokenAddress ||
+            options.tokenAddress?.toLowerCase() === '0x0000000000000000000000000000000000000000' ||
+            options.tokenAddress?.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+        if (!isNativeToken) {
+            if (!options.tokenAddress)
+                throw new Error('Token address is required for token transfer');
+            const code = await provider.getCode(options.tokenAddress);
+            if (code === '0x' || code === '0x0')
+                throw new Error('Invalid token address');
+            const erc20Interface = new Interface(['function transfer(address to, uint256 amount)']);
+            const decimals = options.tokenDecimals ?? 18;
+            if (!options.value)
+                throw new Error('Value is required for token transfer');
+            const amountParsed = parseUnits(options.value, decimals);
+            unsignedTx = {
+                ...unsignedTx,
+                data: erc20Interface.encodeFunctionData('transfer', [options.toAddress, amountParsed]),
+                value: 0n,
+            };
+        }
+        else {
+            if (!options.value)
+                throw new Error('Native transfer requires value');
+            unsignedTx = {
+                to: options.toAddress,
+                data: '0x',
+                value: parseUnits(options.value, 18),
+            };
+        }
+        if (options.chainId)
+            unsignedTx.chainId = options.chainId;
+        const nonce = await provider.getTransactionCount(options.fromAddress, 'pending');
+        const estimateGas = await estimateGasLimitFromProvider({
+            provider: provider,
+            unsignedTx,
+            walletAddress: options.fromAddress,
+            defaultGasLimit: options.defaultGasLimit,
+        });
+        const unsignedTxToReturn = {
             from: options.fromAddress,
             to: unsignedTx.to,
             data: unsignedTx.data,
-            value: unsignedTx.value,
-            gasLimit: estimateGas.gasLimit,
-        });
+            value: unsignedTx.value?.toString(),
+            gasLimit: estimateGas.gasLimit.toString(),
+            chainId: unsignedTx.chainId,
+            nonce,
+            maxFeePerGas: estimateGas.feeData.maxFeePerGas?.toString(),
+            maxPriorityFeePerGas: estimateGas.feeData.maxPriorityFeePerGas?.toString(),
+        };
+        if (estimateGas.feeData.gasPrice)
+            unsignedTxToReturn.gasPrice = estimateGas.feeData.gasPrice.toString();
+        const gasReserve = estimateGas.feeData.maxFeePerGas
+            ? estimateGas.gasLimit * estimateGas.feeData.maxFeePerGas
+            : estimateGas.feeData.gasPrice
+                ? estimateGas.gasLimit * estimateGas.feeData.gasPrice
+                : undefined;
+        console.log({ gasReserve: gasReserve?.toString() });
+        try {
+            await provider.call({
+                from: options.fromAddress,
+                to: unsignedTx.to,
+                data: unsignedTx.data,
+                value: unsignedTx.value,
+                gasLimit: estimateGas.gasLimit,
+            });
+        }
+        catch (error) {
+            throw new Error('Transaction would revert, provider call unsuccessful: ' + error.message || error);
+        }
+        console.log('Built unsigned transfer transaction:', unsignedTxToReturn);
+        return {
+            unsignedTx: unsignedTxToReturn,
+            nonce,
+            gasEstimated: estimateGas.gasEstimated.toString(),
+            gasLimit: estimateGas.gasLimit.toString(),
+            gasReserve: gasReserve?.toString(),
+            bufferPercentage: estimateGas.bufferPercentage,
+            feeData: {
+                maxFeePerGas: estimateGas.feeData.maxFeePerGas?.toString(),
+                maxPriorityFeePerGas: estimateGas.feeData.maxPriorityFeePerGas?.toString(),
+                gasPrice: estimateGas.feeData.gasPrice?.toString(),
+            },
+            //   suggestedGasFees: estimateGas.suggestedGasFees,
+            //   humanReadableFees: humanReadableGasEstimation,
+        };
     }
     catch (error) {
-        throw new Error('Transaction would revert, provider call unsuccessful: ' + error.message || error);
+        console.error('Error building unsigned transfer transaction:', error);
+        throw error;
     }
-    console.log('Built unsigned transfer transaction:', unsignedTxToReturn);
+};
+export const buildMaxNativeTransferTx = async (options) => {
+    const isNativeToken = !options.tokenAddress ||
+        options.tokenAddress?.toLowerCase() === '0x0000000000000000000000000000000000000000' ||
+        options.tokenAddress?.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+    if (!isNativeToken)
+        throw new Error('Max native transfer requires a native token address');
+    const provisionalTx = await buildUnsignedTransferTx({
+        ...options,
+        value: '0',
+        tokenAddress: options.tokenAddress,
+    });
+    if (!provisionalTx.gasReserve)
+        throw new Error('Could not determine gas reserve for max send');
+    const balanceWei = parseUnits(options.balance, 18);
+    const gasReserveWei = BigInt(provisionalTx.gasReserve);
+    const sendableWei = balanceWei - gasReserveWei;
+    if (sendableWei <= 0n)
+        throw new Error('Insufficient balance to cover gas reserve');
+    const sendableValue = formatUnits(sendableWei, 18);
+    const finalTx = await buildUnsignedTransferTx({
+        ...options,
+        value: sendableValue,
+        tokenAddress: options.tokenAddress,
+    });
     return {
-        unsignedTx: unsignedTxToReturn,
-        nonce,
-        gasEstimated: estimateGas.gasEstimated.toString(),
-        gasLimit: estimateGas.gasLimit.toString(),
-        bufferPercentage: estimateGas.bufferPercentage,
-        feeData: {
-            maxFeePerGas: estimateGas.feeData.maxFeePerGas?.toString(),
-            maxPriorityFeePerGas: estimateGas.feeData.maxPriorityFeePerGas?.toString(),
-            gasPrice: estimateGas.feeData.gasPrice?.toString(),
-        },
-        //   suggestedGasFees: estimateGas.suggestedGasFees,
-        //   humanReadableFees: humanReadableGasEstimation,
+        ...finalTx,
+        sendableValue,
     };
 };

package/dist/blockchain/estimateGasLimitFromProvider.js

@@ -1,6 +1,9 @@
 export const estimateGasLimitFromProvider = async ({ provider, unsignedTx, walletAddress, defaultGasLimit, }) => {
+    let lastFeeData = null;
+    let lastGasEstimated = null;
     try {
         const feeData = await provider.getFeeData();
+        lastFeeData = feeData;
         const txForEstimation = { ...unsignedTx, from: walletAddress };
         if (feeData.maxFeePerGas !== undefined)
             txForEstimation.maxFeePerGas = feeData.maxFeePerGas;
@@ -8,7 +11,9 @@ export const estimateGasLimitFromProvider = async ({ provider, unsignedTx, walle
             txForEstimation.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
         if (feeData.gasPrice !== undefined && txForEstimation.maxFeePerGas === undefined)
             txForEstimation.gasPrice = feeData.gasPrice;
+        console.log('Estimating gas with transaction:!!!!!! ', txForEstimation);
         const gasEstimated = await provider.estimateGas(txForEstimation);
+        lastGasEstimated = gasEstimated;
         let congestionFactor = 1.5;
         if (feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
             try {
@@ -40,12 +45,20 @@ export const estimateGasLimitFromProvider = async ({ provider, unsignedTx, walle
     catch (error) {
         console.error('Unable to estimate gas limit: ', error);
         console.log(`Setting default gas limit to: ${defaultGasLimit}`);
+        const feeData = lastFeeData;
+        const gasEstimated = lastGasEstimated ?? defaultGasLimit;
         return {
-            gasEstimated: defaultGasLimit,
+            gasEstimated,
             gasLimit: defaultGasLimit,
             bufferPercentage: 0,
             fallbackUsed: true,
-            feeData: {},
+            feeData: feeData
+                ? {
+                    maxFeePerGas: feeData.maxFeePerGas ?? undefined,
+                    maxPriorityFeePerGas: feeData.maxPriorityFeePerGas ?? undefined,
+                    gasPrice: feeData.gasPrice ?? undefined,
+                }
+                : {},
         };
     }
 };

package/dist/blockchain/getProvider.d.ts

@@ -1,3 +1,3 @@
 /** npm imports */
 import { JsonRpcProvider } from 'ethers';
-export declare const getProvider: (rpcUrl: string, chainId?: number) => JsonRpcProvider;
+export declare const getProvider: (rpcUrl: string, chainId?: number) => JsonRpcProvider | undefined;

package/dist/blockchain/getProvider.js

@@ -1,7 +1,16 @@
 /** npm imports */
-import { JsonRpcProvider } from 'ethers';
+import { JsonRpcProvider, Network } from 'ethers';
 export const getProvider = (rpcUrl, chainId) => {
-    const provider = new JsonRpcProvider(rpcUrl, { chainId });
-    console.log({ provider });
-    return provider;
+    try {
+        if (chainId) {
+            const network = Network.from(chainId);
+            return new JsonRpcProvider(rpcUrl, network, { staticNetwork: network });
+        }
+        else {
+            return new JsonRpcProvider(rpcUrl);
+        }
+    }
+    catch (error) {
+        console.warn('Could not create provider with chainId, falling back to rpcUrl only:', error);
+    }
 };

package/dist/blockchain/txStatus.js

@@ -2,6 +2,8 @@
 import { getProvider } from './getProvider';
 export const txStatus = async ({ rpcUrl, txHash, chainId, }) => {
     const provider = getProvider(rpcUrl, chainId);
+    if (!provider)
+        throw new Error('Could not create provider with given rpcUrl and chainId');
     try {
         const receipt = await provider.getTransactionReceipt(txHash);
         if (!receipt)

package/dist/cjs/blockchain/broadcastTransaction.d.ts

@@ -1,2 +1,2 @@
 import { BroadcastTransactionOptions } from '../types/common';
-export declare const broadcastTransaction: ({ signedTx, rpcUrl, waitConfirmations, }: BroadcastTransactionOptions) => Promise<string>;
+export declare const broadcastTransaction: ({ signedTx, rpcUrl, chainId, waitConfirmations, }: BroadcastTransactionOptions) => Promise<string>;

package/dist/cjs/blockchain/broadcastTransaction.js

@@ -5,8 +5,10 @@ exports.broadcastTransaction = void 0;
 const ethers_1 = require("ethers");
 /** local imports */
 const getProvider_1 = require("./getProvider");
-const broadcastTransaction = async ({ signedTx, rpcUrl, waitConfirmations = 0, }) => {
-    const provider = (0, getProvider_1.getProvider)(rpcUrl);
+const broadcastTransaction = async ({ signedTx, rpcUrl, chainId, waitConfirmations = 0, }) => {
+    const provider = (0, getProvider_1.getProvider)(rpcUrl, chainId);
+    if (!provider)
+        throw new Error('Could not create provider with given rpcUrl');
     try {
         ethers_1.Transaction.from(signedTx);
     }

package/dist/cjs/blockchain/buildUnsignedTransferTx.d.ts

@@ -1,2 +1,3 @@
-import { BuildUnsignedTransferTxOptions, UnsignedTransferTxResponse } from '../types/common';
+import { BuildMaxNativeTransferTxOptions, BuildMaxNativeTransferTxResponse, BuildUnsignedTransferTxOptions, UnsignedTransferTxResponse } from '../types/common';
 export declare const buildUnsignedTransferTx: (options: BuildUnsignedTransferTxOptions) => Promise<UnsignedTransferTxResponse>;
+export declare const buildMaxNativeTransferTx: (options: BuildMaxNativeTransferTxOptions) => Promise<BuildMaxNativeTransferTxResponse>;

package/dist/cjs/blockchain/buildUnsignedTransferTx.js

@@ -1,92 +1,137 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildUnsignedTransferTx = void 0;
+exports.buildMaxNativeTransferTx = exports.buildUnsignedTransferTx = void 0;
 /** npm imports */
 const ethers_1 = require("ethers");
 /** local imports */
 const getProvider_1 = require("./getProvider");
 const estimateGasLimitFromProvider_1 = require("./estimateGasLimitFromProvider");
 const buildUnsignedTransferTx = async (options) => {
+    console.log({ options });
     const provider = (0, getProvider_1.getProvider)(options.rpcUrl, options.chainId);
-    let unsignedTx = { to: options.tokenAddress };
-    const isNativeToken = !options.tokenAddress ||
-        options.tokenAddress?.toLowerCase() === '0x0000000000000000000000000000000000000000' ||
-        options.tokenAddress?.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
-    if (!isNativeToken) {
-        if (!options.tokenAddress)
-            throw new Error('Token address is required for token transfer');
-        const code = await provider.getCode(options.tokenAddress);
-        if (code === '0x' || code === '0x0')
-            throw new Error('Invalid token address');
-        const erc20Interface = new ethers_1.Interface(['function transfer(address to, uint256 amount)']);
-        const decimals = options.tokenDecimals ?? 18;
-        if (!options.value)
-            throw new Error('Value is required for token transfer');
-        const amountParsed = (0, ethers_1.parseUnits)(options.value, decimals);
-        unsignedTx = {
-            ...unsignedTx,
-            data: erc20Interface.encodeFunctionData('transfer', [options.toAddress, amountParsed]),
-            value: 0n,
-        };
-    }
-    else {
-        if (!options.value)
-            throw new Error('Native transfer requires value');
-        unsignedTx = {
-            to: options.toAddress,
-            data: '0x',
-            value: (0, ethers_1.parseUnits)(options.value, 18),
-        };
-    }
-    if (options.chainId)
-        unsignedTx.chainId = options.chainId;
-    const nonce = await provider.getTransactionCount(options.fromAddress, 'pending');
-    const estimateGas = await (0, estimateGasLimitFromProvider_1.estimateGasLimitFromProvider)({
-        provider: provider,
-        unsignedTx,
-        walletAddress: options.fromAddress,
-        defaultGasLimit: options.defaultGasLimit,
-    });
-    const unsignedTxToReturn = {
-        from: options.fromAddress,
-        to: unsignedTx.to,
-        data: unsignedTx.data,
-        value: unsignedTx.value?.toString(),
-        gasLimit: estimateGas.gasLimit.toString(),
-        chainId: unsignedTx.chainId,
-        nonce,
-        maxFeePerGas: estimateGas.feeData.maxFeePerGas?.toString(),
-        maxPriorityFeePerGas: estimateGas.feeData.maxPriorityFeePerGas?.toString(),
-    };
-    if (estimateGas.feeData.gasPrice)
-        unsignedTxToReturn.gasPrice = estimateGas.feeData.gasPrice.toString();
-    console.log('Built unsigned transfer transaction:', unsignedTxToReturn);
+    if (!provider)
+        throw new Error('Could not create provider with given rpcUrl and chainId');
     try {
-        await provider.call({
+        let unsignedTx = { to: options.tokenAddress };
+        const isNativeToken = !options.tokenAddress ||
+            options.tokenAddress?.toLowerCase() === '0x0000000000000000000000000000000000000000' ||
+            options.tokenAddress?.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+        if (!isNativeToken) {
+            if (!options.tokenAddress)
+                throw new Error('Token address is required for token transfer');
+            const code = await provider.getCode(options.tokenAddress);
+            if (code === '0x' || code === '0x0')
+                throw new Error('Invalid token address');
+            const erc20Interface = new ethers_1.Interface(['function transfer(address to, uint256 amount)']);
+            const decimals = options.tokenDecimals ?? 18;
+            if (!options.value)
+                throw new Error('Value is required for token transfer');
+            const amountParsed = (0, ethers_1.parseUnits)(options.value, decimals);
+            unsignedTx = {
+                ...unsignedTx,
+                data: erc20Interface.encodeFunctionData('transfer', [options.toAddress, amountParsed]),
+                value: 0n,
+            };
+        }
+        else {
+            if (!options.value)
+                throw new Error('Native transfer requires value');
+            unsignedTx = {
+                to: options.toAddress,
+                data: '0x',
+                value: (0, ethers_1.parseUnits)(options.value, 18),
+            };
+        }
+        if (options.chainId)
+            unsignedTx.chainId = options.chainId;
+        const nonce = await provider.getTransactionCount(options.fromAddress, 'pending');
+        const estimateGas = await (0, estimateGasLimitFromProvider_1.estimateGasLimitFromProvider)({
+            provider: provider,
+            unsignedTx,
+            walletAddress: options.fromAddress,
+            defaultGasLimit: options.defaultGasLimit,
+        });
+        const unsignedTxToReturn = {
             from: options.fromAddress,
             to: unsignedTx.to,
             data: unsignedTx.data,
-            value: unsignedTx.value,
-            gasLimit: estimateGas.gasLimit,
-        });
+            value: unsignedTx.value?.toString(),
+            gasLimit: estimateGas.gasLimit.toString(),
+            chainId: unsignedTx.chainId,
+            nonce,
+            maxFeePerGas: estimateGas.feeData.maxFeePerGas?.toString(),
+            maxPriorityFeePerGas: estimateGas.feeData.maxPriorityFeePerGas?.toString(),
+        };
+        if (estimateGas.feeData.gasPrice)
+            unsignedTxToReturn.gasPrice = estimateGas.feeData.gasPrice.toString();
+        const gasReserve = estimateGas.feeData.maxFeePerGas
+            ? estimateGas.gasLimit * estimateGas.feeData.maxFeePerGas
+            : estimateGas.feeData.gasPrice
+                ? estimateGas.gasLimit * estimateGas.feeData.gasPrice
+                : undefined;
+        console.log({ gasReserve: gasReserve?.toString() });
+        try {
+            await provider.call({
+                from: options.fromAddress,
+                to: unsignedTx.to,
+                data: unsignedTx.data,
+                value: unsignedTx.value,
+                gasLimit: estimateGas.gasLimit,
+            });
+        }
+        catch (error) {
+            throw new Error('Transaction would revert, provider call unsuccessful: ' + error.message || error);
+        }
+        console.log('Built unsigned transfer transaction:', unsignedTxToReturn);
+        return {
+            unsignedTx: unsignedTxToReturn,
+            nonce,
+            gasEstimated: estimateGas.gasEstimated.toString(),
+            gasLimit: estimateGas.gasLimit.toString(),
+            gasReserve: gasReserve?.toString(),
+            bufferPercentage: estimateGas.bufferPercentage,
+            feeData: {
+                maxFeePerGas: estimateGas.feeData.maxFeePerGas?.toString(),
+                maxPriorityFeePerGas: estimateGas.feeData.maxPriorityFeePerGas?.toString(),
+                gasPrice: estimateGas.feeData.gasPrice?.toString(),
+            },
+            //   suggestedGasFees: estimateGas.suggestedGasFees,
+            //   humanReadableFees: humanReadableGasEstimation,
+        };
     }
     catch (error) {
-        throw new Error('Transaction would revert, provider call unsuccessful: ' + error.message || error);
+        console.error('Error building unsigned transfer transaction:', error);
+        throw error;
     }
-    console.log('Built unsigned transfer transaction:', unsignedTxToReturn);
+};
+exports.buildUnsignedTransferTx = buildUnsignedTransferTx;
+const buildMaxNativeTransferTx = async (options) => {
+    const isNativeToken = !options.tokenAddress ||
+        options.tokenAddress?.toLowerCase() === '0x0000000000000000000000000000000000000000' ||
+        options.tokenAddress?.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+    if (!isNativeToken)
+        throw new Error('Max native transfer requires a native token address');
+    const provisionalTx = await (0, exports.buildUnsignedTransferTx)({
+        ...options,
+        value: '0',
+        tokenAddress: options.tokenAddress,
+    });
+    if (!provisionalTx.gasReserve)
+        throw new Error('Could not determine gas reserve for max send');
+    const balanceWei = (0, ethers_1.parseUnits)(options.balance, 18);
+    const gasReserveWei = BigInt(provisionalTx.gasReserve);
+    const sendableWei = balanceWei - gasReserveWei;
+    if (sendableWei <= 0n)
+        throw new Error('Insufficient balance to cover gas reserve');
+    const sendableValue = (0, ethers_1.formatUnits)(sendableWei, 18);
+    const finalTx = await (0, exports.buildUnsignedTransferTx)({
+        ...options,
+        value: sendableValue,
+        tokenAddress: options.tokenAddress,
+    });
     return {
-        unsignedTx: unsignedTxToReturn,
-        nonce,
-        gasEstimated: estimateGas.gasEstimated.toString(),
-        gasLimit: estimateGas.gasLimit.toString(),
-        bufferPercentage: estimateGas.bufferPercentage,
-        feeData: {
-            maxFeePerGas: estimateGas.feeData.maxFeePerGas?.toString(),
-            maxPriorityFeePerGas: estimateGas.feeData.maxPriorityFeePerGas?.toString(),
-            gasPrice: estimateGas.feeData.gasPrice?.toString(),
-        },
-        //   suggestedGasFees: estimateGas.suggestedGasFees,
-        //   humanReadableFees: humanReadableGasEstimation,
+        ...finalTx,
+        sendableValue,
     };
 };
-exports.buildUnsignedTransferTx = buildUnsignedTransferTx;
+exports.buildMaxNativeTransferTx = buildMaxNativeTransferTx;

package/dist/cjs/blockchain/estimateGasLimitFromProvider.js

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.estimateGasLimitFromProvider = void 0;
 const estimateGasLimitFromProvider = async ({ provider, unsignedTx, walletAddress, defaultGasLimit, }) => {
+    let lastFeeData = null;
+    let lastGasEstimated = null;
     try {
         const feeData = await provider.getFeeData();
+        lastFeeData = feeData;
         const txForEstimation = { ...unsignedTx, from: walletAddress };
         if (feeData.maxFeePerGas !== undefined)
             txForEstimation.maxFeePerGas = feeData.maxFeePerGas;
@@ -11,7 +14,9 @@ const estimateGasLimitFromProvider = async ({ provider, unsignedTx, walletAddres
             txForEstimation.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
         if (feeData.gasPrice !== undefined && txForEstimation.maxFeePerGas === undefined)
             txForEstimation.gasPrice = feeData.gasPrice;
+        console.log('Estimating gas with transaction:!!!!!! ', txForEstimation);
         const gasEstimated = await provider.estimateGas(txForEstimation);
+        lastGasEstimated = gasEstimated;
         let congestionFactor = 1.5;
         if (feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
             try {
@@ -43,12 +48,20 @@ const estimateGasLimitFromProvider = async ({ provider, unsignedTx, walletAddres
     catch (error) {
         console.error('Unable to estimate gas limit: ', error);
         console.log(`Setting default gas limit to: ${defaultGasLimit}`);
+        const feeData = lastFeeData;
+        const gasEstimated = lastGasEstimated ?? defaultGasLimit;
         return {
-            gasEstimated: defaultGasLimit,
+            gasEstimated,
             gasLimit: defaultGasLimit,
             bufferPercentage: 0,
             fallbackUsed: true,
-            feeData: {},
+            feeData: feeData
+                ? {
+                    maxFeePerGas: feeData.maxFeePerGas ?? undefined,
+                    maxPriorityFeePerGas: feeData.maxPriorityFeePerGas ?? undefined,
+                    gasPrice: feeData.gasPrice ?? undefined,
+                }
+                : {},
         };
     }
 };

package/dist/cjs/blockchain/getProvider.d.ts

@@ -1,3 +1,3 @@
 /** npm imports */
 import { JsonRpcProvider } from 'ethers';
-export declare const getProvider: (rpcUrl: string, chainId?: number) => JsonRpcProvider;
+export declare const getProvider: (rpcUrl: string, chainId?: number) => JsonRpcProvider | undefined;

package/dist/cjs/blockchain/getProvider.js

@@ -4,8 +4,17 @@ exports.getProvider = void 0;
 /** npm imports */
 const ethers_1 = require("ethers");
 const getProvider = (rpcUrl, chainId) => {
-    const provider = new ethers_1.JsonRpcProvider(rpcUrl, { chainId });
-    console.log({ provider });
-    return provider;
+    try {
+        if (chainId) {
+            const network = ethers_1.Network.from(chainId);
+            return new ethers_1.JsonRpcProvider(rpcUrl, network, { staticNetwork: network });
+        }
+        else {
+            return new ethers_1.JsonRpcProvider(rpcUrl);
+        }
+    }
+    catch (error) {
+        console.warn('Could not create provider with chainId, falling back to rpcUrl only:', error);
+    }
 };
 exports.getProvider = getProvider;

package/dist/cjs/blockchain/txStatus.js

@@ -5,6 +5,8 @@ exports.txStatus = void 0;
 const getProvider_1 = require("./getProvider");
 const txStatus = async ({ rpcUrl, txHash, chainId, }) => {
     const provider = (0, getProvider_1.getProvider)(rpcUrl, chainId);
+    if (!provider)
+        throw new Error('Could not create provider with given rpcUrl and chainId');
     try {
         const receipt = await provider.getTransactionReceipt(txHash);
         if (!receipt)

package/dist/cjs/index.d.ts

@@ -4,15 +4,20 @@ export { ERC20_TOKEN_CONTRACT_ABI };
 /** constants exports */
 export { GAS_LIMIT_PER_TX_TYPE } from './constants/constants';
 /** basic blockchain exports */
-export { buildUnsignedTransferTx } from './blockchain/buildUnsignedTransferTx';
+export { buildMaxNativeTransferTx, buildUnsignedTransferTx, } from './blockchain/buildUnsignedTransferTx';
 export { broadcastTransaction } from './blockchain/broadcastTransaction';
 export { estimateGasLimitFromProvider } from './blockchain/estimateGasLimitFromProvider';
 export { getProvider } from './blockchain/getProvider';
 export { txStatus } from './blockchain/txStatus';
+/** services exports */
+export { EvmWalletService, EvmGeneratedWallet, EvmDerivedWallet, } from './services/evm-wallet-core/evmWalletService';
+export { EntropySource } from './services/evm-wallet-core/entropy';
+export { createWallet, signMessage, signTransaction } from './services/evm-wallet-core/signer';
 /** utils exports */
 export { getShortenTransactionHash } from './utils/getShortenTxHash';
 export { transformBigInt } from './utils/transformBigInt';
 import NATIVE_TOKENS from './utils/tokens';
 export { NATIVE_TOKENS };
+export { formattedAmountForDisplay, parsedAmount } from './utils/formatAmount';
 /** types exports */
-export { BroadcastTransactionOptions, BuildUnsignedTransferTxOptions, EstimateGasLimitFromProviderProps, GasEstimateResult, TxStatusOptions, TxStatusResponse, UnsignedTransferTxResponse, } from './types/common';
+export { BroadcastTransactionOptions, BuildMaxNativeTransferTxOptions, BuildMaxNativeTransferTxResponse, BuildUnsignedTransferTxOptions, EstimateGasLimitFromProviderProps, GasEstimateResult, TxStatusOptions, TxStatusResponse, UnsignedTransferTxResponse, FormatAmountOptions, TransactionRequest, } from './types/common';

package/dist/cjs/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NATIVE_TOKENS = exports.transformBigInt = exports.getShortenTransactionHash = exports.txStatus = exports.getProvider = exports.estimateGasLimitFromProvider = exports.broadcastTransaction = exports.buildUnsignedTransferTx = exports.GAS_LIMIT_PER_TX_TYPE = exports.ERC20_TOKEN_CONTRACT_ABI = void 0;
+exports.parsedAmount = exports.formattedAmountForDisplay = exports.NATIVE_TOKENS = exports.transformBigInt = exports.getShortenTransactionHash = exports.signTransaction = exports.signMessage = exports.createWallet = exports.EvmWalletService = exports.txStatus = exports.getProvider = exports.estimateGasLimitFromProvider = exports.broadcastTransaction = exports.buildUnsignedTransferTx = exports.buildMaxNativeTransferTx = exports.GAS_LIMIT_PER_TX_TYPE = exports.ERC20_TOKEN_CONTRACT_ABI = void 0;
 /** ABIs exports */
 const ERC20_TOKEN_CONTRACT_ABI_1 = __importDefault(require("./ABIs/ERC20_TOKEN_CONTRACT_ABI"));
 exports.ERC20_TOKEN_CONTRACT_ABI = ERC20_TOKEN_CONTRACT_ABI_1.default;
@@ -12,6 +12,7 @@ var constants_1 = require("./constants/constants");
 Object.defineProperty(exports, "GAS_LIMIT_PER_TX_TYPE", { enumerable: true, get: function () { return constants_1.GAS_LIMIT_PER_TX_TYPE; } });
 /** basic blockchain exports */
 var buildUnsignedTransferTx_1 = require("./blockchain/buildUnsignedTransferTx");
+Object.defineProperty(exports, "buildMaxNativeTransferTx", { enumerable: true, get: function () { return buildUnsignedTransferTx_1.buildMaxNativeTransferTx; } });
 Object.defineProperty(exports, "buildUnsignedTransferTx", { enumerable: true, get: function () { return buildUnsignedTransferTx_1.buildUnsignedTransferTx; } });
 var broadcastTransaction_1 = require("./blockchain/broadcastTransaction");
 Object.defineProperty(exports, "broadcastTransaction", { enumerable: true, get: function () { return broadcastTransaction_1.broadcastTransaction; } });
@@ -21,6 +22,13 @@ var getProvider_1 = require("./blockchain/getProvider");
 Object.defineProperty(exports, "getProvider", { enumerable: true, get: function () { return getProvider_1.getProvider; } });
 var txStatus_1 = require("./blockchain/txStatus");
 Object.defineProperty(exports, "txStatus", { enumerable: true, get: function () { return txStatus_1.txStatus; } });
+/** services exports */
+var evmWalletService_1 = require("./services/evm-wallet-core/evmWalletService");
+Object.defineProperty(exports, "EvmWalletService", { enumerable: true, get: function () { return evmWalletService_1.EvmWalletService; } });
+var signer_1 = require("./services/evm-wallet-core/signer");
+Object.defineProperty(exports, "createWallet", { enumerable: true, get: function () { return signer_1.createWallet; } });
+Object.defineProperty(exports, "signMessage", { enumerable: true, get: function () { return signer_1.signMessage; } });
+Object.defineProperty(exports, "signTransaction", { enumerable: true, get: function () { return signer_1.signTransaction; } });
 /** utils exports */
 var getShortenTxHash_1 = require("./utils/getShortenTxHash");
 Object.defineProperty(exports, "getShortenTransactionHash", { enumerable: true, get: function () { return getShortenTxHash_1.getShortenTransactionHash; } });
@@ -28,3 +36,6 @@ var transformBigInt_1 = require("./utils/transformBigInt");
 Object.defineProperty(exports, "transformBigInt", { enumerable: true, get: function () { return transformBigInt_1.transformBigInt; } });
 const tokens_1 = __importDefault(require("./utils/tokens"));
 exports.NATIVE_TOKENS = tokens_1.default;
+var formatAmount_1 = require("./utils/formatAmount");
+Object.defineProperty(exports, "formattedAmountForDisplay", { enumerable: true, get: function () { return formatAmount_1.formattedAmountForDisplay; } });
+Object.defineProperty(exports, "parsedAmount", { enumerable: true, get: function () { return formatAmount_1.parsedAmount; } });

package/dist/cjs/services/evm-wallet-core/entropy.d.ts

@@ -0,0 +1,3 @@
+export interface EntropySource {
+    randomBytes(length: number): Uint8Array;
+}

package/dist/cjs/services/evm-wallet-core/entropy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/services/evm-wallet-core/evmWalletService.d.ts

@@ -0,0 +1,27 @@
+/** local imports */
+import { EntropySource } from './entropy';
+export interface EvmGeneratedWallet {
+    address: string;
+    mnemonic: string;
+    privateKey: string;
+    path: string;
+}
+export interface EvmDerivedWallet {
+    address: string;
+    privateKey: string;
+    path: string;
+    publicKey: string;
+}
+export declare class EvmWalletService {
+    private entropy;
+    private readonly DEFAULT_DERIVATION_PATH;
+    constructor(entropy: EntropySource);
+    generateNewWallet(accountIndex?: number, wordCount?: 12 | 15 | 18 | 21 | 24): EvmGeneratedWallet;
+    generateMultipleWallets(mnemonic: string, count: number, startIndex?: number): EvmDerivedWallet[];
+    deriveWalletFromMnemonic(mnemonic: string, accountIndex?: number, customPath?: string): EvmDerivedWallet;
+    deriveFromPrivateKey(privateKey: string): Omit<EvmDerivedWallet, 'path'>;
+    signMessage(privateKey: string, message: string): Promise<string>;
+    isValidMnemonic(mnemonic: string): boolean;
+    private validateMnemonic;
+    private getEntropyForWordCount;
+}

package/dist/cjs/services/evm-wallet-core/evmWalletService.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmWalletService = void 0;
+/** npm imports */
+const ethers_1 = require("ethers");
+class EvmWalletService {
+    constructor(entropy) {
+        this.entropy = entropy;
+        this.DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0";
+    }
+    generateNewWallet(accountIndex = 0, wordCount = 12) {
+        const entropy = this.getEntropyForWordCount(wordCount);
+        const randomBytesArray = this.entropy.randomBytes(entropy);
+        const customMnemonic = ethers_1.Mnemonic.fromEntropy(randomBytesArray);
+        const path = `${this.DEFAULT_DERIVATION_PATH}/${accountIndex}`;
+        const hdNode = ethers_1.HDNodeWallet.fromMnemonic(customMnemonic, path);
+        return {
+            address: hdNode.address,
+            mnemonic: customMnemonic.phrase,
+            privateKey: hdNode.privateKey,
+            path,
+        };
+    }
+    generateMultipleWallets(mnemonic, count, startIndex = 0) {
+        this.validateMnemonic(mnemonic);
+        const wallets = [];
+        const mnemonicObject = ethers_1.Mnemonic.fromPhrase(mnemonic);
+        for (let i = 0; i < count; i++) {
+            const accountIndex = startIndex + i;
+            const path = `${this.DEFAULT_DERIVATION_PATH}/${accountIndex}`;
+            const hdNode = ethers_1.HDNodeWallet.fromMnemonic(mnemonicObject, path);
+            wallets.push({
+                address: hdNode.address,
+                privateKey: hdNode.privateKey,
+                path,
+                publicKey: hdNode.publicKey,
+            });
+        }
+        return wallets;
+    }
+    deriveWalletFromMnemonic(mnemonic, accountIndex = 0, customPath) {
+        this.validateMnemonic(mnemonic);
+        const path = customPath || `${this.DEFAULT_DERIVATION_PATH}/${accountIndex}`;
+        const mnemonicObject = ethers_1.Mnemonic.fromPhrase(mnemonic);
+        const hdNode = ethers_1.HDNodeWallet.fromMnemonic(mnemonicObject, path);
+        return {
+            address: hdNode.address,
+            privateKey: hdNode.privateKey,
+            path,
+            publicKey: hdNode.publicKey,
+        };
+    }
+    deriveFromPrivateKey(privateKey) {
+        const wallet = new ethers_1.Wallet(privateKey);
+        return {
+            address: wallet.address,
+            privateKey: wallet.privateKey,
+            publicKey: wallet.signingKey.publicKey,
+        };
+    }
+    async signMessage(privateKey, message) {
+        const wallet = new ethers_1.Wallet(privateKey);
+        return await wallet.signMessage(message);
+    }
+    isValidMnemonic(mnemonic) {
+        try {
+            ethers_1.Mnemonic.fromPhrase(mnemonic);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    validateMnemonic(mnemonic) {
+        if (!this.isValidMnemonic(mnemonic)) {
+            throw new Error('Invalid mnemonic phrase');
+        }
+    }
+    getEntropyForWordCount(wordCount) {
+        const entropyMap = {
+            12: 16, // 128 bits
+            15: 20, // 160 bits
+            18: 24, // 192 bits
+            21: 28, // 224 bits
+            24: 32, // 256 bits
+        };
+        return entropyMap[wordCount];
+    }
+}
+exports.EvmWalletService = EvmWalletService;

package/dist/cjs/services/evm-wallet-core/signer.d.ts

@@ -0,0 +1,7 @@
+/** npm imports */
+import { Wallet } from 'ethers';
+/** local imports */
+import { TransactionRequest } from '../../types/common';
+export declare const createWallet: (privateKey: string, rpcUrl?: string) => Wallet;
+export declare const signMessage: (privateKey: string, message: string) => Promise<string>;
+export declare const signTransaction: (privateKey: string, tx: TransactionRequest, rpcUrl?: string) => Promise<string>;

package/dist/cjs/services/evm-wallet-core/signer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTransaction = exports.signMessage = exports.createWallet = void 0;
+/** npm imports */
+const ethers_1 = require("ethers");
+const createWallet = (privateKey, rpcUrl) => new ethers_1.Wallet(privateKey, rpcUrl ? new ethers_1.JsonRpcProvider(rpcUrl) : undefined);
+exports.createWallet = createWallet;
+const signMessage = async (privateKey, message) => {
+    const wallet = (0, exports.createWallet)(privateKey);
+    return wallet.signMessage(message);
+};
+exports.signMessage = signMessage;
+const signTransaction = async (privateKey, tx, rpcUrl) => {
+    const wallet = (0, exports.createWallet)(privateKey, rpcUrl);
+    return wallet.signTransaction(tx);
+};
+exports.signTransaction = signTransaction;

package/dist/cjs/types/common.d.ts

@@ -33,6 +33,7 @@ export interface UnsignedTransferTxResponse {
     nonce: number;
     gasEstimated: string;
     gasLimit: string;
+    gasReserve?: string;
     bufferPercentage: number;
     feeData: {
         maxFeePerGas?: string;
@@ -40,9 +41,17 @@ export interface UnsignedTransferTxResponse {
         gasPrice?: string;
     };
 }
+export interface BuildMaxNativeTransferTxOptions extends Omit<BuildUnsignedTransferTxOptions, 'value' | 'tokenAddress' | 'tokenDecimals'> {
+    balance: string;
+    tokenAddress?: string;
+}
+export interface BuildMaxNativeTransferTxResponse extends UnsignedTransferTxResponse {
+    sendableValue: string;
+}
 export interface BroadcastTransactionOptions {
     signedTx: string;
     rpcUrl: string;
+    chainId?: number;
     waitConfirmations?: number;
 }
 export interface TxStatusOptions {
@@ -54,3 +63,12 @@ export interface TxStatusResponse {
     success: boolean;
     receipt: TransactionReceipt | null;
 }
+export interface FormatAmountOptions {
+    decimalsToShow?: number;
+    useGroupSeparator?: boolean;
+    locale?: string;
+    minimumFractionDigits?: number;
+    minDisplayDecimals?: number;
+    maxDisplayDigits?: number;
+}
+export type { TransactionRequest };

package/dist/cjs/utils/formatAmount.d.ts

@@ -0,0 +1,6 @@
+/** npm imports */
+import { BigNumberish } from 'ethers';
+/** local imports */
+import { FormatAmountOptions } from '../types/common';
+export declare const formattedAmountForDisplay: (amount: BigNumberish, decimals: number, options?: FormatAmountOptions) => string;
+export declare const parsedAmount: (amount: string, decimals: number) => bigint;

package/dist/cjs/utils/formatAmount.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsedAmount = exports.formattedAmountForDisplay = void 0;
+/** npm imports */
+const ethers_1 = require("ethers");
+const formattedAmountForDisplay = (amount, decimals, options = {}) => {
+    const { decimalsToShow = 0, useGroupSeparator = true, locale = 'en-US', minimumFractionDigits, minDisplayDecimals = 9, maxDisplayDigits = 16, } = options;
+    const formattedAmount = (0, ethers_1.formatUnits)(amount, decimals);
+    if (formattedAmount.startsWith('-')) {
+        throw new Error('Negative balances are not supported');
+    }
+    const [wholePart = '0', fractionPart = ''] = formattedAmount.split('.');
+    if (wholePart.length >= maxDisplayDigits) {
+        const mantissaWhole = wholePart[0] ?? '0';
+        const mantissaFraction = (wholePart.slice(1) + fractionPart).slice(0, decimalsToShow);
+        const exponent = wholePart.length - 1;
+        const rawMantissa = mantissaFraction ? `${mantissaWhole}.${mantissaFraction}` : mantissaWhole;
+        const trimmedMantissa = rawMantissa.replace(/\.0+$|(?<=\.[0-9]*?)0+$/g, '').replace(/\.$/, '');
+        return `${trimmedMantissa}e${exponent}`;
+    }
+    const firstNonZeroIndex = fractionPart.split('').findIndex((digit) => digit !== '0');
+    const hasNonZeroFraction = firstNonZeroIndex !== -1;
+    if (hasNonZeroFraction && wholePart === '0' && firstNonZeroIndex >= minDisplayDecimals) {
+        const sample = new Intl.NumberFormat(locale).format(1000.1);
+        const decimalSeparator = sample.replace(/\d/g, '').slice(-1) ?? '.';
+        const minValue = `0${decimalSeparator}${'0'.repeat(Math.max(0, minDisplayDecimals - 1))}1`;
+        return `< ${minValue}`;
+    }
+    if (!hasNonZeroFraction) {
+        const sample = new Intl.NumberFormat(locale).format(1000.1);
+        const groupSeparator = sample.replace(/\d/g, '')[0] ?? ',';
+        const groupedWhole = useGroupSeparator
+            ? (wholePart || '0').replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator)
+            : wholePart;
+        return groupedWhole;
+    }
+    const maxDecimals = decimalsToShow ?? fractionPart.length;
+    let trimmedFraction = fractionPart.slice(0, Math.max(0, maxDecimals));
+    const minDecimals = minimumFractionDigits ?? 0;
+    if (trimmedFraction.length < minDecimals) {
+        trimmedFraction = trimmedFraction.padEnd(minDecimals, '0');
+    }
+    const sample = new Intl.NumberFormat(locale).format(1000.1);
+    const groupSeparator = sample.replace(/\d/g, '')[0] ?? ',';
+    const decimalSeparator = sample.replace(/\d/g, '').slice(-1) ?? '.';
+    const groupedWhole = useGroupSeparator
+        ? (wholePart || '0').replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator)
+        : wholePart;
+    if (!trimmedFraction)
+        return groupedWhole;
+    return `${groupedWhole}${decimalSeparator}${trimmedFraction}`;
+};
+exports.formattedAmountForDisplay = formattedAmountForDisplay;
+const parsedAmount = (amount, decimals) => (0, ethers_1.parseUnits)(amount, decimals);
+exports.parsedAmount = parsedAmount;

package/dist/index.d.ts

@@ -4,15 +4,20 @@ export { ERC20_TOKEN_CONTRACT_ABI };
 /** constants exports */
 export { GAS_LIMIT_PER_TX_TYPE } from './constants/constants';
 /** basic blockchain exports */
-export { buildUnsignedTransferTx } from './blockchain/buildUnsignedTransferTx';
+export { buildMaxNativeTransferTx, buildUnsignedTransferTx, } from './blockchain/buildUnsignedTransferTx';
 export { broadcastTransaction } from './blockchain/broadcastTransaction';
 export { estimateGasLimitFromProvider } from './blockchain/estimateGasLimitFromProvider';
 export { getProvider } from './blockchain/getProvider';
 export { txStatus } from './blockchain/txStatus';
+/** services exports */
+export { EvmWalletService, EvmGeneratedWallet, EvmDerivedWallet, } from './services/evm-wallet-core/evmWalletService';
+export { EntropySource } from './services/evm-wallet-core/entropy';
+export { createWallet, signMessage, signTransaction } from './services/evm-wallet-core/signer';
 /** utils exports */
 export { getShortenTransactionHash } from './utils/getShortenTxHash';
 export { transformBigInt } from './utils/transformBigInt';
 import NATIVE_TOKENS from './utils/tokens';
 export { NATIVE_TOKENS };
+export { formattedAmountForDisplay, parsedAmount } from './utils/formatAmount';
 /** types exports */
-export { BroadcastTransactionOptions, BuildUnsignedTransferTxOptions, EstimateGasLimitFromProviderProps, GasEstimateResult, TxStatusOptions, TxStatusResponse, UnsignedTransferTxResponse, } from './types/common';
+export { BroadcastTransactionOptions, BuildMaxNativeTransferTxOptions, BuildMaxNativeTransferTxResponse, BuildUnsignedTransferTxOptions, EstimateGasLimitFromProviderProps, GasEstimateResult, TxStatusOptions, TxStatusResponse, UnsignedTransferTxResponse, FormatAmountOptions, TransactionRequest, } from './types/common';

package/dist/index.js

@@ -4,13 +4,17 @@ export { ERC20_TOKEN_CONTRACT_ABI };
 /** constants exports */
 export { GAS_LIMIT_PER_TX_TYPE } from './constants/constants';
 /** basic blockchain exports */
-export { buildUnsignedTransferTx } from './blockchain/buildUnsignedTransferTx';
+export { buildMaxNativeTransferTx, buildUnsignedTransferTx, } from './blockchain/buildUnsignedTransferTx';
 export { broadcastTransaction } from './blockchain/broadcastTransaction';
 export { estimateGasLimitFromProvider } from './blockchain/estimateGasLimitFromProvider';
 export { getProvider } from './blockchain/getProvider';
 export { txStatus } from './blockchain/txStatus';
+/** services exports */
+export { EvmWalletService, } from './services/evm-wallet-core/evmWalletService';
+export { createWallet, signMessage, signTransaction } from './services/evm-wallet-core/signer';
 /** utils exports */
 export { getShortenTransactionHash } from './utils/getShortenTxHash';
 export { transformBigInt } from './utils/transformBigInt';
 import NATIVE_TOKENS from './utils/tokens';
 export { NATIVE_TOKENS };
+export { formattedAmountForDisplay, parsedAmount } from './utils/formatAmount';

package/dist/services/evm-wallet-core/entropy.d.ts

@@ -0,0 +1,3 @@
+export interface EntropySource {
+    randomBytes(length: number): Uint8Array;
+}

package/dist/services/evm-wallet-core/entropy.js

@@ -0,0 +1 @@
+export {};

package/dist/services/evm-wallet-core/evmWalletService.d.ts

@@ -0,0 +1,27 @@
+/** local imports */
+import { EntropySource } from './entropy';
+export interface EvmGeneratedWallet {
+    address: string;
+    mnemonic: string;
+    privateKey: string;
+    path: string;
+}
+export interface EvmDerivedWallet {
+    address: string;
+    privateKey: string;
+    path: string;
+    publicKey: string;
+}
+export declare class EvmWalletService {
+    private entropy;
+    private readonly DEFAULT_DERIVATION_PATH;
+    constructor(entropy: EntropySource);
+    generateNewWallet(accountIndex?: number, wordCount?: 12 | 15 | 18 | 21 | 24): EvmGeneratedWallet;
+    generateMultipleWallets(mnemonic: string, count: number, startIndex?: number): EvmDerivedWallet[];
+    deriveWalletFromMnemonic(mnemonic: string, accountIndex?: number, customPath?: string): EvmDerivedWallet;
+    deriveFromPrivateKey(privateKey: string): Omit<EvmDerivedWallet, 'path'>;
+    signMessage(privateKey: string, message: string): Promise<string>;
+    isValidMnemonic(mnemonic: string): boolean;
+    private validateMnemonic;
+    private getEntropyForWordCount;
+}

package/dist/services/evm-wallet-core/evmWalletService.js

@@ -0,0 +1,86 @@
+/** npm imports */
+import { Wallet, HDNodeWallet, Mnemonic } from 'ethers';
+export class EvmWalletService {
+    constructor(entropy) {
+        this.entropy = entropy;
+        this.DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0";
+    }
+    generateNewWallet(accountIndex = 0, wordCount = 12) {
+        const entropy = this.getEntropyForWordCount(wordCount);
+        const randomBytesArray = this.entropy.randomBytes(entropy);
+        const customMnemonic = Mnemonic.fromEntropy(randomBytesArray);
+        const path = `${this.DEFAULT_DERIVATION_PATH}/${accountIndex}`;
+        const hdNode = HDNodeWallet.fromMnemonic(customMnemonic, path);
+        return {
+            address: hdNode.address,
+            mnemonic: customMnemonic.phrase,
+            privateKey: hdNode.privateKey,
+            path,
+        };
+    }
+    generateMultipleWallets(mnemonic, count, startIndex = 0) {
+        this.validateMnemonic(mnemonic);
+        const wallets = [];
+        const mnemonicObject = Mnemonic.fromPhrase(mnemonic);
+        for (let i = 0; i < count; i++) {
+            const accountIndex = startIndex + i;
+            const path = `${this.DEFAULT_DERIVATION_PATH}/${accountIndex}`;
+            const hdNode = HDNodeWallet.fromMnemonic(mnemonicObject, path);
+            wallets.push({
+                address: hdNode.address,
+                privateKey: hdNode.privateKey,
+                path,
+                publicKey: hdNode.publicKey,
+            });
+        }
+        return wallets;
+    }
+    deriveWalletFromMnemonic(mnemonic, accountIndex = 0, customPath) {
+        this.validateMnemonic(mnemonic);
+        const path = customPath || `${this.DEFAULT_DERIVATION_PATH}/${accountIndex}`;
+        const mnemonicObject = Mnemonic.fromPhrase(mnemonic);
+        const hdNode = HDNodeWallet.fromMnemonic(mnemonicObject, path);
+        return {
+            address: hdNode.address,
+            privateKey: hdNode.privateKey,
+            path,
+            publicKey: hdNode.publicKey,
+        };
+    }
+    deriveFromPrivateKey(privateKey) {
+        const wallet = new Wallet(privateKey);
+        return {
+            address: wallet.address,
+            privateKey: wallet.privateKey,
+            publicKey: wallet.signingKey.publicKey,
+        };
+    }
+    async signMessage(privateKey, message) {
+        const wallet = new Wallet(privateKey);
+        return await wallet.signMessage(message);
+    }
+    isValidMnemonic(mnemonic) {
+        try {
+            Mnemonic.fromPhrase(mnemonic);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    validateMnemonic(mnemonic) {
+        if (!this.isValidMnemonic(mnemonic)) {
+            throw new Error('Invalid mnemonic phrase');
+        }
+    }
+    getEntropyForWordCount(wordCount) {
+        const entropyMap = {
+            12: 16, // 128 bits
+            15: 20, // 160 bits
+            18: 24, // 192 bits
+            21: 28, // 224 bits
+            24: 32, // 256 bits
+        };
+        return entropyMap[wordCount];
+    }
+}

package/dist/services/evm-wallet-core/signer.d.ts

@@ -0,0 +1,7 @@
+/** npm imports */
+import { Wallet } from 'ethers';
+/** local imports */
+import { TransactionRequest } from '../../types/common';
+export declare const createWallet: (privateKey: string, rpcUrl?: string) => Wallet;
+export declare const signMessage: (privateKey: string, message: string) => Promise<string>;
+export declare const signTransaction: (privateKey: string, tx: TransactionRequest, rpcUrl?: string) => Promise<string>;

package/dist/services/evm-wallet-core/signer.js

@@ -0,0 +1,11 @@
+/** npm imports */
+import { Wallet, JsonRpcProvider } from 'ethers';
+export const createWallet = (privateKey, rpcUrl) => new Wallet(privateKey, rpcUrl ? new JsonRpcProvider(rpcUrl) : undefined);
+export const signMessage = async (privateKey, message) => {
+    const wallet = createWallet(privateKey);
+    return wallet.signMessage(message);
+};
+export const signTransaction = async (privateKey, tx, rpcUrl) => {
+    const wallet = createWallet(privateKey, rpcUrl);
+    return wallet.signTransaction(tx);
+};

package/dist/types/common.d.ts

@@ -33,6 +33,7 @@ export interface UnsignedTransferTxResponse {
     nonce: number;
     gasEstimated: string;
     gasLimit: string;
+    gasReserve?: string;
     bufferPercentage: number;
     feeData: {
         maxFeePerGas?: string;
@@ -40,9 +41,17 @@ export interface UnsignedTransferTxResponse {
         gasPrice?: string;
     };
 }
+export interface BuildMaxNativeTransferTxOptions extends Omit<BuildUnsignedTransferTxOptions, 'value' | 'tokenAddress' | 'tokenDecimals'> {
+    balance: string;
+    tokenAddress?: string;
+}
+export interface BuildMaxNativeTransferTxResponse extends UnsignedTransferTxResponse {
+    sendableValue: string;
+}
 export interface BroadcastTransactionOptions {
     signedTx: string;
     rpcUrl: string;
+    chainId?: number;
     waitConfirmations?: number;
 }
 export interface TxStatusOptions {
@@ -54,3 +63,12 @@ export interface TxStatusResponse {
     success: boolean;
     receipt: TransactionReceipt | null;
 }
+export interface FormatAmountOptions {
+    decimalsToShow?: number;
+    useGroupSeparator?: boolean;
+    locale?: string;
+    minimumFractionDigits?: number;
+    minDisplayDecimals?: number;
+    maxDisplayDigits?: number;
+}
+export type { TransactionRequest };

package/dist/utils/formatAmount.d.ts

@@ -0,0 +1,6 @@
+/** npm imports */
+import { BigNumberish } from 'ethers';
+/** local imports */
+import { FormatAmountOptions } from '../types/common';
+export declare const formattedAmountForDisplay: (amount: BigNumberish, decimals: number, options?: FormatAmountOptions) => string;
+export declare const parsedAmount: (amount: string, decimals: number) => bigint;

package/dist/utils/formatAmount.js

@@ -0,0 +1,50 @@
+/** npm imports */
+import { formatUnits, parseUnits } from 'ethers';
+export const formattedAmountForDisplay = (amount, decimals, options = {}) => {
+    const { decimalsToShow = 0, useGroupSeparator = true, locale = 'en-US', minimumFractionDigits, minDisplayDecimals = 9, maxDisplayDigits = 16, } = options;
+    const formattedAmount = formatUnits(amount, decimals);
+    if (formattedAmount.startsWith('-')) {
+        throw new Error('Negative balances are not supported');
+    }
+    const [wholePart = '0', fractionPart = ''] = formattedAmount.split('.');
+    if (wholePart.length >= maxDisplayDigits) {
+        const mantissaWhole = wholePart[0] ?? '0';
+        const mantissaFraction = (wholePart.slice(1) + fractionPart).slice(0, decimalsToShow);
+        const exponent = wholePart.length - 1;
+        const rawMantissa = mantissaFraction ? `${mantissaWhole}.${mantissaFraction}` : mantissaWhole;
+        const trimmedMantissa = rawMantissa.replace(/\.0+$|(?<=\.[0-9]*?)0+$/g, '').replace(/\.$/, '');
+        return `${trimmedMantissa}e${exponent}`;
+    }
+    const firstNonZeroIndex = fractionPart.split('').findIndex((digit) => digit !== '0');
+    const hasNonZeroFraction = firstNonZeroIndex !== -1;
+    if (hasNonZeroFraction && wholePart === '0' && firstNonZeroIndex >= minDisplayDecimals) {
+        const sample = new Intl.NumberFormat(locale).format(1000.1);
+        const decimalSeparator = sample.replace(/\d/g, '').slice(-1) ?? '.';
+        const minValue = `0${decimalSeparator}${'0'.repeat(Math.max(0, minDisplayDecimals - 1))}1`;
+        return `< ${minValue}`;
+    }
+    if (!hasNonZeroFraction) {
+        const sample = new Intl.NumberFormat(locale).format(1000.1);
+        const groupSeparator = sample.replace(/\d/g, '')[0] ?? ',';
+        const groupedWhole = useGroupSeparator
+            ? (wholePart || '0').replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator)
+            : wholePart;
+        return groupedWhole;
+    }
+    const maxDecimals = decimalsToShow ?? fractionPart.length;
+    let trimmedFraction = fractionPart.slice(0, Math.max(0, maxDecimals));
+    const minDecimals = minimumFractionDigits ?? 0;
+    if (trimmedFraction.length < minDecimals) {
+        trimmedFraction = trimmedFraction.padEnd(minDecimals, '0');
+    }
+    const sample = new Intl.NumberFormat(locale).format(1000.1);
+    const groupSeparator = sample.replace(/\d/g, '')[0] ?? ',';
+    const decimalSeparator = sample.replace(/\d/g, '').slice(-1) ?? '.';
+    const groupedWhole = useGroupSeparator
+        ? (wholePart || '0').replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator)
+        : wholePart;
+    if (!trimmedFraction)
+        return groupedWhole;
+    return `${groupedWhole}${decimalSeparator}${trimmedFraction}`;
+};
+export const parsedAmount = (amount, decimals) => parseUnits(amount, decimals);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octaflowlabs/onchain-sdk",
-  "version": "1.0.0-test7",
+  "version": "1.1.0",
   "description": "onchain methods for web3",
   "repository": "https://github.com/crisramb665/onchain-sdk.git",
   "license": "MIT",