@layerswap/wallet-fuel 1.0.0

package/dist/esm/FuelProvider.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BakoRequestAPI } from './connectors/bako-safe/Bako';
+import { BakoSafeConnector } from './connectors/bako-safe';
+import { FuelProvider } from '@fuels/react';
+import { FueletWalletConnector } from './connectors/fuelet-wallet';
+import { FuelWalletConnector } from './connectors/fuel-wallet';
+import { useSettingsState } from '@layerswap/widget/internal';
+import { NetworkType } from '@layerswap/widget/types';
+import { useMemo } from 'react';
+const HOST_URL = 'https://api.bako.global';
+const FuelProviderWrapper = ({ children }) => {
+    const { networks } = useSettingsState();
+    const fuelConfig = {
+        connectors: [
+            new FuelWalletConnector(),
+            new BakoSafeConnector({
+                api: new BakoRequestAPI(HOST_URL)
+            }),
+            new FueletWalletConnector(),
+        ]
+    };
+    const fuelNetworks = useMemo(() => networks.filter(n => n.type == NetworkType.Fuel).map((network) => ({
+        chainId: Number(network.chain_id)
+    })), [networks]);
+    return (_jsx(FuelProvider, { uiConfig: { suggestBridge: false }, theme: 'dark', fuelConfig: fuelConfig, networks: fuelNetworks, children: children }));
+};
+export default FuelProviderWrapper;

package/dist/esm/connectors/bako-safe/Bako.js

@@ -0,0 +1,29 @@
+import { urlJoin } from "@fuel-ts/account";
+export class BAKO_STATE {
+}
+BAKO_STATE.state = { data: false, req_count: 0 };
+BAKO_STATE.period_durtion = 10000;
+export class BakoRequestAPI {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    async get(pathname) {
+        if (!pathname.includes('/state')) {
+            const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) => res.json());
+            return data;
+        }
+        const period_elapsed = BAKO_STATE.state?.period_start && new Date().getTime() - BAKO_STATE.state?.period_start?.getTime() > BAKO_STATE.period_durtion;
+        const skip = BAKO_STATE.state?.last_req && new Date().getTime() - BAKO_STATE.state?.last_req?.getTime() < 1000 * 60 * 2 && period_elapsed;
+        if (skip)
+            return BAKO_STATE.state?.data;
+        const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) => res.json());
+        const count = BAKO_STATE.state?.req_count || 0;
+        BAKO_STATE.state = { last_req: new Date(), data, req_count: count + 1, period_start: period_elapsed ? new Date() : BAKO_STATE.state?.period_start || new Date() };
+        return data;
+    }
+    async delete(pathname) {
+        await fetch(urlJoin(this.baseUrl, pathname), {
+            method: 'DELETE',
+        });
+    }
+}

package/dist/esm/connectors/bako-safe/BakoSafeConnector.js

