@layerswap/wallet-fuel 1.0.0

package/dist/esm/connectors/fuel-wallet/FuelWalletConnector.js

@@ -0,0 +1,234 @@
+import { Address, FuelConnector, FuelConnectorEventType, FuelConnectorEventTypes, Provider, transactionRequestify, } from 'fuels';
+import { JSONRPCClient } from 'json-rpc-2.0';
+import { APP_IMAGE, CONNECTOR_SCRIPT, CONTENT_SCRIPT_NAME, EVENT_MESSAGE, } from './constants';
+import { MessageTypes, } from './types';
+export class FuelWalletConnector extends FuelConnector {
+    constructor(name = 'Fuel Wallet') {
+        super();
+        this.name = '';
+        this.connected = false;
+        this.installed = false;
+        this.external = false;
+        this.events = FuelConnectorEventTypes;
+        this.metadata = {
+            image: APP_IMAGE,
+            install: {
+                action: 'Install',
+                description: 'To connect your Fuel Wallet, install the browser extension.',
+                link: 'https://chrome.google.com/webstore/detail/fuel-wallet/dldjpboieedgcmpkchcjcbijingjcgok',
+            },
+        };
+        this.onMessage = (message) => {
+            const messageFroze = Object.freeze(message);
+            if (!this.acceptMessage(messageFroze))
+                return;
+            const { data: event } = messageFroze;
+            this.onCommunicationMessage(event);
+        };
+        this.onCommunicationMessage = (message) => {
+            switch (message.type) {
+                case MessageTypes.response:
+                    this.onResponse(message);
+                    break;
+                case MessageTypes.event:
+                    this.onEvent(message);
+                    break;
+                default:
+            }
+        };
+        this.name = name;
+        this.setMaxListeners(100);
+        this.client = new JSONRPCClient(this.sendRequest.bind(this), this.createRequestId);
+        this.setupListener();
+        this.setupConnector();
+    }
+    /**
+     * ============================================================
+     * Application communication methods
+     * ============================================================
+     */
+    async setupConnector() {
+        if (typeof window !== 'undefined') {
+            this.ping()
+                .then(() => {
+                window.dispatchEvent(new CustomEvent(FuelConnectorEventType, { detail: this }));
+            })
+                .catch(() => { });
+        }
+    }
+    acceptMessage(message) {
+        const { data: event } = message;
+        return (message.origin === window.origin &&
+            event.type !== MessageTypes.request &&
+            event.connectorName === this.name &&
+            event.target === CONNECTOR_SCRIPT);
+    }
+    setupListener() {
+        if (typeof window === 'undefined')
+            return;
+        window.addEventListener(EVENT_MESSAGE, this.onMessage.bind(this));
+    }
+    createRequestId() {
+        return crypto.randomUUID();
+    }
+    postMessage(message, origin) {
+        window.postMessage(message, origin || window.origin);
+    }
+    async sendRequest(request) {
+        if (!request)
+            return;
+        this.postMessage({
+            type: MessageTypes.request,
+            target: CONTENT_SCRIPT_NAME,
+            connectorName: this.name,
+            request,
+        });
+    }
+    onResponse(message) {
+        this.client.receive(message.response);
+    }
+    onEvent(message) {
+        message.events.forEach((eventData) => {
+            if (eventData.event === 'start') {
+                this.setupConnector();
+            }
+            else {
+                this.emit(eventData.event, ...eventData.params);
+            }
+        });
+    }
+    /**
+     * ============================================================
+     * Connector methods
+     * ============================================================
+     */
+    async ping() {
+        return this.client.timeout(800).request('ping', {});
+    }
+    async isConnected() {
+        // If the wallet not exists or not connected, return false
+        try {
+            return await this.client.request('isConnected', {});
+        }
+        catch {
+            return false;
+        }
+    }
+    async connect() {
+        return this.client.request('connect', {});
+    }
+    async disconnect() {
+        return this.client.request('disconnect', {});
+    }
+    async accounts() {
+        const accounts = await this.client.request('accounts', {});
+        return accounts;
+    }
+    async currentAccount() {
+        const account = await this.client.request('currentAccount', {});
+        if (!account)
+            return null;
+        return Address.fromDynamicInput(account).toString();
+    }
+    async signMessage(address, message) {
+        if (!message.trim()) {
+            throw new Error('Message is required');
+        }
+        return this.client.request('signMessage', {
+            address,
+            message,
+        });
+    }
+    async sendTransaction(address, transaction) {
+        if (!transaction) {
+            throw new Error('Transaction is required');
+        }
+        // Transform transaction object to a transaction request
+        const txRequest = transactionRequestify(transaction);
+        /**
+         * @todo We should remove this once the chainId standard start to be used and chainId is required
+         * to be correct according to the network the transaction wants to target.
+         */
+        const network = await this.currentNetwork();
+        const provider = {
+            url: network.url,
+        };
+        return this.client.request('sendTransaction', {
+            address,
+            transaction: JSON.stringify(txRequest),
+            provider,
+        });
+    }
+    async assets() {
+        return this.client.request('assets', {});
+    }
+    async addAsset(asset) {
+        return this.addAssets([asset]);
+    }
+    async addAssets(assets) {
+        /**
+         * @todo: Remove this once Fuel Wallet supports assets with multiple networks
+         */
+        const assetsData = assets.map((asset) => {
+            const fuelNetworkAsset = asset.networks.find((n) => n.type === 'fuel');
+            if (!fuelNetworkAsset) {
+                throw new Error('Asset for Fuel Network not found!');
+            }
+            return {
+                ...asset,
+                imageUrl: asset.icon,
+                decimals: fuelNetworkAsset.decimals,
+                assetId: fuelNetworkAsset.assetId,
+            };
+        });
+        return this.client.request('addAssets', {
+            assets: assetsData,
+        });
+    }
+    async addABI(contractId, abi) {
+        return this.client.request('addAbi', {
+            abiMap: {
+                [contractId]: abi,
+            },
+        });
+    }
+    async getABI(contractId) {
+        return this.client.request('getAbi', {
+            contractId,
+        });
+    }
+    async hasABI(contractId) {
+        const abi = await this.getABI(contractId);
+        return !!abi;
+    }
+    async currentNetwork() {
+        return this.client.request('network', {});
+    }
+    async selectNetwork(network) {
+        return this.client.request('selectNetwork', {
+            network,
+        });
+    }
+    async networks() {
+        return this.client.request('networks', {});
+    }
+    async addNetwork(networkUrl) {
+        /**
+         * @todo: Remove fetch provider once Fuel Wallet supports adding networks
+         * by URL
+         */
+        const provider = new Provider(networkUrl);
+        return this.client.request('addNetwork', {
+            network: {
+                url: provider.url,
+                name: (await provider.getChain()).name,
+            },
+        });
+    }
+    async version() {
+        return this.client.request('version', {
+            app: '0.0.0',
+            network: '0.0.0',
+        });
+    }
+}

