@octaflowlabs/onchain-sdk 1.2.2 → 1.3.1

package/dist/blockchain/buildUnsignedTransferTx.d.ts

@@ -1,3 +1,8 @@
-import { BuildMaxNativeTransferTxOptions, BuildMaxNativeTransferTxResponse, BuildUnsignedTransferTxOptions, UnsignedTransferTxResponse } from '../types/common';
-export declare const buildUnsignedTransferTx: (options: BuildUnsignedTransferTxOptions) => Promise<UnsignedTransferTxResponse>;
-export declare const buildMaxNativeTransferTx: (options: BuildMaxNativeTransferTxOptions) => Promise<BuildMaxNativeTransferTxResponse>;
+import { BuildBaseUnsignedTransferTxParams, BuildMaxNativeTransferTxOptions, BuildUnsignedTransferTxOptions, PrepareTransactionResult } from '../types/common';
+export declare const buildBaseUnsignedTransferTx: ({ recipientAddress, value, tokenAddress, tokenDecimals, }: BuildBaseUnsignedTransferTxParams) => {
+    to: string;
+    data: string;
+    value: bigint;
+};
+export declare const buildUnsignedTransferTx: (options: BuildUnsignedTransferTxOptions) => Promise<PrepareTransactionResult>;
+export declare const buildMaxNativeTransferTx: (options: BuildMaxNativeTransferTxOptions) => Promise<string>;

package/dist/blockchain/buildUnsignedTransferTx.js

@@ -1,97 +1,46 @@
 /** npm imports */
-import { Interface, formatUnits, parseUnits } from 'ethers';
+import { Interface, formatUnits, parseEther, parseUnits } from 'ethers';
 /** local imports */
 import { getProvider } from './getProvider';
-import { estimateGasLimitFromProvider } from './estimateGasLimitFromProvider';
+import { prepareTransaction } from './prepareTransaction';
+export const buildBaseUnsignedTransferTx = ({ recipientAddress, value, tokenAddress, tokenDecimals, }) => {
+    const isNative = !tokenAddress ||
+        tokenAddress.toLowerCase() === '0x0000000000000000000000000000000000000000' ||
+        tokenAddress.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+    if (!isNative) {
+        const erc20Interface = new Interface(['function transfer(address to, uint256 amount)']);
+        const decimals = tokenDecimals ?? 18;
+        const amountParsed = parseUnits(value, decimals);
+        return {
+            to: tokenAddress,
+            data: erc20Interface.encodeFunctionData('transfer', [recipientAddress, amountParsed]),
+            value: 0n,
+        };
+    }
+    return {
+        to: recipientAddress,
+        data: '0x',
+        value: parseEther(value),
+    };
+};
 export const buildUnsignedTransferTx = async (options) => {
     const provider = getProvider(options.rpcUrl, options.chainId);
     if (!provider)
         throw new Error('Could not create provider with given rpcUrl and chainId');
     try {
-        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,
+        const baseUnsignedTx = buildBaseUnsignedTransferTx({
+            recipientAddress: options.toAddress,
+            value: options.value ?? '0',
+            tokenAddress: options.tokenAddress,
+            tokenDecimals: options.tokenDecimals,
+        });
+        return prepareTransaction({
+            rpcUrl: options.rpcUrl,
+            chainId: options.chainId ?? Number((await provider.getNetwork()).chainId),
+            tx: baseUnsignedTx,
+            fromAddress: 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();
-        const gasReserve = estimateGas.feeData.maxFeePerGas
-            ? estimateGas.gasLimit * estimateGas.feeData.maxFeePerGas
-            : estimateGas.feeData.gasPrice
-                ? estimateGas.gasLimit * estimateGas.feeData.gasPrice
-                : undefined;
-        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);
-        }
-        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) {
         console.error('Error building unsigned transfer transaction:', error);
@@ -99,31 +48,29 @@ export const buildUnsignedTransferTx = async (options) => {
     }
 };
 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,
+    const provider = getProvider(options.rpcUrl, options.chainId);
+    if (!provider)
+        throw new Error('Could not create provider with given rpcUrl and chainId');
+    const network = await provider.getNetwork();
+    const chainId = options.chainId ?? Number(network.chainId);
+    const provisionalTx = await prepareTransaction({
+        rpcUrl: options.rpcUrl,
+        chainId,
+        tx: {
+            to: options.toAddress,
+            data: '0x',
+            value: 0n,
+        },
+        fromAddress: options.fromAddress,
+        defaultGasLimit: options.defaultGasLimit,
     });
     if (!provisionalTx.gasReserve)
         throw new Error('Could not determine gas reserve for max send');
-    const balanceWei = parseUnits(options.balance, 18);
+    const balanceWei = parseEther(options.balance);
     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 {
-        ...finalTx,
-        sendableValue,
-    };
+    return sendableValue;
 };

package/dist/blockchain/estimateTransaction.d.ts

@@ -0,0 +1,2 @@
+import { EstimateTransactionOptions, EstimateTransactionResult } from '../types/common';
+export declare const estimateTransaction: ({ rpcUrl, chainId, tx, fromAddress, defaultGasLimit, }: EstimateTransactionOptions) => Promise<EstimateTransactionResult>;