@@ -0,0 +1,268 @@
+import { FuelConnector, FuelConnectorEventTypes, Provider, } from 'fuels';
+import { BakoStorage } from './BakoSafeStorage';
+import { DAppWindow } from './DAPPWindow';
+import { SocketClient } from './SocketClient';
+import { APP_DESCRIPTION, APP_IMAGE_DARK, APP_IMAGE_LIGHT, APP_NAME, APP_NETWORK, APP_URL, APP_VERSION, HAS_WINDOW, HOST_URL, IS_SAFARI, SESSION_ID, WINDOW, } from './constants';
+import { RequestAPI } from './request';
+import { BakoSafeConnectorEvents, } from './types';
+export class BakoSafeConnector extends FuelConnector {
+    constructor(config) {
+        super();
+        this.name = APP_NAME;
+        this.metadata = {
+            image: {
+                light: APP_IMAGE_LIGHT,
+                dark: APP_IMAGE_DARK,
+            },
+            install: {
+                action: APP_URL,
+                link: APP_URL,
+                description: APP_DESCRIPTION,
+            },
+        };
+        this.installed = !IS_SAFARI;
+        this.connected = false;
+        this.external = false;
+        this.host = config?.host ?? HOST_URL;
+        this.appUrl = config?.appUrl ?? APP_URL;
+        this.api = config?.api ?? new RequestAPI(this.host);
+        this.storage = this.getStorage(config?.storage);
+        this.setupReady = false;
+    }
+    // ============================================================
+    // Bako Safe application specific methods
+    // ============================================================
+    getStorage(storage) {
+        const _storage = storage ?? WINDOW.localStorage ?? new BakoStorage();
+        if (!_storage) {
+            throw new Error('No storage provided');
+        }
+        return _storage;
+    }
+    async getSessionId() {
+        let sessionId = (await this.storage?.getItem(SESSION_ID)) || '';
+        if (!sessionId) {
+            sessionId = crypto.randomUUID();
+            await this.storage?.setItem(SESSION_ID, sessionId);
+        }
+        return sessionId;
+    }
+    checkWindow() {
+        // timeout to open
+        const openInterval = setInterval(() => {
+            const isOpen = this.dAppWindow?.isOpen;
+            if (!isOpen) {
+                this.emit(BakoSafeConnectorEvents.CLIENT_DISCONNECTED, {});
+                clearInterval(openInterval);
+            }
+        }, 2000);
+        // timeout to close
+        const interval = setInterval(() => {
+            const isOpen = this.dAppWindow?.opned?.closed;
+            if (isOpen) {
+                this.emit(BakoSafeConnectorEvents.CLIENT_DISCONNECTED, {});
+                clearInterval(interval);
+            }
+        }, 300);
+    }
+    /**
+     * [important]
+     * this.socket.emit -> emit message to the server
+     * this.emit -> emit message to the dApp client
+     */
+    async setup() {
+        if (!HAS_WINDOW)
+            return;
+        if (this.socket)
+            this.socket.checkConnection();
+        if (this.setupReady)
+            return;
+        this.setupReady = true;
+        const sessionId = await this.getSessionId();
+        this.sessionId = sessionId;
+        this.socket = SocketClient.create({
+            sessionId,
+            events: this,
+        });
+        this.dAppWindow = new DAppWindow({
+            sessionId,
+            height: 800,
+            width: 450,
+            appUrl: this.appUrl,
+            request_id: this.socket.request_id,
+        });
+        await this.requestConnectionState();
+    }
+    async requestConnectionState() {
+        return new Promise((resolve) => {
+            if (!this.socket)
+                return;
+            this.socket.server.emit(BakoSafeConnectorEvents.CONNECTION_STATE);
+            this.socket.server.once(BakoSafeConnectorEvents.CONNECTION_STATE, async ({ data }) => {
+                this.connected = data;
+                this.emit(this.events.connection, data);
+                resolve();
+            });
+        });
+    }
+    // ============================================================
+    // Connector methods
+    // ============================================================
+    async connect() {
+        await this.setup();
+        return new Promise((resolve, reject) => {
+            if (this.connected) {
+                resolve(true);
+                return;
+            }
+            this.dAppWindow?.open('/', reject);
+            this.checkWindow();
+            this.once(BakoSafeConnectorEvents.CLIENT_DISCONNECTED, () => {
+                this.dAppWindow?.close();
+                reject(false);
+            });
+            this.once(BakoSafeConnectorEvents.AUTH_CONFIRMED, async ({ data }) => {
+                await this.requestConnectionState();
+                this.emit(this.events.accounts, await this.accounts());
+                this.emit(this.events.currentAccount, await this.currentAccount());
+                this.dAppWindow?.close();
+                resolve(data.connected);
+            });
+        });
+    }
+    /*
+     * @param {string} address - The address to sign the transaction
+     * @param {Transaction} transaction - The transaction to send
+     *
+     * @returns {string} - The transaction id
+     */
+    async sendTransaction(_address, _transaction) {
+        return new Promise((resolve, reject) => {
+            this.dAppWindow?.open('/dapp/transaction', reject);
+            this.checkWindow();
+            const onClientConnected = () => {
+                this.socket?.server.emit(BakoSafeConnectorEvents.TX_PENDING, {
+                    _transaction,
+                    _address,
+                });
+            };
+            // @ts-ignore
+            this.on(BakoSafeConnectorEvents.CLIENT_CONNECTED, onClientConnected);
+            this.once(BakoSafeConnectorEvents.CLIENT_DISCONNECTED, () => {
+                this.dAppWindow?.close();
+                this.removeListener(BakoSafeConnectorEvents.CLIENT_CONNECTED, onClientConnected);
+                reject(new Error('Client disconnected'));
+            });
+            this.once(BakoSafeConnectorEvents.TX_TIMEOUT, () => {
+                this.dAppWindow?.close();
+                this.removeListener(BakoSafeConnectorEvents.CLIENT_CONNECTED, onClientConnected);
+                reject(new Error('Transaction timeout'));
+            });
+            this.once(BakoSafeConnectorEvents.TX_CONFIRMED, ({ data }) => {
+                this.removeListener(BakoSafeConnectorEvents.CLIENT_CONNECTED, onClientConnected);
+                resolve(`0x${data.id}`);
+            });
+        });
+    }
+    async selectNetwork(_network) {
+        return new Promise((resolve, reject) => {
+            this.dAppWindow?.open('/dapp/network', reject);
+            this.checkWindow();
+            const onClientConnected = () => {
+                this.socket?.server.emit(BakoSafeConnectorEvents.CHANGE_NETWORK, {
+                    _network,
+                });
+            };
+            // @ts-ignore
+            this.on(BakoSafeConnectorEvents.CLIENT_CONNECTED, onClientConnected);
+            this.once(BakoSafeConnectorEvents.CLIENT_DISCONNECTED, () => {
+                this.dAppWindow?.close();
+                this.removeListener(BakoSafeConnectorEvents.CLIENT_CONNECTED, onClientConnected);
+                reject(new Error('Client disconnected'));
+            });
+            this.once(BakoSafeConnectorEvents.NETWORK_CHANGED, async () => {
+                const network = await this.currentNetwork();
+                this.emit(this.events.networks, [network]);
+                this.emit(this.events.currentNetwork, network);
+                this.dAppWindow?.close();
+                this.removeListener(BakoSafeConnectorEvents.CLIENT_CONNECTED, onClientConnected);
+                resolve(true);
+            });
+        });
+    }
+    async ping() {
+        if (IS_SAFARI) {
+            return false;
+        }
+        await this.setup();
+        return this.setupReady ?? false;
+    }
+    async version() {
+        return {
+            app: APP_VERSION,
+            network: APP_NETWORK,
+        };
+    }
+    async isConnected() {
+        await this.setup();
+        return this.connected;
+    }
+    async accounts() {
+        const data = await this.api.get(`/connections/${this.sessionId}/accounts`);
+        const acc = Array.isArray(data) ? data : [];
+        return acc;
+    }
+    async currentAccount() {
+        const data = await this.api.get(`/connections/${this.sessionId}/currentAccount`);
+        const isInvalid = data && JSON.stringify(data) === JSON.stringify({});
+        return isInvalid ? null : data;
+    }
+    async disconnect() {
+        await this.api.delete(`/connections/${this.sessionId}`);
+        await this.requestConnectionState();
+        this.emit(this.events.accounts, []);
+        this.emit(this.events.currentAccount, null);
+        return false;
+    }
+    async currentNetwork() {
+        const data = await this.api.get(`/connections/${this.sessionId}/currentNetwork`);
+        const provider = new Provider(data);
+        return {
+            url: provider.url,
+            chainId: await provider.getChainId(),
+        };
+    }
+    async networks() {
+        return [await this.currentNetwork()];
+    }
+    async assets() {
+        return [];
+    }
+    async signMessage(_address, _message) {
+        throw new Error('Method not implemented.');
+    }
+    async addAssets(_assets) {
+        throw new Error('Method not implemented.');
+    }
+    async addAsset(_assets) {
+        throw new Error('Method not implemented.');
+    }
+    async addNetwork(_networkUrl) {
+        throw new Error('Method not implemented.');
+    }
+    async addABI(_contractId, _abi) {
+        throw new Error('Method not implemented.');
+    }
+    async getABI(_id) {
+        throw new Error('Method not implemented.');
+    }
+    async hasABI(_id) {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * @inheritdoc
+     */
+    async startConsolidation(opts) {
+        this.emit(FuelConnectorEventTypes.consolidateCoins, opts);
+    }
+}

package/dist/esm/connectors/bako-safe/BakoSafeStorage.js

@@ -0,0 +1,20 @@
+import { StorageAbstract } from 'fuels';
+export class BakoStorage extends StorageAbstract {
+    constructor() {
+        super(...arguments);
+        this.data = {};
+    }
+    async getItem(key) {
+        return this.data[key];
+    }
+    async setItem(key, value) {
+        this.data[key] = value;
+        return;
+    }
+    async removeItem(key) {
+        delete this.data[key];
+    }
+    async clear() {
+        this.data = {};
+    }
+}

package/dist/esm/connectors/bako-safe/DAPPWindow.js

@@ -0,0 +1,130 @@
+import { WINDOW } from './constants';
+export class DAppWindow {
+    constructor(config) {
+        this.config = config;
+        this.isMobile = /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);
+        this.isSafariBrowser = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+        this.isOpen = false;
+        this.opned = null;
+        this.request_id = config.request_id;
+    }
+    get popupConfig() {
+        const { height, width } = this.config;
+        return {
+            top: WINDOW.innerHeight / 2 - height / 2,
+            left: WINDOW.innerWidth / 2 - width / 2,
+            width,
+            height: !this.isMobile && WINDOW.innerHeight >= height
+                ? height
+                : WINDOW.innerHeight,
+        };
+    }
+    open(method, reject) {
+        if (this.isOpen)
+            reject(new Error('Window is already open'));
+        if (!this.isSafariBrowser) {
+            // if is not safari, we can use popup for both cases
+            this.makePopup(method);
+        }
+        // if (this.isSafariBrowser && isConnection) {
+        //   // to use webauthn, we need a new WINDOW
+        //   this.makeLink(method);
+        // }
+        if (this.isSafariBrowser) {
+            // && !isConnection) {
+            // to confirm tx, we need a new popup
+            this.makeFrame(method, true);
+        }
+        return;
+    }
+    close() {
+        const frame = document.getElementById(`${this.config.sessionId}-iframe`);
+        const backdrop = document.getElementById(`${this.config.sessionId}-backdrop`);
+        if (frame)
+            document.body.removeChild(frame);
+        if (backdrop)
+            document.body.removeChild(backdrop);
+        if (this.opned)
+            this.opned.close();
+        this.isOpen = false;
+    }
+    makeLink(method) {
+        const link = `${this.config.appUrl}${method}${this.queryString}`;
+        const a = document.createElement('a');
+        a.setAttribute('href', link);
+        a.setAttribute('target', '_blank');
+        a.click();
+        this.isOpen = true;
+    }
+    makeFrame(method, isSafari = false) {
+        const w = this.small;
+        //bako frame
+        const frame = document.createElement('iframe');
+        frame.id = `${this.config.sessionId}-iframe`;
+        frame.src = `${this.config.appUrl}${method}${this.queryString}${isSafari ? '&byConnector=true' : ''}`;
+        frame.style.position = 'fixed';
+        frame.style.zIndex = '99999999';
+        frame.style.top = `${w.top}`;
+        frame.style.left = `${w.left}`;
+        frame.style.width = w.width;
+        frame.style.height = w.height;
+        frame.style.borderRadius = '16px';
+        //backdrop
+        const backdrop = document.createElement('div');
+        backdrop.id = `${this.config.sessionId}-backdrop`;
+        backdrop.style.position = 'fixed';
+        backdrop.style.top = '0';
+        backdrop.style.left = '0';
+        backdrop.style.width = '100%';
+        backdrop.style.height = '100%';
+        backdrop.style.backgroundColor = 'rgba(0,0,0,0.5)';
+        backdrop.style.zIndex = '99999998';
+        backdrop.addEventListener('click', () => this.close()); // if user click on backdrop, close the frame
+        document.body.appendChild(backdrop);
+        document.body.appendChild(frame);
+        this.isOpen = true;
+    }
+    makePopup(method) {
+        const link = `${this.config.appUrl}${method}${this.queryString}`;
+        const popup = WINDOW.open(link, 'popup', `width=${this.popupConfig.width}, height=${this.popupConfig.height}, top=${this.popupConfig.top}, left=${this.popupConfig.left}`);
+        if (popup)
+            this.opned = popup;
+        this.isOpen = true;
+        return popup;
+    }
+    get queryString() {
+        const { sessionId } = this.config;
+        return `?sessionId=${sessionId}&origin=${WINDOW.location.origin}&name=${WINDOW.document.title}&request_id=${this.request_id}`;
+    }
+    get small() {
+        // todo: update this to calculate by screen size changes
+        const breakponint = {
+            md: {
+                top: 0,
+                left: 0,
+                limit: 650,
+                width: '100%',
+                height: '100%',
+            }, // 100%
+            lg: {
+                top: `${(WINDOW.innerHeight - WINDOW.innerHeight * 0.7) / 2}px`,
+                left: `${(WINDOW.innerWidth - WINDOW.innerWidth * 0.5) / 2}px`,
+                limit: 1024,
+                width: '50%',
+                height: '70%',
+            }, // 75%
+            xl: {
+                top: `${(WINDOW.innerHeight - 650) / 2}px`,
+                left: `${(WINDOW.innerWidth - 500) / 2}px`,
+                limit: 1440,
+                height: '650px',
+                width: '500px',
+            }, // 400px
+        };
+        return WINDOW.innerWidth < breakponint.md.limit
+            ? breakponint.md
+            : WINDOW.innerWidth < breakponint.lg.limit
+                ? breakponint.lg
+                : breakponint.xl;
+    }
+}