package/dist/esm/connectors/fuel-wallet/constants.js

@@ -0,0 +1,4 @@
+export const CONNECTOR_SCRIPT = 'FuelConnectorScript';
+export const CONTENT_SCRIPT_NAME = 'FuelContentScript';
+export const EVENT_MESSAGE = 'message';
+export const APP_IMAGE = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCA0OTEgNDk2IiBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHRoZW1lPSJkYXJrIj48dGl0bGU+RnVlbCBXYWxsZXQgSWNvbjwvdGl0bGU+PHJlY3QgeD0iNDIuNTUzNSIgeT0iMjguMzQzOCIgd2lkdGg9IjM5Ny4xNTQiIGhlaWdodD0iNDI1LjE0MyIgZmlsbD0iIzA4MDgwOCI+PC9yZWN0PjxwYXRoIGQ9Ik0zMi42MTc4IDBDMTQuNTY5NyAwIDAgMTQuNzMyNyAwIDMyLjk4MjZWNDk2SDQwNS44NTJDNDE5LjU2OCA0OTYgNDMyLjc1OSA0OTAuNDkyIDQ0Mi40NzMgNDgwLjY3TDQ3NS4zNTMgNDQ3LjQyMkM0ODUuMDY2IDQzNy42IDQ5MC41MTMgNDI0LjI2MSA0OTAuNTEzIDQxMC4zOTFWMEgzMi42MTc4Wk0zMjAuMjcxIDYzLjc3NTJMMTYwLjcyNiAyMjUuMTA1QzE1Ni43ODggMjI5LjA4NiAxNTEuNDA3IDIzMS4zNDMgMTQ1LjgyOCAyMzEuMzQzQzEzNy42OSAyMzEuMzQzIDEzMC4yMDggMjI2LjU2NSAxMjYuNzMgMjE5LjEzMkw2NC45MDc0IDg3LjAwMjRDNTkuODUzOSA3Ni4xODUyIDY3LjY2MzggNjMuNzc1MiA3OS40NzcxIDYzLjc3NTJIMzIwLjI3MVpNNjMuMDY5NyA0MzIuMjI1VjI3NS4yNzVDNjMuMDY5NyAyNjYuOTE0IDY5Ljc2MzkgMjYwLjE0NSA3OC4wMzMyIDI2MC4xNDVIMjMzLjI0Nkw2My4wNjk3IDQzMi4yMjVaTTI0Ni4xMSAyMzEuMzQzSDE5NC43MjJMMzQ5LjM0NSA3NC45OTA2QzM1Ni40MzMgNjcuODIzNCAzNjYuMDggNjMuNzc1MiAzNzYuMTIxIDYzLjc3NTJINDI3LjUwOUwyNzIuODg3IDIyMC4xMjdDMjY1Ljc5OSAyMjcuMjk1IDI1Ni4xNTEgMjMxLjM0MyAyNDYuMTEgMjMxLjM0M1oiIGZpbGw9IiMwMEY1OEMiPjwvcGF0aD48L3N2Zz4=';