package/dist/blockchain/estimateTransaction.js

@@ -0,0 +1,29 @@
+/** local imports */
+import { estimateGasLimitFromProvider } from './estimateGasLimitFromProvider';
+import { getProvider } from './getProvider';
+import { formatUnits } from 'ethers';
+export const estimateTransaction = async ({ rpcUrl, chainId, tx, fromAddress, defaultGasLimit, }) => {
+    const provider = getProvider(rpcUrl, chainId);
+    if (!provider)
+        throw new Error('Could not get provider');
+    const estimateGas = await estimateGasLimitFromProvider({
+        provider,
+        unsignedTx: tx,
+        walletAddress: fromAddress,
+        defaultGasLimit: defaultGasLimit || 21000n,
+    });
+    const gasReserve = estimateGas.feeData.maxFeePerGas
+        ? estimateGas.gasLimit * estimateGas.feeData.maxFeePerGas
+        : estimateGas.feeData.gasPrice
+            ? estimateGas.gasLimit * estimateGas.feeData.gasPrice
+            : undefined;
+    const humanReadableGasReserve = gasReserve ? `${formatUnits(gasReserve, 18)}` : 'N/A';
+    return {
+        gasLimit: estimateGas.gasLimit,
+        gasEstimated: estimateGas.gasEstimated,
+        feeData: estimateGas.feeData,
+        gasReserve,
+        humanReadableGasReserve,
+        bufferPercentage: estimateGas.bufferPercentage,
+    };
+};

package/dist/blockchain/prepareTransaction.d.ts

@@ -0,0 +1,2 @@
+import { PrepareTransactionParams, PrepareTransactionResult } from '../types/common';
+export declare const prepareTransaction: ({ rpcUrl, chainId, tx, fromAddress, defaultGasLimit, }: PrepareTransactionParams) => Promise<PrepareTransactionResult>;

package/dist/blockchain/prepareTransaction.js

@@ -0,0 +1,43 @@
+/** local imports */
+import { estimateTransaction } from './estimateTransaction';
+import { getProvider } from './getProvider';
+export const prepareTransaction = async ({ rpcUrl, chainId, tx, fromAddress, defaultGasLimit, }) => {
+    const provider = getProvider(rpcUrl, chainId);
+    if (!provider)
+        throw new Error('Could not create provider');
+    const estimation = await estimateTransaction({
+        rpcUrl,
+        chainId,
+        tx,
+        fromAddress,
+        defaultGasLimit,
+    });
+    const nonce = await provider.getTransactionCount(fromAddress, 'pending');
+    const preparedTx = {
+        from: fromAddress,
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        gasLimit: estimation.gasLimit,
+        chainId,
+        nonce,
+        maxFeePerGas: estimation.feeData.maxFeePerGas,
+        maxPriorityFeePerGas: estimation.feeData.maxPriorityFeePerGas,
+    };
+    if (estimation.feeData.gasPrice)
+        preparedTx.gasPrice = estimation.feeData.gasPrice;
+    return {
+        unsignedTx: preparedTx,
+        nonce,
+        gasEstimated: estimation.gasEstimated,
+        gasLimit: estimation.gasLimit,
+        gasReserve: estimation.gasReserve,
+        bufferPercentage: estimation.bufferPercentage,
+        feeData: {
+            maxFeePerGas: estimation.feeData.maxFeePerGas,
+            maxPriorityFeePerGas: estimation.feeData.maxPriorityFeePerGas,
+            gasPrice: estimation.feeData.gasPrice,
+        },
+        humanReadableGasReserve: estimation.humanReadableGasReserve,
+    };
+};

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

@@ -1,3 +1,8 @@
-import { BuildMaxNativeTransferTxOptions, BuildMaxNativeTransferTxResponse, BuildUnsignedTransferTxOptions, UnsignedTransferTxResponse } from '../types/common';
-export declare const buildUnsignedTransferTx: (options: BuildUnsignedTransferTxOptions) => Promise<UnsignedTransferTxResponse>;
-export declare const buildMaxNativeTransferTx: (options: BuildMaxNativeTransferTxOptions) => Promise<BuildMaxNativeTransferTxResponse>;
+import { BuildBaseUnsignedTransferTxParams, BuildMaxNativeTransferTxOptions, BuildUnsignedTransferTxOptions, PrepareTransactionResult } from '../types/common';
+export declare const buildBaseUnsignedTransferTx: ({ recipientAddress, value, tokenAddress, tokenDecimals, }: BuildBaseUnsignedTransferTxParams) => {
+    to: string;
+    data: string;
+    value: bigint;
+};
+export declare const buildUnsignedTransferTx: (options: BuildUnsignedTransferTxOptions) => Promise<PrepareTransactionResult>;
+export declare const buildMaxNativeTransferTx: (options: BuildMaxNativeTransferTxOptions) => Promise<string>;

package/dist/cjs/blockchain/buildUnsignedTransferTx.js