package/dist/esm/connectors/bako-safe/SocketClient.js

@@ -0,0 +1,74 @@
+import { io } from 'socket.io-client';
+import { APP_URL, SOCKET_URL } from './constants';
+import { WINDOW } from './constants';
+import { BakoSafeConnectorEvents, BakoSafeUsernames, } from './types';
+const DEFAULT_SOCKET_AUTH = {
+    username: BakoSafeUsernames.CONNECTOR,
+    data: new Date(),
+    origin: WINDOW.origin ?? APP_URL,
+};
+export class SocketClient {
+    constructor({ sessionId, events }) {
+        this.connecting = false;
+        this.request_id = crypto.randomUUID();
+        this.server = io(SOCKET_URL, {
+            auth: {
+                ...DEFAULT_SOCKET_AUTH,
+                sessionId,
+                request_id: this.request_id,
+            },
+            autoConnect: false,
+            reconnection: true,
+            reconnectionAttempts: 5,
+            reconnectionDelay: 1000,
+        });
+        this.server?.on(BakoSafeConnectorEvents.DEFAULT, (data) => {
+            if (data.to === DEFAULT_SOCKET_AUTH.username) {
+                this.events.emit(data.type, {
+                    from: data.username,
+                    data: data.data,
+                });
+            }
+        });
+        this.events = events;
+        this.setupEventListeners();
+        this.connect();
+    }
+    setupEventListeners() {
+        this.server.on('connect', () => {
+            this.connecting = false;
+        });
+        this.server.on('connect_error', () => {
+            this.connecting = false;
+        });
+        this.server.on(BakoSafeConnectorEvents.DEFAULT, (data) => {
+            if (data.to === DEFAULT_SOCKET_AUTH.username) {
+                this.events.emit(data.type, {
+                    from: data.username,
+                    data: data.data,
+                });
+            }
+        });
+    }
+    static create(options) {
+        if (!SocketClient.instance) {
+            SocketClient.instance = new SocketClient(options);
+        }
+        return SocketClient.instance;
+    }
+    connect() {
+        if (this.isConnected || this.connecting)
+            return;
+        this.connecting = true;
+        this.server.connect();
+    }
+    get isConnected() {
+        return this.server.connected;
+    }
+    checkConnection() {
+        if (this.isConnected || this.connecting)
+            return;
+        this.connect();
+    }
+}
+SocketClient.instance = null;