package/dist/esm/connectors/fuel-wallet/index.js

@@ -0,0 +1,3 @@
+export * from './constants';
+export { FuelWalletConnector } from './FuelWalletConnector';
+export * from './types';

package/dist/esm/connectors/fuel-wallet/types.js

@@ -0,0 +1,9 @@
+export var MessageTypes;
+(function (MessageTypes) {
+    MessageTypes["ping"] = "ping";
+    MessageTypes["uiEvent"] = "uiEvent";
+    MessageTypes["event"] = "event";
+    MessageTypes["request"] = "request";
+    MessageTypes["response"] = "response";
+    MessageTypes["removeConnection"] = "removeConnection";
+})(MessageTypes || (MessageTypes = {}));

package/dist/esm/connectors/fuelet-wallet/FueletWalletConnector.js

@@ -0,0 +1,19 @@
+import { APP_IMAGE_DARK, APP_IMAGE_LIGHT } from './constants';
+import { FuelWalletConnector } from '../fuel-wallet';
+export class FueletWalletConnector extends FuelWalletConnector {
+    constructor() {
+        super('Fuelet Wallet');
+        this.name = 'Fuelet Wallet';
+        this.metadata = {
+            image: {
+                light: APP_IMAGE_LIGHT,
+                dark: APP_IMAGE_DARK,
+            },
+            install: {
+                action: 'Install',
+                description: 'Install Fuelet Wallet in order to connect it.',
+                link: 'https://fuelet.app/download/',
+            },
+        };
+    }
+}

package/dist/esm/connectors/fuelet-wallet/constants.js