@@ -1,100 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildMaxNativeTransferTx = exports.buildUnsignedTransferTx = void 0;
+exports.buildMaxNativeTransferTx = exports.buildUnsignedTransferTx = exports.buildBaseUnsignedTransferTx = void 0;
 /** npm imports */
 const ethers_1 = require("ethers");
 /** local imports */
 const getProvider_1 = require("./getProvider");
-const estimateGasLimitFromProvider_1 = require("./estimateGasLimitFromProvider");
+const prepareTransaction_1 = require("./prepareTransaction");
+const buildBaseUnsignedTransferTx = ({ recipientAddress, value, tokenAddress, tokenDecimals, }) => {
+    const isNative = !tokenAddress ||
+        tokenAddress.toLowerCase() === '0x0000000000000000000000000000000000000000' ||
+        tokenAddress.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+    if (!isNative) {
+        const erc20Interface = new ethers_1.Interface(['function transfer(address to, uint256 amount)']);
+        const decimals = tokenDecimals ?? 18;
+        const amountParsed = (0, ethers_1.parseUnits)(value, decimals);
+        return {
+            to: tokenAddress,
+            data: erc20Interface.encodeFunctionData('transfer', [recipientAddress, amountParsed]),
+            value: 0n,
+        };
+    }
+    return {
+        to: recipientAddress,
+        data: '0x',
+        value: (0, ethers_1.parseEther)(value),
+    };
+};
+exports.buildBaseUnsignedTransferTx = buildBaseUnsignedTransferTx;
 const buildUnsignedTransferTx = async (options) => {
     const provider = (0, getProvider_1.getProvider)(options.rpcUrl, options.chainId);
     if (!provider)
         throw new Error('Could not create provider with given rpcUrl and chainId');
     try {
-        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,
+        const baseUnsignedTx = (0, exports.buildBaseUnsignedTransferTx)({
+            recipientAddress: options.toAddress,
+            value: options.value ?? '0',
+            tokenAddress: options.tokenAddress,
+            tokenDecimals: options.tokenDecimals,
+        });
+        return (0, prepareTransaction_1.prepareTransaction)({
+            rpcUrl: options.rpcUrl,
+            chainId: options.chainId ?? Number((await provider.getNetwork()).chainId),
+            tx: baseUnsignedTx,
+            fromAddress: 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();
-        const gasReserve = estimateGas.feeData.maxFeePerGas
-            ? estimateGas.gasLimit * estimateGas.feeData.maxFeePerGas
-            : estimateGas.feeData.gasPrice
-                ? estimateGas.gasLimit * estimateGas.feeData.gasPrice
-                : undefined;
-        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);
-        }
-        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) {
         console.error('Error building unsigned transfer transaction:', error);
@@ -103,32 +53,30 @@ const buildUnsignedTransferTx = async (options) => {
 };
 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,
+    const provider = (0, getProvider_1.getProvider)(options.rpcUrl, options.chainId);
+    if (!provider)
+        throw new Error('Could not create provider with given rpcUrl and chainId');
+    const network = await provider.getNetwork();
+    const chainId = options.chainId ?? Number(network.chainId);
+    const provisionalTx = await (0, prepareTransaction_1.prepareTransaction)({
+        rpcUrl: options.rpcUrl,
+        chainId,
+        tx: {
+            to: options.toAddress,
+            data: '0x',
+            value: 0n,
+        },
+        fromAddress: options.fromAddress,
+        defaultGasLimit: options.defaultGasLimit,
     });
     if (!provisionalTx.gasReserve)
         throw new Error('Could not determine gas reserve for max send');
-    const balanceWei = (0, ethers_1.parseUnits)(options.balance, 18);
+    const balanceWei = (0, ethers_1.parseEther)(options.balance);
     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 {
-        ...finalTx,
-        sendableValue,
-    };
+    return sendableValue;
 };
 exports.buildMaxNativeTransferTx = buildMaxNativeTransferTx;

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

@@ -0,0 +1,2 @@
+import { EstimateTransactionOptions, EstimateTransactionResult } from '../types/common';
+export declare const estimateTransaction: ({ rpcUrl, chainId, tx, fromAddress, defaultGasLimit, }: EstimateTransactionOptions) => Promise<EstimateTransactionResult>;

package/dist/cjs/blockchain/estimateTransaction.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTransaction = void 0;
+/** local imports */
+const estimateGasLimitFromProvider_1 = require("./estimateGasLimitFromProvider");
+const getProvider_1 = require("./getProvider");
+const ethers_1 = require("ethers");
+const estimateTransaction = async ({ rpcUrl, chainId, tx, fromAddress, defaultGasLimit, }) => {
+    const provider = (0, getProvider_1.getProvider)(rpcUrl, chainId);
+    if (!provider)
+        throw new Error('Could not get provider');
+    const estimateGas = await (0, estimateGasLimitFromProvider_1.estimateGasLimitFromProvider)({
+        provider,
+        unsignedTx: tx,
+        walletAddress: fromAddress,
+        defaultGasLimit: defaultGasLimit || 21000n,
+    });
+    const gasReserve = estimateGas.feeData.maxFeePerGas
+        ? estimateGas.gasLimit * estimateGas.feeData.maxFeePerGas
+        : estimateGas.feeData.gasPrice
+            ? estimateGas.gasLimit * estimateGas.feeData.gasPrice
+            : undefined;
+    const humanReadableGasReserve = gasReserve ? `${(0, ethers_1.formatUnits)(gasReserve, 18)}` : 'N/A';
+    return {
+        gasLimit: estimateGas.gasLimit,
+        gasEstimated: estimateGas.gasEstimated,
+        feeData: estimateGas.feeData,
+        gasReserve,
+        humanReadableGasReserve,
+        bufferPercentage: estimateGas.bufferPercentage,
+    };
+};
+exports.estimateTransaction = estimateTransaction;

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

@@ -0,0 +1,2 @@
+import { PrepareTransactionParams, PrepareTransactionResult } from '../types/common';
+export declare const prepareTransaction: ({ rpcUrl, chainId, tx, fromAddress, defaultGasLimit, }: PrepareTransactionParams) => Promise<PrepareTransactionResult>;

package/dist/cjs/blockchain/prepareTransaction.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareTransaction = void 0;
+/** local imports */
+const estimateTransaction_1 = require("./estimateTransaction");
+const getProvider_1 = require("./getProvider");
+const prepareTransaction = async ({ rpcUrl, chainId, tx, fromAddress, defaultGasLimit, }) => {
+    const provider = (0, getProvider_1.getProvider)(rpcUrl, chainId);
+    if (!provider)
+        throw new Error('Could not create provider');
+    const estimation = await (0, estimateTransaction_1.estimateTransaction)({
+        rpcUrl,
+        chainId,
+        tx,
+        fromAddress,
+        defaultGasLimit,
+    });
+    const nonce = await provider.getTransactionCount(fromAddress, 'pending');
+    const preparedTx = {
+        from: fromAddress,
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        gasLimit: estimation.gasLimit,
+        chainId,
+        nonce,
+        maxFeePerGas: estimation.feeData.maxFeePerGas,
+        maxPriorityFeePerGas: estimation.feeData.maxPriorityFeePerGas,
+    };
+    if (estimation.feeData.gasPrice)
+        preparedTx.gasPrice = estimation.feeData.gasPrice;
+    return {
+        unsignedTx: preparedTx,
+        nonce,
+        gasEstimated: estimation.gasEstimated,
+        gasLimit: estimation.gasLimit,
+        gasReserve: estimation.gasReserve,
+        bufferPercentage: estimation.bufferPercentage,
+        feeData: {
+            maxFeePerGas: estimation.feeData.maxFeePerGas,
+            maxPriorityFeePerGas: estimation.feeData.maxPriorityFeePerGas,
+            gasPrice: estimation.feeData.gasPrice,
+        },
+        humanReadableGasReserve: estimation.humanReadableGasReserve,
+    };
+};
+exports.prepareTransaction = prepareTransaction;

package/dist/cjs/index.d.ts

@@ -5,12 +5,14 @@ export { ERC20_TOKEN_CONTRACT_ABI };
 export { GAS_LIMIT_PER_TX_TYPE, MULTICALL3_ADDRESS } from './constants/constants';
 export { NETWORKS_REGISTRY, NetworkField, NetworkRegistry } from './constants/NETWORKS_REGISTRY';
 /** basic blockchain exports */
-export { buildMaxNativeTransferTx, buildUnsignedTransferTx, } from './blockchain/buildUnsignedTransferTx';
+export { buildBaseUnsignedTransferTx, 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';
 export { getBalance, getBalances } from './blockchain/getBalances';
+export { estimateTransaction } from './blockchain/estimateTransaction';
+export { prepareTransaction } from './blockchain/prepareTransaction';
 /** services exports */
 export { EvmWalletService, EvmGeneratedWallet, EvmDerivedWallet, } from './services/evm-wallet-core/evmWalletService';
 export { EntropySource } from './services/evm-wallet-core/entropy';
@@ -24,4 +26,4 @@ export { formattedAmountForDisplay, parsedAmount } from './utils/formatAmount';
 export { handleErrorMessages, errorMessagesForBroadcast, errorMessagesForGasLimitEstimation, } from './utils/handleErrorMessages';
 export { normalizeAddress } from './utils/normalizeAddress';
 /** types exports */
-export { BroadcastTransactionOptions, BuildMaxNativeTransferTxOptions, BuildMaxNativeTransferTxResponse, BuildUnsignedTransferTxOptions, EstimateGasLimitFromProviderProps, GasEstimateResult, TxStatusOptions, TxStatusResponse, UnsignedTransferTxResponse, FormatAmountOptions, TransactionRequest, GetBalanceParams, GetBalancesParams, GetBalancesChainRequest, GetBalanceResult, ChainBalances, TokenBalance, ChainGroup, } from './types/common';
+export { BroadcastTransactionOptions, BuildMaxNativeTransferTxOptions, BuildUnsignedTransferTxOptions, EstimateGasLimitFromProviderProps, GasEstimateResult, TxStatusOptions, BuildBaseUnsignedTransferTxParams, TxStatusResponse, EstimateTransactionOptions, EstimateTransactionResult, PrepareTransactionParams, PrepareTransactionResult, FormatAmountOptions, TransactionRequest, GetBalanceParams, GetBalancesParams, GetBalancesChainRequest, GetBalanceResult, ChainBalances, TokenBalance, ChainGroup, } 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.normalizeAddress = exports.errorMessagesForGasLimitEstimation = exports.errorMessagesForBroadcast = exports.handleErrorMessages = exports.parsedAmount = exports.formattedAmountForDisplay = exports.NATIVE_TOKENS = exports.transformBigInt = exports.getShortenData = exports.getShortenTransactionHashOrAddress = exports.signTransaction = exports.signMessage = exports.createWallet = exports.EvmWalletService = exports.getBalances = exports.getBalance = exports.txStatus = exports.getProvider = exports.estimateGasLimitFromProvider = exports.broadcastTransaction = exports.buildUnsignedTransferTx = exports.buildMaxNativeTransferTx = exports.NETWORKS_REGISTRY = exports.MULTICALL3_ADDRESS = exports.GAS_LIMIT_PER_TX_TYPE = exports.ERC20_TOKEN_CONTRACT_ABI = void 0;
+exports.normalizeAddress = exports.errorMessagesForGasLimitEstimation = exports.errorMessagesForBroadcast = exports.handleErrorMessages = exports.parsedAmount = exports.formattedAmountForDisplay = exports.NATIVE_TOKENS = exports.transformBigInt = exports.getShortenData = exports.getShortenTransactionHashOrAddress = exports.signTransaction = exports.signMessage = exports.createWallet = exports.EvmWalletService = exports.prepareTransaction = exports.estimateTransaction = exports.getBalances = exports.getBalance = exports.txStatus = exports.getProvider = exports.estimateGasLimitFromProvider = exports.broadcastTransaction = exports.buildUnsignedTransferTx = exports.buildMaxNativeTransferTx = exports.buildBaseUnsignedTransferTx = exports.NETWORKS_REGISTRY = exports.MULTICALL3_ADDRESS = 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;
@@ -15,6 +15,7 @@ var NETWORKS_REGISTRY_1 = require("./constants/NETWORKS_REGISTRY");
 Object.defineProperty(exports, "NETWORKS_REGISTRY", { enumerable: true, get: function () { return NETWORKS_REGISTRY_1.NETWORKS_REGISTRY; } });
 /** basic blockchain exports */
 var buildUnsignedTransferTx_1 = require("./blockchain/buildUnsignedTransferTx");
+Object.defineProperty(exports, "buildBaseUnsignedTransferTx", { enumerable: true, get: function () { return buildUnsignedTransferTx_1.buildBaseUnsignedTransferTx; } });
 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");
@@ -28,6 +29,10 @@ Object.defineProperty(exports, "txStatus", { enumerable: true, get: function ()
 var getBalances_1 = require("./blockchain/getBalances");
 Object.defineProperty(exports, "getBalance", { enumerable: true, get: function () { return getBalances_1.getBalance; } });
 Object.defineProperty(exports, "getBalances", { enumerable: true, get: function () { return getBalances_1.getBalances; } });
+var estimateTransaction_1 = require("./blockchain/estimateTransaction");
+Object.defineProperty(exports, "estimateTransaction", { enumerable: true, get: function () { return estimateTransaction_1.estimateTransaction; } });
+var prepareTransaction_1 = require("./blockchain/prepareTransaction");
+Object.defineProperty(exports, "prepareTransaction", { enumerable: true, get: function () { return prepareTransaction_1.prepareTransaction; } });
 /** services exports */
 var evmWalletService_1 = require("./services/evm-wallet-core/evmWalletService");
 Object.defineProperty(exports, "EvmWalletService", { enumerable: true, get: function () { return evmWalletService_1.EvmWalletService; } });

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

@@ -20,6 +20,10 @@ export declare class EvmWalletService {
     generateMultipleWallets(mnemonic: string, count: number, startIndex?: number): EvmDerivedWallet[];
     deriveWalletFromMnemonic(mnemonic: string, accountIndex?: number, customPath?: string): EvmDerivedWallet;
     deriveFromPrivateKey(privateKey: string): Omit<EvmDerivedWallet, 'path'>;
+    getFirstAvailableIndexForMnemonicImport(mnemonic: string, existingAddresses: string[], maxIndicesToCheck?: number): {
+        index: number;
+        wallet: EvmDerivedWallet;
+    } | null;
     signMessage(privateKey: string, message: string): Promise<string>;
     isValidMnemonic(mnemonic: string): boolean;
     private validateMnemonic;

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

@@ -58,6 +58,18 @@ class EvmWalletService {
             publicKey: wallet.signingKey.publicKey,
         };
     }
+    getFirstAvailableIndexForMnemonicImport(mnemonic, existingAddresses, maxIndicesToCheck = 20) {
+        this.validateMnemonic(mnemonic);
+        const existingSet = new Set(existingAddresses.map((addr) => (0, ethers_1.getAddress)(addr)));
+        for (let i = 0; i < maxIndicesToCheck; i++) {
+            const wallet = this.deriveWalletFromMnemonic(mnemonic, i);
+            const normalizedAddress = (0, ethers_1.getAddress)(wallet.address);
+            if (!existingSet.has(normalizedAddress)) {
+                return { index: i, wallet };
+            }
+        }
+        return null;
+    }
     async signMessage(privateKey, message) {
         const wallet = new ethers_1.Wallet(privateKey);
         return await wallet.signMessage(message);
@@ -72,9 +84,8 @@ class EvmWalletService {
         }
     }
     validateMnemonic(mnemonic) {
-        if (!this.isValidMnemonic(mnemonic)) {
+        if (!this.isValidMnemonic(mnemonic))
             throw new Error('Invalid mnemonic phrase');
-        }
     }
     getEntropyForWordCount(wordCount) {
         const entropyMap = {

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

@@ -17,36 +17,59 @@ export interface GasEstimateResult {
         gasPrice?: bigint;
     };
 }
+export interface EstimateTransactionOptions {
+    rpcUrl: string;
+    chainId: number;
+    tx: TransactionRequest;
+    fromAddress: string;
+    defaultGasLimit?: bigint;
+}
+export interface PrepareTransactionParams extends EstimateTransactionOptions {
+}
+export interface EstimateTransactionResult {
+    gasLimit: bigint;
+    gasEstimated: bigint;
+    feeData: {
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        gasPrice?: bigint;
+    };
+    gasReserve?: bigint;
+    humanReadableGasReserve: string;
+    bufferPercentage: number;
+}
+export interface PrepareTransactionResult {
+    unsignedTx: TransactionRequest;
+    nonce: number;
+    gasEstimated: bigint;
+    gasLimit: bigint;
+    gasReserve?: bigint;
+    bufferPercentage: number;
+    feeData: {
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        gasPrice?: bigint;
+    };
+    humanReadableGasReserve: string;
+}
+export interface BuildBaseUnsignedTransferTxParams {
+    recipientAddress: string;
+    value: string;
+    tokenAddress?: string;
+    tokenDecimals?: number;
+}
 export interface BuildUnsignedTransferTxOptions {
     fromAddress: string;
     toAddress: string;
     value?: string;
-    data?: string;
     tokenAddress?: string;
     tokenDecimals?: number;
     rpcUrl: string;
     chainId?: number;
     defaultGasLimit: bigint;
 }
-export interface UnsignedTransferTxResponse {
-    unsignedTx: TransactionRequest;
-    nonce: number;
-    gasEstimated: string;
-    gasLimit: string;
-    gasReserve?: string;
-    bufferPercentage: number;
-    feeData: {
-        maxFeePerGas?: string;
-        maxPriorityFeePerGas?: string;
-        gasPrice?: string;
-    };
-}
-export interface BuildMaxNativeTransferTxOptions extends Omit<BuildUnsignedTransferTxOptions, 'value' | 'tokenAddress' | 'tokenDecimals'> {
+export interface BuildMaxNativeTransferTxOptions extends Omit<BuildUnsignedTransferTxOptions, 'value' | 'tokenDecimals'> {
     balance: string;
-    tokenAddress?: string;
-}
-export interface BuildMaxNativeTransferTxResponse extends UnsignedTransferTxResponse {
-    sendableValue: string;
 }
 export interface BroadcastTransactionOptions {
     signedTx: string;

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

@@ -1,2 +1,2 @@
-export declare const getShortenTransactionHashOrAddress: (txHashOrAddress: string) => string;
-export declare const getShortenData: (data: string) => string;
+export declare const getShortenTransactionHashOrAddress: (txHashOrAddress: string, firstPartLength?: number, lastPartLength?: number) => string;
+export declare const getShortenData: (data: string, firstPartLength?: number, lastPartLength?: number) => string;

package/dist/cjs/utils/getShortenTxHash.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getShortenData = exports.getShortenTransactionHashOrAddress = void 0;
-const getShortenTransactionHashOrAddress = (txHashOrAddress) => {
-    const firstCharacters = txHashOrAddress.substring(0, 6);
-    const lastCharacters = txHashOrAddress.slice(-4);
+const getShortenTransactionHashOrAddress = (txHashOrAddress, firstPartLength = 6, lastPartLength = 4) => {
+    const firstCharacters = txHashOrAddress.substring(0, firstPartLength);
+    const lastCharacters = txHashOrAddress.slice(-lastPartLength);
     return `${firstCharacters}...${lastCharacters}`;
 };
 exports.getShortenTransactionHashOrAddress = getShortenTransactionHashOrAddress;
-const getShortenData = (data) => {
-    const firstCharacters = data.substring(0, 12);
-    const lastCharacters = data.slice(-12);
+const getShortenData = (data, firstPartLength = 12, lastPartLength = 12) => {
+    const firstCharacters = data.substring(0, firstPartLength);
+    const lastCharacters = data.slice(-lastPartLength);
     return `${firstCharacters}...${lastCharacters}`;
 };
 exports.getShortenData = getShortenData;

package/dist/index.d.ts

@@ -5,12 +5,14 @@ export { ERC20_TOKEN_CONTRACT_ABI };
 export { GAS_LIMIT_PER_TX_TYPE, MULTICALL3_ADDRESS } from './constants/constants';
 export { NETWORKS_REGISTRY, NetworkField, NetworkRegistry } from './constants/NETWORKS_REGISTRY';
 /** basic blockchain exports */
-export { buildMaxNativeTransferTx, buildUnsignedTransferTx, } from './blockchain/buildUnsignedTransferTx';
+export { buildBaseUnsignedTransferTx, 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';
 export { getBalance, getBalances } from './blockchain/getBalances';
+export { estimateTransaction } from './blockchain/estimateTransaction';
+export { prepareTransaction } from './blockchain/prepareTransaction';
 /** services exports */
 export { EvmWalletService, EvmGeneratedWallet, EvmDerivedWallet, } from './services/evm-wallet-core/evmWalletService';
 export { EntropySource } from './services/evm-wallet-core/entropy';
@@ -24,4 +26,4 @@ export { formattedAmountForDisplay, parsedAmount } from './utils/formatAmount';
 export { handleErrorMessages, errorMessagesForBroadcast, errorMessagesForGasLimitEstimation, } from './utils/handleErrorMessages';
 export { normalizeAddress } from './utils/normalizeAddress';
 /** types exports */
-export { BroadcastTransactionOptions, BuildMaxNativeTransferTxOptions, BuildMaxNativeTransferTxResponse, BuildUnsignedTransferTxOptions, EstimateGasLimitFromProviderProps, GasEstimateResult, TxStatusOptions, TxStatusResponse, UnsignedTransferTxResponse, FormatAmountOptions, TransactionRequest, GetBalanceParams, GetBalancesParams, GetBalancesChainRequest, GetBalanceResult, ChainBalances, TokenBalance, ChainGroup, } from './types/common';
+export { BroadcastTransactionOptions, BuildMaxNativeTransferTxOptions, BuildUnsignedTransferTxOptions, EstimateGasLimitFromProviderProps, GasEstimateResult, TxStatusOptions, BuildBaseUnsignedTransferTxParams, TxStatusResponse, EstimateTransactionOptions, EstimateTransactionResult, PrepareTransactionParams, PrepareTransactionResult, FormatAmountOptions, TransactionRequest, GetBalanceParams, GetBalancesParams, GetBalancesChainRequest, GetBalanceResult, ChainBalances, TokenBalance, ChainGroup, } from './types/common';

package/dist/index.js

@@ -5,12 +5,14 @@ export { ERC20_TOKEN_CONTRACT_ABI };
 export { GAS_LIMIT_PER_TX_TYPE, MULTICALL3_ADDRESS } from './constants/constants';
 export { NETWORKS_REGISTRY } from './constants/NETWORKS_REGISTRY';
 /** basic blockchain exports */
-export { buildMaxNativeTransferTx, buildUnsignedTransferTx, } from './blockchain/buildUnsignedTransferTx';
+export { buildBaseUnsignedTransferTx, 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';
 export { getBalance, getBalances } from './blockchain/getBalances';
+export { estimateTransaction } from './blockchain/estimateTransaction';
+export { prepareTransaction } from './blockchain/prepareTransaction';
 /** services exports */
 export { EvmWalletService, } from './services/evm-wallet-core/evmWalletService';
 export { createWallet, signMessage, signTransaction } from './services/evm-wallet-core/signer';

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

@@ -20,6 +20,10 @@ export declare class EvmWalletService {
     generateMultipleWallets(mnemonic: string, count: number, startIndex?: number): EvmDerivedWallet[];
     deriveWalletFromMnemonic(mnemonic: string, accountIndex?: number, customPath?: string): EvmDerivedWallet;
     deriveFromPrivateKey(privateKey: string): Omit<EvmDerivedWallet, 'path'>;
+    getFirstAvailableIndexForMnemonicImport(mnemonic: string, existingAddresses: string[], maxIndicesToCheck?: number): {
+        index: number;
+        wallet: EvmDerivedWallet;
+    } | null;
     signMessage(privateKey: string, message: string): Promise<string>;
     isValidMnemonic(mnemonic: string): boolean;
     private validateMnemonic;

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

@@ -1,5 +1,5 @@
 /** npm imports */
-import { Wallet, HDNodeWallet, Mnemonic } from 'ethers';
+import { Wallet, HDNodeWallet, Mnemonic, getAddress } from 'ethers';
 export class EvmWalletService {
     constructor(entropy) {
         this.entropy = entropy;
@@ -55,6 +55,18 @@ export class EvmWalletService {
             publicKey: wallet.signingKey.publicKey,
         };
     }
+    getFirstAvailableIndexForMnemonicImport(mnemonic, existingAddresses, maxIndicesToCheck = 20) {
+        this.validateMnemonic(mnemonic);
+        const existingSet = new Set(existingAddresses.map((addr) => getAddress(addr)));
+        for (let i = 0; i < maxIndicesToCheck; i++) {
+            const wallet = this.deriveWalletFromMnemonic(mnemonic, i);
+            const normalizedAddress = getAddress(wallet.address);
+            if (!existingSet.has(normalizedAddress)) {
+                return { index: i, wallet };
+            }
+        }
+        return null;
+    }
     async signMessage(privateKey, message) {
         const wallet = new Wallet(privateKey);
         return await wallet.signMessage(message);
@@ -69,9 +81,8 @@ export class EvmWalletService {
         }
     }
     validateMnemonic(mnemonic) {
-        if (!this.isValidMnemonic(mnemonic)) {
+        if (!this.isValidMnemonic(mnemonic))
             throw new Error('Invalid mnemonic phrase');
-        }
     }
     getEntropyForWordCount(wordCount) {
         const entropyMap = {

package/dist/types/common.d.ts

@@ -17,36 +17,59 @@ export interface GasEstimateResult {
         gasPrice?: bigint;
     };
 }
+export interface EstimateTransactionOptions {
+    rpcUrl: string;
+    chainId: number;
+    tx: TransactionRequest;
+    fromAddress: string;
+    defaultGasLimit?: bigint;
+}
+export interface PrepareTransactionParams extends EstimateTransactionOptions {
+}
+export interface EstimateTransactionResult {
+    gasLimit: bigint;
+    gasEstimated: bigint;
+    feeData: {
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        gasPrice?: bigint;
+    };
+    gasReserve?: bigint;
+    humanReadableGasReserve: string;
+    bufferPercentage: number;
+}
+export interface PrepareTransactionResult {
+    unsignedTx: TransactionRequest;
+    nonce: number;
+    gasEstimated: bigint;
+    gasLimit: bigint;
+    gasReserve?: bigint;
+    bufferPercentage: number;
+    feeData: {
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        gasPrice?: bigint;
+    };
+    humanReadableGasReserve: string;
+}
+export interface BuildBaseUnsignedTransferTxParams {
+    recipientAddress: string;
+    value: string;
+    tokenAddress?: string;
+    tokenDecimals?: number;
+}
 export interface BuildUnsignedTransferTxOptions {
     fromAddress: string;
     toAddress: string;
     value?: string;
-    data?: string;
     tokenAddress?: string;
     tokenDecimals?: number;
     rpcUrl: string;
     chainId?: number;
     defaultGasLimit: bigint;
 }
-export interface UnsignedTransferTxResponse {
-    unsignedTx: TransactionRequest;
-    nonce: number;
-    gasEstimated: string;
-    gasLimit: string;
-    gasReserve?: string;
-    bufferPercentage: number;
-    feeData: {
-        maxFeePerGas?: string;
-        maxPriorityFeePerGas?: string;
-        gasPrice?: string;
-    };
-}
-export interface BuildMaxNativeTransferTxOptions extends Omit<BuildUnsignedTransferTxOptions, 'value' | 'tokenAddress' | 'tokenDecimals'> {
+export interface BuildMaxNativeTransferTxOptions extends Omit<BuildUnsignedTransferTxOptions, 'value' | 'tokenDecimals'> {
     balance: string;
-    tokenAddress?: string;
-}
-export interface BuildMaxNativeTransferTxResponse extends UnsignedTransferTxResponse {
-    sendableValue: string;
 }
 export interface BroadcastTransactionOptions {
     signedTx: string;

package/dist/utils/getShortenTxHash.d.ts

@@ -1,2 +1,2 @@
-export declare const getShortenTransactionHashOrAddress: (txHashOrAddress: string) => string;
-export declare const getShortenData: (data: string) => string;
+export declare const getShortenTransactionHashOrAddress: (txHashOrAddress: string, firstPartLength?: number, lastPartLength?: number) => string;
+export declare const getShortenData: (data: string, firstPartLength?: number, lastPartLength?: number) => string;

package/dist/utils/getShortenTxHash.js

@@ -1,10 +1,10 @@
-export const getShortenTransactionHashOrAddress = (txHashOrAddress) => {
-    const firstCharacters = txHashOrAddress.substring(0, 6);
-    const lastCharacters = txHashOrAddress.slice(-4);
+export const getShortenTransactionHashOrAddress = (txHashOrAddress, firstPartLength = 6, lastPartLength = 4) => {
+    const firstCharacters = txHashOrAddress.substring(0, firstPartLength);
+    const lastCharacters = txHashOrAddress.slice(-lastPartLength);
     return `${firstCharacters}...${lastCharacters}`;
 };
-export const getShortenData = (data) => {
-    const firstCharacters = data.substring(0, 12);
-    const lastCharacters = data.slice(-12);
+export const getShortenData = (data, firstPartLength = 12, lastPartLength = 12) => {
+    const firstCharacters = data.substring(0, firstPartLength);
+    const lastCharacters = data.slice(-lastPartLength);
     return `${firstCharacters}...${lastCharacters}`;
 };

package/package.json

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