package/dist/esm/connectors/bako-safe/constants.js

@@ -0,0 +1,16 @@
+export const APP_VERSION = '0.0.0';
+export const APP_NETWORK = '0.0.0';
+export const APP_NAME = 'Bako Safe';
+export const APP_DESCRIPTION = 'Bako Safe is a connector to safe.bako.global, a non-custodial vault for your crypto assets.';
+export const APP_IMAGE_DARK = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNTAiIGhlaWdodD0iNTAiIHZpZXdCb3g9IjAgMCA1MCA1MCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiByeD0iOCIgZmlsbD0idXJsKCNwYWludDBfbGluZWFyXzEzMjQ5XzE2MjI4MCkiLz4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzEzMjQ5XzE2MjI4MCkiPgo8cGF0aCBkPSJNMTMgMjUuOTE2N0wzNyAzNy44NjcxTDI1LjAwMjQgMTguOTg5M0wxMyAyNS45MTY3WiIgZmlsbD0iI0Y1RjVGNSIvPgo8cGF0aCBkPSJNMzMuODg2NCAyMi4yMTgyTDI0Ljk5NzYgMTcuMDg2NVY1LjEzNTc0TDEzIDEyLjA2MjhWMjUuOTE2TDI0Ljk5NzYgMTguOTg4OVYzMC45Mzk2TDEzIDM3Ljg2NjhMMjQuOTk3NiA0NC43OTM4TDM2Ljk5NTIgMzcuODY2OFYyNy42MDMzQzM2Ljk5NTIgMjUuMzgxNiAzNS44MDk4IDIzLjMyOTEgMzMuODg2NCAyMi4yMTgyWiIgZmlsbD0iIzFFMUYyMiIvPgo8L2c+CjxkZWZzPgo8bGluZWFyR3JhZGllbnQgaWQ9InBhaW50MF9saW5lYXJfMTMyNDlfMTYyMjgwIiB4MT0iMCIgeTE9IjAiIHgyPSI1Mi4zMjg1IiB5Mj0iNDcuNDMxIiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSI+CjxzdG9wIHN0b3AtY29sb3I9IiNGRkMwMTAiLz4KPHN0b3Agb2Zmc2V0PSIwLjQ4IiBzdG9wLWNvbG9yPSIjRUJBMzEyIi8+CjxzdG9wIG9mZnNldD0iMC43MSIgc3RvcC1jb2xvcj0iI0QzODAxNSIvPgo8c3RvcCBvZmZzZXQ9IjAuOTkiIHN0b3AtY29sb3I9IiNCMjRGMTgiLz4KPC9saW5lYXJHcmFkaWVudD4KPGNsaXBQYXRoIGlkPSJjbGlwMF8xMzI0OV8xNjIyODAiPgo8cmVjdCB3aWR0aD0iMjQiIGhlaWdodD0iNDAiIGZpbGw9IndoaXRlIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMyA1KSIvPgo8L2NsaXBQYXRoPgo8L2RlZnM+Cjwvc3ZnPgo=';
+export const APP_IMAGE_LIGHT = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNTAiIGhlaWdodD0iNTAiIHZpZXdCb3g9IjAgMCA1MCA1MCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiByeD0iOCIgZmlsbD0idXJsKCNwYWludDBfbGluZWFyXzEzMjQ5XzE2MjI4MCkiLz4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzEzMjQ5XzE2MjI4MCkiPgo8cGF0aCBkPSJNMTMgMjUuOTE2N0wzNyAzNy44NjcxTDI1LjAwMjQgMTguOTg5M0wxMyAyNS45MTY3WiIgZmlsbD0iI0Y1RjVGNSIvPgo8cGF0aCBkPSJNMzMuODg2NCAyMi4yMTgyTDI0Ljk5NzYgMTcuMDg2NVY1LjEzNTc0TDEzIDEyLjA2MjhWMjUuOTE2TDI0Ljk5NzYgMTguOTg4OVYzMC45Mzk2TDEzIDM3Ljg2NjhMMjQuOTk3NiA0NC43OTM4TDM2Ljk5NTIgMzcuODY2OFYyNy42MDMzQzM2Ljk5NTIgMjUuMzgxNiAzNS44MDk4IDIzLjMyOTEgMzMuODg2NCAyMi4yMTgyWiIgZmlsbD0iIzFFMUYyMiIvPgo8L2c+CjxkZWZzPgo8bGluZWFyR3JhZGllbnQgaWQ9InBhaW50MF9saW5lYXJfMTMyNDlfMTYyMjgwIiB4MT0iMCIgeTE9IjAiIHgyPSI1Mi4zMjg1IiB5Mj0iNDcuNDMxIiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSI+CjxzdG9wIHN0b3AtY29sb3I9IiNGRkMwMTAiLz4KPHN0b3Agb2Zmc2V0PSIwLjQ4IiBzdG9wLWNvbG9yPSIjRUJBMzEyIi8+CjxzdG9wIG9mZnNldD0iMC43MSIgc3RvcC1jb2xvcj0iI0QzODAxNSIvPgo8c3RvcCBvZmZzZXQ9IjAuOTkiIHN0b3AtY29sb3I9IiNCMjRGMTgiLz4KPC9saW5lYXJHcmFkaWVudD4KPGNsaXBQYXRoIGlkPSJjbGlwMF8xMzI0OV8xNjIyODAiPgo8cmVjdCB3aWR0aD0iMjQiIGhlaWdodD0iNDAiIGZpbGw9IndoaXRlIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMyA1KSIvPgo8L2NsaXBQYXRoPgo8L2RlZnM+Cjwvc3ZnPgo=';
+export const APP_URL = 'https://safe.bako.global';
+export const HOST_URL = 'https://api.bako.global';
+export const SOCKET_URL = 'https://api.bako.global';
+// Window object
+export const HAS_WINDOW = typeof window !== 'undefined';
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+export const WINDOW = HAS_WINDOW ? window : {};
+export const IS_SAFARI = /^((?!chrome|android).)*safari/i.test(WINDOW.navigator?.userAgent ?? '');
+//storage
+export const SESSION_ID = 'sessionId';