@@ -0,0 +1,2 @@
+export const APP_IMAGE_DARK = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCA0MCA0MCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+RnVlbGV0IEljb248L3RpdGxlPjxwYXRoIGQ9Ik0yMCA0MEMxNC45MzU1IDQwIDEwLjMxNDUgMzguMTE0IDYuNzkwNSAzNS4wMTA1TDE4LjE0NiAyNi45MDdDMTguODQ1IDI2LjQwODUgMTkuODA2NSAyNi45NjQ1IDE5LjcyMiAyNy44MTk1TDE5LjI3NDUgMzIuMzYwNUMxOS4xODIgMzMuMjk1IDIwLjMxMjUgMzMuODI5NSAyMC45NzY1IDMzLjE2NTVMMjcuMDcxIDI3LjA3MUMzMS4wNjIgMjMuMDggMzAuOTc0NSAxNi41NTU1IDI2LjgwODUgMTIuNjc1NUMyMi44NDA1IDguOTggMTYuNTkzNSA5LjI2NCAxMi43NTk1IDEzLjA5ODVMNi44NTMgMTkuMDA0NUM2LjE4NyAxOS42NzEgNi43Mjc1IDIwLjgwNDUgNy42NjQ1IDIwLjcwNjVMMTIuMjA5IDIwLjIzMUMxMy4wNjU1IDIwLjE0MTUgMTMuNjI3NSAyMS4xMDUgMTMuMTI3IDIxLjgwNjVMNC45ODk1IDMzLjIwOTVDMS44ODYgMjkuNjg1NSAwIDI1LjA2NDUgMCAyMEMwIDguOTU0NSA4Ljk1NDUgMCAyMCAwQzMxLjA0NTUgMCA0MCA4Ljk1NDUgNDAgMjBDNDAgMzEuMDQ1NSAzMS4wNDU1IDQwIDIwIDQwWiIgZmlsbD0id2hpdGUiPjwvcGF0aD48L3N2Zz4=';
+export const APP_IMAGE_LIGHT = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCA0MCA0MCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+RnVlbGV0IEljb248L3RpdGxlPjxwYXRoIGQ9Ik0yMCA0MEMxNC45MzU1IDQwIDEwLjMxNDUgMzguMTE0IDYuNzkwNSAzNS4wMTA1TDE4LjE0NiAyNi45MDdDMTguODQ1IDI2LjQwODUgMTkuODA2NSAyNi45NjQ1IDE5LjcyMiAyNy44MTk1TDE5LjI3NDUgMzIuMzYwNUMxOS4xODIgMzMuMjk1IDIwLjMxMjUgMzMuODI5NSAyMC45NzY1IDMzLjE2NTVMMjcuMDcxIDI3LjA3MUMzMS4wNjIgMjMuMDggMzAuOTc0NSAxNi41NTU1IDI2LjgwODUgMTIuNjc1NUMyMi44NDA1IDguOTggMTYuNTkzNSA5LjI2NCAxMi43NTk1IDEzLjA5ODVMNi44NTMgMTkuMDA0NUM2LjE4NyAxOS42NzEgNi43Mjc1IDIwLjgwNDUgNy42NjQ1IDIwLjcwNjVMMTIuMjA5IDIwLjIzMUMxMy4wNjU1IDIwLjE0MTUgMTMuNjI3NSAyMS4xMDUgMTMuMTI3IDIxLjgwNjVMNC45ODk1IDMzLjIwOTVDMS44ODYgMjkuNjg1NSAwIDI1LjA2NDUgMCAyMEMwIDguOTU0NSA4Ljk1NDUgMCAyMCAwQzMxLjA0NTUgMCA0MCA4Ljk1NDUgNDAgMjBDNDAgMzEuMDQ1NSAzMS4wNDU1IDQwIDIwIDQwWiIgZmlsbD0iIzI4MjgyRiI+PC9wYXRoPjwvc3ZnPg==';

package/dist/esm/connectors/fuelet-wallet/index.js

@@ -0,0 +1 @@
+export { FueletWalletConnector } from './FueletWalletConnector';

package/dist/esm/fuelAddressUtilsProvider.js

@@ -0,0 +1,19 @@
+import { KnownInternalNames } from "@layerswap/widget/internal";
+export class FuelAddressUtilsProvider {
+    supportsNetwork(network) {
+        return (KnownInternalNames.Networks.FuelMainnet.includes(network.name) || KnownInternalNames.Networks.FuelTestnet.includes(network.name));
+    }
+    isValidAddress(address) {
+        if (!address) {
+            return false;
+        }
+        const hexRegex = /^[0-9a-fA-F]+$/;
+        if (address.startsWith("0x")) {
+            address = address.slice(2); // Remove the "0x" prefix
+        }
+        else {
+            return false;
+        }
+        return address.length === 64 && hexRegex.test(address);
+    }
+}

package/dist/esm/fuelBalanceProvider.js

@@ -0,0 +1,61 @@
+import { retryWithExponentialBackoff, fetchWithTimeout, KnownInternalNames, formatUnits } from "@layerswap/widget/internal";
+import { BalanceProvider } from "@layerswap/widget/types";
+export class FuelBalanceProvider extends BalanceProvider {
+    constructor() {
+        super(...arguments);
+        this.supportsNetwork = (network) => {
+            return KnownInternalNames.Networks.FuelMainnet.includes(network.name) || KnownInternalNames.Networks.FuelTestnet.includes(network.name);
+        };
+        this.fetchBalance = async (address, network, options) => {
+            let balances = [];
+            if (!network?.tokens)
+                return;
+            const BALANCES_QUERY = `query Balances($filter: BalanceFilterInput) {
+            balances(filter: $filter, first: 5) {
+              nodes {
+                amount
+                assetId
+              }
+            }
+          }`;
+            const BALANCES_ARGS = {
+                filter: {
+                    owner: address,
+                },
+            };
+            try {
+                const response = await retryWithExponentialBackoff(async () => await fetchWithTimeout(network.node_url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json',
+                    },
+                    body: JSON.stringify({
+                        query: BALANCES_QUERY,
+                        variables: BALANCES_ARGS,
+                    }),
+                    timeoutMs: options?.timeoutMs ?? 60000,
+                }), options?.retryCount ?? 3);
+                const json = await response.json();
+                for (let i = 0; i < network.tokens.length; i++) {
+                    const token = network.tokens[i];
+                    const balance = json.data.balances.nodes.find(b => b?.assetId === token.contract) || null;
+                    const balanceObj = {
+                        network: network.name,
+                        amount: balance?.amount ? Number(formatUnits(BigInt(Number(balance?.amount)), token.decimals)) : undefined,
+                        decimals: token.decimals,
+                        isNativeCurrency: network.token?.symbol === token.symbol,
+                        token: token.symbol,
+                        request_time: new Date().toJSON(),
+                        error: balance?.amount === undefined ? `Could not fetch balance for ${token.symbol}` : undefined
+                    };
+                    balances.push(balanceObj);
+                }
+            }
+            catch (e) {
+                return network.tokens.map((currency) => (this.resolveTokenBalanceFetchError(e, currency, network)));
+            }
+            return balances;
+        };
+    }
+}

package/dist/esm/fuelGasProvider.js