package/dist/esm/connectors/bako-safe/index.js

@@ -0,0 +1 @@
+export * from './BakoSafeConnector';

package/dist/esm/connectors/bako-safe/request.js

@@ -0,0 +1,15 @@
+import { urlJoin } from 'fuels';
+export class RequestAPI {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    async get(pathname) {
+        const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) => res.json());
+        return data;
+    }
+    async delete(pathname) {
+        await fetch(urlJoin(this.baseUrl, pathname), {
+            method: 'DELETE',
+        });
+    }
+}

package/dist/esm/connectors/bako-safe/types.js

@@ -0,0 +1,25 @@
+export var BakoSafeConnectorEvents;
+(function (BakoSafeConnectorEvents) {
+    //default
+    BakoSafeConnectorEvents["DEFAULT"] = "message";
+    //client
+    BakoSafeConnectorEvents["CLIENT_DISCONNECTED"] = "[CLIENT_DISCONNECTED]";
+    BakoSafeConnectorEvents["CLIENT_CONNECTED"] = "[CONNECTED]";
+    //transactions
+    BakoSafeConnectorEvents["TX_PENDING"] = "[TX_EVENT_REQUESTED]";
+    BakoSafeConnectorEvents["TX_CONFIRMED"] = "[TX_EVENT_CONFIRMED]";
+    BakoSafeConnectorEvents["TX_TIMEOUT"] = "[TX_EVENT_TIMEOUT]";
+    //switchNetwork
+    BakoSafeConnectorEvents["CHANGE_NETWORK"] = "[CHANGE_NETWORK]";
+    BakoSafeConnectorEvents["NETWORK_CHANGED"] = "[NETWORK_CHANGED]";
+    //auth
+    BakoSafeConnectorEvents["AUTH_CONFIRMED"] = "[AUTH_CONFIRMED]";
+    BakoSafeConnectorEvents["CONNECTION_STATE"] = "[CONNECTION_STATE]";
+    BakoSafeConnectorEvents["DISCONNECT"] = "[DISCONNECT]";
+})(BakoSafeConnectorEvents || (BakoSafeConnectorEvents = {}));
+export var BakoSafeUsernames;
+(function (BakoSafeUsernames) {
+    BakoSafeUsernames["CONNECTOR"] = "[CONNECTOR]";
+    BakoSafeUsernames["CLIENT"] = "[UI]";
+    BakoSafeUsernames["SERVER"] = "[API]";
+})(BakoSafeUsernames || (BakoSafeUsernames = {}));