@@ -0,0 +1,38 @@
+import WatchdogAbi from './jsons/FUELWATCHDOG.json';
+import { KnownInternalNames, formatUnits } from "@layerswap/widget/internal";
+export class FuelGasProvider {
+    supportsNetwork(network) {
+        return (KnownInternalNames.Networks.FuelMainnet.includes(network.name) || KnownInternalNames.Networks.FuelTestnet.includes(network.name));
+    }
+    async getGas({ address, network, token }) {
+        if (!network.metadata?.watchdog_contract)
+            throw new Error("Watchdog contract not found");
+        if (!network?.token)
+            throw new Error("No native token provided");
+        try {
+            const { Provider, Contract, Address } = await import('fuels');
+            const provider = new Provider(network?.node_url);
+            const contract = new Contract(network.metadata?.watchdog_contract, WatchdogAbi, provider);
+            const asset_id = await provider.getBaseAssetId();
+            const assetAddress = Address.fromB256(token.contract || asset_id);
+            const assetId = assetAddress.toAssetId();
+            const parsedAmount = 0.005 * Math.pow(10, token?.decimals);
+            const receiver = { bits: Address.fromDynamicInput('0x0B1956a6737cb62fF5E66479F7770315fb5055BB75888b6C2Be43155F6dF1704').toB256() };
+            const scope = contract.functions
+                .watch(42069, receiver)
+                .txParams({
+                variableOutputs: 1,
+            })
+                .callParams({
+                forward: [parsedAmount, assetId.bits],
+            });
+            const { maxFee } = await scope.getTransactionCost();
+            const formatedGas = Number((Number(formatUnits(BigInt(Number(maxFee)), network.token.decimals)) * 2).toFixed(network.token.decimals));
+            if (formatedGas)
+                return { gas: formatedGas, token: network.token };
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,13 @@
+import { FuelAddressUtilsProvider } from "./fuelAddressUtilsProvider";
+import { FuelBalanceProvider } from "./fuelBalanceProvider";
+import { FuelGasProvider } from "./fuelGasProvider";
+import FuelProviderWrapper from "./FuelProvider";
+import useFuelConnection from "./useFuelConnection";
+export const FuelProvider = {
+    id: "fuel",
+    wrapper: FuelProviderWrapper,
+    walletConnectionProvider: useFuelConnection,
+    addressUtilsProvider: new FuelAddressUtilsProvider(),
+    balanceProvider: new FuelBalanceProvider(),
+    gasProvider: new FuelGasProvider(),
+};

package/dist/esm/jsons/FUELWATCHDOG.json

@@ -0,0 +1,96 @@
+{
+    "programType": "contract",
+    "specVersion": "1",
+    "encodingVersion": "1",
+    "concreteTypes": [
+        {
+            "type": "()",
+            "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+        },
+        {
+            "type": "str",
+            "concreteTypeId": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a"
+        },
+        {
+            "type": "struct SwapID",
+            "concreteTypeId": "fe04d267f8e97aed4f214782e62e801a27fa2df26a2c7585be443083908a349d",
+            "metadataTypeId": 1
+        },
+        {
+            "type": "struct std::address::Address",
+            "concreteTypeId": "f597b637c3b0f588fb8d7086c6f4735caa3122b85f0423b82e489f9bb58e2308",
+            "metadataTypeId": 2
+        },
+        {
+            "type": "u256",
+            "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e"
+        }
+    ],
+    "metadataTypes": [
+        {
+            "type": "b256",
+            "metadataTypeId": 0
+        },
+        {
+            "type": "struct SwapID",
+            "metadataTypeId": 1,
+            "components": [
+                {
+                    "name": "num",
+                    "typeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e"
+                }
+            ]
+        },
+        {
+            "type": "struct std::address::Address",
+            "metadataTypeId": 2,
+            "components": [
+                {
+                    "name": "bits",
+                    "typeId": 0
+                }
+            ]
+        }
+    ],
+    "functions": [
+        {
+            "inputs": [
+                {
+                    "name": "ID",
+                    "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e"
+                },
+                {
+                    "name": "recipient",
+                    "concreteTypeId": "f597b637c3b0f588fb8d7086c6f4735caa3122b85f0423b82e489f9bb58e2308"
+                }
+            ],
+            "name": "watch",
+            "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+            "attributes": [
+                {
+                    "name": "payable",
+                    "arguments": []
+                },
+                {
+                    "name": "storage",
+                    "arguments": [
+                        "read",
+                        "write"
+                    ]
+                }
+            ]
+        }
+    ],
+    "loggedTypes": [
+        {
+            "logId": "10098701174489624218",
+            "concreteTypeId": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a"
+        },
+        {
+            "logId": "18303986129540053741",
+            "concreteTypeId": "fe04d267f8e97aed4f214782e62e801a27fa2df26a2c7585be443083908a349d"
+        }
+    ],
+    "messagesTypes": [],
+    "configurables": []
+}

package/dist/esm/services/transferService/transactionBuilder.js

@@ -0,0 +1,11 @@
+import { coinQuantityfy, ScriptTransactionRequest } from 'fuels';
+export const transactionBuilder = async (params) => {
+    const { fuelWallet, callData } = params;
+    var parsedCallData = JSON.parse(callData);
+    var scriptTransaction = ScriptTransactionRequest.from(parsedCallData.script);
+    var quantitiesParsed = parsedCallData.quantities.map(q => coinQuantityfy(q));
+    await scriptTransaction.estimateAndFund(fuelWallet, {
+        quantities: quantitiesParsed
+    });
+    return scriptTransaction;
+};