@leofcoin/chain 1.7.65 → 1.7.67

package/exports/browser/client-Depp28gl-DItJEEYa.js

@@ -0,0 +1,638 @@
+import { L as LittlePubSub } from './node-browser-DewO13hB.js';
+import './index-CM4QYC3g.js';
+
+class Api {
+    _pubsub;
+    constructor(_pubsub) {
+        this._pubsub = _pubsub;
+    }
+    subscribe(topic, cb) {
+        this._pubsub.subscribe(topic, cb);
+    }
+    unsubscribe(topic, cb) {
+        this._pubsub.unsubscribe(topic, cb);
+    }
+    publish(topic, value) {
+        this._pubsub.publish(topic, value);
+    }
+    subscribers() {
+        this._pubsub.subscribers;
+    }
+    connectionState(state) {
+        switch (state) {
+            case 0:
+                return 'connecting';
+            case 1:
+                return 'open';
+            case 2:
+                return 'closing';
+            case 3:
+                return 'closed';
+        }
+    }
+    /**
+     * @param {string} type
+     * @param {string} name
+     * @param {object} params
+     */
+    request(client, request) {
+        return new Promise((resolve, reject) => {
+            const state = this.connectionState(client.readyState);
+            if (state !== 'open')
+                return reject(`coudn't send request to ${client.id}, no open connection found.`);
+            request.id = Math.random().toString(36).slice(-12);
+            const handler = result => {
+                if (result && result.error)
+                    return reject(result.error);
+                resolve({ result, id: request.id, handler });
+                this.unsubscribe(request.id, handler);
+            };
+            this.subscribe(request.id, handler);
+            this.send(client, request);
+        });
+    }
+    async send(client, request) {
+        return client.send(JSON.stringify(request));
+    }
+    pubsub(client) {
+        return {
+            publish: (topic = 'pubsub', value) => {
+                return this.send(client, { url: 'pubsub', params: { topic, value } });
+            },
+            subscribe: (topic = 'pubsub', cb) => {
+                this.subscribe(topic, cb);
+                return this.send(client, { url: 'pubsub', params: { topic, subscribe: true } });
+            },
+            unsubscribe: (topic = 'pubsub', cb) => {
+                this.unsubscribe(topic, cb);
+                return this.send(client, { url: 'pubsub', params: { topic, unsubscribe: true } });
+            },
+            subscribers: this._pubsub.subscribers
+        };
+    }
+    server(client) {
+        return {
+            uptime: async () => {
+                try {
+                    const { result, id, handler } = await this.request(client, { url: 'uptime' });
+                    this.unsubscribe(id, handler);
+                    return result;
+                }
+                catch (e) {
+                    throw e;
+                }
+            },
+            ping: async () => {
+                try {
+                    const now = new Date().getTime();
+                    const { result, id, handler } = await this.request(client, { url: 'ping' });
+                    this.unsubscribe(id, handler);
+                    return (Number(result) - now);
+                }
+                catch (e) {
+                    throw e;
+                }
+            }
+        };
+    }
+    peernet(client) {
+        return {
+            join: async (params) => {
+                try {
+                    params.join = true;
+                    const requested = { url: 'peernet', params };
+                    const { result, id, handler } = await this.request(client, requested);
+                    this.unsubscribe(id, handler);
+                    return result;
+                }
+                catch (e) {
+                    throw e;
+                }
+            },
+            leave: async (params) => {
+                try {
+                    params.join = false;
+                    const requested = { url: 'peernet', params };
+                    const { result, id, handler } = await this.request(client, requested);
+                    this.unsubscribe(id, handler);
+                    return result;
+                }
+                catch (e) {
+                    throw e;
+                }
+            }
+        };
+    }
+}
+
+class ClientConnection {
+    client;
+    api;
+    #startTime;
+    constructor(client, api) {
+        this.#startTime = new Date().getTime();
+        this.client = client;
+        this.api = api;
+    }
+    request = async (req) => {
+        const { result, id, handler } = await this.api.request(this.client, req);
+        globalThis.pubsub.unsubscribe(id, handler);
+        return result;
+    };
+    send = (req) => this.api.send(this.client, req);
+    get subscribe() {
+        return this.api.subscribe;
+    }
+    get unsubscribe() {
+        return this.api.unsubscribe;
+    }
+    get subscribers() {
+        return this.api.subscribers;
+    }
+    get publish() {
+        return this.api.publish;
+    }
+    get pubsub() {
+        return this.api.pubsub(this.client);
+    }
+    uptime = () => {
+        const now = new Date().getTime();
+        return (now - this.#startTime);
+    };
+    get peernet() {
+        return this.api.peernet(this.client);
+    }
+    get server() {
+        return this.api.server(this.client);
+    }
+    connectionState = () => this.api.connectionState(this.client.readyState);
+    close = exit => {
+        // client.onclose = message => {
+        //   if (exit) process.exit()
+        // }
+        this.client.close();
+    };
+}
+
+if (!globalThis.PubSub)
+    globalThis.PubSub = LittlePubSub;
+if (!globalThis.pubsub)
+    globalThis.pubsub = new LittlePubSub(false);
+class SocketRequestClient {
+    api;
+    clientConnection;
+    #tries = 0;
+    #retry = false;
+    #timeout = 10000;
+    #times = 10;
+    #options;
+    #protocol;
+    #url;
+    #experimentalWebsocket = false;
+    constructor(url, protocol, options) {
+        let { retry, timeout, times, experimentalWebsocket } = options || {};
+        if (retry !== undefined)
+            this.#retry = retry;
+        if (timeout !== undefined)
+            this.#timeout = timeout;
+        if (times !== undefined)
+            this.#times = times;
+        if (experimentalWebsocket !== undefined)
+            this.#experimentalWebsocket;
+        this.#url = url;
+        this.#protocol = protocol;
+        this.#options = options;
+        this.api = new Api(globalThis.pubsub);
+    }
+    init() {
+        return new Promise(async (resolve, reject) => {
+            const init = async () => {
+                // @ts-ignore
+                if (!globalThis.WebSocket && !this.#experimentalWebsocket)
+                    globalThis.WebSocket = (await import('./browser-DQJ6xf_F-D0onvbt2.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                const client = new WebSocket(this.#url, this.#protocol);
+                if (this.#experimentalWebsocket) {
+                    client.addEventListener('error', this.onerror);
+                    client.addEventListener('message', this.onmessage);
+                    client.addEventListener('open', () => {
+                        this.#tries = 0;
+                        resolve(new ClientConnection(client, this.api));
+                    });
+                    client.addEventListener('close', (client.onclose = (message) => {
+                        this.#tries++;
+                        if (!this.#retry)
+                            return reject(this.#options);
+                        if (this.#tries > this.#times) {
+                            console.log(`${this.#options.protocol} Client Closed`);
+                            console.error(`could not connect to - ${this.#url}/`);
+                            return resolve(new ClientConnection(client, this.api));
+                        }
+                        if (message.code === 1006) {
+                            console.log(`Retrying in ${this.#timeout} ms`);
+                            setTimeout(() => {
+                                return init();
+                            }, this.#timeout);
+                        }
+                    }));
+                }
+                else {
+                    client.onmessage = this.onmessage;
+                    client.onerror = this.onerror;
+                    client.onopen = () => {
+                        this.#tries = 0;
+                        resolve(new ClientConnection(client, this.api));
+                    };
+                    client.onclose = (message) => {
+                        this.#tries++;
+                        if (!this.#retry)
+                            return reject(this.#options);
+                        if (this.#tries > this.#times) {
+                            console.log(`${this.#options.protocol} Client Closed`);
+                            console.error(`could not connect to - ${this.#url}/`);
+                            return resolve(new ClientConnection(client, this.api));
+                        }
+                        if (message.code === 1006) {
+                            console.log(`Retrying in ${this.#timeout} ms`);
+                            setTimeout(() => {
+                                return init();
+                            }, this.#timeout);
+                        }
+                    };
+                }
+            };
+            return init();
+        });
+    }
+    onerror = (error) => {
+        if (globalThis.pubsub.subscribers['error']) {
+            globalThis.pubsub.publish('error', error);
+        }
+        else {
+            console.error(error);
+        }
+    };
+    onmessage(message) {
+        if (!message.data) {
+            console.warn(`message ignored because it contained no data`);
+            return;
+        }
+        const { value, url, status, id } = JSON.parse(message.data.toString());
+        const publisher = id ? id : url;
+        if (status === 200) {
+            globalThis.pubsub.publish(publisher, value);
+        }
+        else {
+            globalThis.pubsub.publish(publisher, { error: value });
+        }
+    }
+}
+
+const MAX_MESSAGE_SIZE = 16000;
+const defaultOptions = {
+    networkVersion: 'peach',
+    version: 'v1',
+    stars: ['wss://star.leofcoin.org'],
+    connectEvent: 'peer:connected'
+};
+
+const iceServers = [
+    {
+        urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
+    },
+    {
+        urls: 'stun:openrelay.metered.ca:80'
+    },
+    {
+        urls: 'turn:openrelay.metered.ca:443',
+        username: 'openrelayproject',
+        credential: 'openrelayproject'
+    },
+    {
+        urls: 'turn:openrelay.metered.ca:443?transport=tcp',
+        username: 'openrelayproject',
+        credential: 'openrelayproject'
+    }
+];
+const SimplePeer = (await import('./index-DqPlTtAJ-Bczd-x6k.js').then(function (n) { return n.i; })).default;
+class Peer extends SimplePeer {
+    peerId;
+    channelName;
+    version;
+    bw = { up: 0, down: 0 };
+    get connected() {
+        return super.connected;
+    }
+    constructor(options) {
+        const { from, to, initiator, trickle, config, version } = options;
+        const channelName = initiator ? `${from}:${to}` : `${to}:${from}`;
+        super({
+            channelName,
+            initiator,
+            trickle: trickle || true,
+            config: { iceServers, ...config },
+            wrtc: globalThis.wrtc
+        });
+        this.version = String(version);
+        this.peerId = to;
+        this.channelName = channelName;
+    }
+    async #chunkit(data, id) {
+        this.bw.up = data.length;
+        const size = data.length;
+        // no needles chunking, keep it simple, if data is smaller then max size just send it
+        if (data.length <= MAX_MESSAGE_SIZE) {
+            return super.send(JSON.stringify({ chunk: data, id, size: data.length }));
+        }
+        async function* chunks(data) {
+            while (data.length !== 0) {
+                const amountToSlice = data.length >= MAX_MESSAGE_SIZE ? MAX_MESSAGE_SIZE : data.length;
+                const subArray = data.subarray(0, amountToSlice);
+                data = data.subarray(amountToSlice, data.length);
+                yield subArray;
+                // super.send(JSON.stringify({ chunk: subArray, id, size }))
+            }
+        }
+        // while (data.length !== 0) {
+        //   const amountToSlice =
+        //     data.length >= MAX_MESSAGE_SIZE ? MAX_MESSAGE_SIZE : data.length
+        //   const subArray = data.subarray(0, amountToSlice)
+        //   data = data.subarray(amountToSlice, data.length)
+        //   super.send(JSON.stringify({ chunk: subArray, id, size }))
+        // }
+        for await (const chunk of chunks(data)) {
+            super.send(JSON.stringify({ chunk, id, size }));
+        }
+    }
+    /**
+     * send to peer
+     * @param data ArrayLike
+     * @param id custom id to listen to
+     */
+    send(data, id = crypto.randomUUID()) {
+        // send chuncks till ndata support for SCTP is added
+        // wraps data
+        this.#chunkit(data, id);
+    }
+    /**
+     * send to peer & wait for response
+     * @param data ArrayLike
+     * @param id custom id to listen to
+     */
+    request(data, id = crypto.randomUUID()) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(`request for ${id} timed out`), 30_000);
+            const onrequest = ({ data }) => {
+                clearTimeout(timeout);
+                resolve(data);
+                globalThis.pubsub.unsubscribe(id, onrequest);
+            };
+            globalThis.pubsub.subscribe(id, onrequest);
+            this.send(data, id);
+        });
+    }
+}
+
+const debug = globalThis.createDebugger('@netpeer/swarm/client');
+class Client {
+    #peerId;
+    #connections = {};
+    #stars = {};
+    #connectEvent = 'peer:connected';
+    id;
+    networkVersion;
+    starsConfig;
+    socketClient;
+    messageSize = 262144;
+    version;
+    #messagesToHandle = {};
+    get peerId() {
+        return this.#peerId;
+    }
+    get connections() {
+        return { ...this.#connections };
+    }
+    get peers() {
+        return Object.entries(this.#connections);
+    }
+    getPeer(peerId) {
+        return this.#connections[peerId];
+    }
+    /**
+     *
+     * @param options {object}
+     * @param options.peerId {string}
+     * @param options.networkVersion {string}
+     * @param options.version {string}
+     * @param options.stars {string[]}
+     * @param options.connectEvent {string} defaults to peer:connected, can be renamed to handle different protocols, like peer:discovered (setup peer props before fireing the connect event)
+     */
+    constructor(options) {
+        const { peerId, networkVersion, version, connectEvent, stars } = {
+            ...defaultOptions,
+            ...options
+        };
+        this.#peerId = peerId;
+        this.networkVersion = networkVersion;
+        this.version = version;
+        this.#connectEvent = connectEvent;
+        this.starsConfig = stars;
+        this._init();
+    }
+    async _init() {
+        // reconnectJob()
+        if (!globalThis.RTCPeerConnection)
+            globalThis.wrtc = (await import('./browser-pguCHlVu-pguCHlVu.js').then(function (n) { return n.b; })).default;
+        for (const star of this.starsConfig) {
+            try {
+                const client = new SocketRequestClient(star, this.networkVersion);
+                this.#stars[star] = await client.init();
+                this.setupStarListeners(this.#stars[star]);
+                this.#stars[star].send({
+                    url: 'join',
+                    params: { version: this.version, peerId: this.peerId }
+                });
+            }
+            catch (e) {
+                if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 &&
+                    !this.socketClient)
+                    throw new Error(`No star available to connect`);
+            }
+        }
+        if (globalThis.process?.versions?.node) {
+            process.on('SIGINT', async () => {
+                process.stdin.resume();
+                await this.close();
+                process.exit();
+            });
+        }
+        else {
+            globalThis.addEventListener('beforeunload', async () => this.close());
+        }
+    }
+    setupStarListeners(star) {
+        star.pubsub.subscribe('peer:joined', (id) => this.#peerJoined(id, star));
+        star.pubsub.subscribe('peer:left', (id) => this.#peerLeft(id, star));
+        star.pubsub.subscribe('star:joined', this.#starJoined);
+        star.pubsub.subscribe('star:left', this.#starLeft);
+        star.pubsub.subscribe('signal', (message) => this.#inComingSignal(message, star));
+    }
+    #starJoined = (id) => {
+        if (this.#stars[id]) {
+            this.#stars[id].close(0);
+            delete this.#stars[id];
+        }
+        console.log(`star ${id} joined`);
+    };
+    #starLeft = async (id) => {
+        if (this.#stars[id]) {
+            this.#stars[id].close(0);
+            delete this.#stars[id];
+        }
+        if (Object.keys(this.#stars).length === 0) {
+            for (const star of this.starsConfig) {
+                try {
+                    const socketClient = await new SocketRequestClient(star, this.networkVersion).init();
+                    if (!socketClient?.client?.OPEN)
+                        return;
+                    this.#stars[star] = socketClient;
+                    this.#stars[star].send({
+                        url: 'join',
+                        params: { peerId: this.peerId, version: this.version }
+                    });
+                    this.setupStarListeners(socketClient);
+                }
+                catch (e) {
+                    if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1)
+                        throw new Error(`No star available to connect`);
+                }
+            }
+        }
+        debug(`star ${id} left`);
+    };
+    #peerLeft = (peer, star) => {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            this.#connections[id].destroy();
+            delete this.#connections[id];
+        }
+        debug(`peer ${id} left`);
+    };
+    #createRTCPeerConnection = (peerId, star, version, initiator = false) => {
+        const peer = new Peer({
+            initiator: initiator,
+            from: this.peerId,
+            to: peerId,
+            version
+        });
+        peer.on('signal', (signal) => this.#peerSignal(peer, signal, star, this.version));
+        peer.on('connect', () => this.#peerConnect(peer));
+        peer.on('close', () => this.#peerClose(peer));
+        peer.on('data', (data) => this.#peerData(peer, data));
+        peer.on('error', (error) => this.#peerError(peer, error));
+        this.#connections[peerId] = peer;
+    };
+    #peerJoined = async ({ peerId, version }, star) => {
+        // check if peer rejoined before the previous connection closed
+        if (this.#connections[peerId]) {
+            this.#connections[peerId].destroy();
+            delete this.#connections[peerId];
+        }
+        // RTCPeerConnection
+        this.#createRTCPeerConnection(peerId, star, version, true);
+        debug(`peer ${peerId} joined`);
+    };
+    #inComingSignal = async ({ from, signal, channelName, version }, star) => {
+        if (version !== this.version) {
+            console.warn(`${from} joined using the wrong version.\nexpected: ${this.version} but got:${version}`);
+            return;
+        }
+        let peer = this.#connections[from];
+        if (!peer) {
+            this.#createRTCPeerConnection(from, star, version);
+            peer = this.#connections[from];
+        }
+        if (String(peer.channelName) !== String(channelName))
+            console.warn(`channelNames don't match: got ${peer.channelName}, expected: ${channelName}`);
+        peer.signal(signal);
+    };
+    #peerSignal = (peer, signal, star, version) => {
+        let client = this.#stars[star];
+        if (!client)
+            client = this.#stars[Object.keys(this.#stars)[0]];
+        client.send({
+            url: 'signal',
+            params: {
+                from: this.peerId,
+                to: peer.peerId,
+                channelName: peer.channelName,
+                version,
+                signal
+            }
+        });
+    };
+    #peerClose = (peer) => {
+        if (this.#connections[peer.peerId]) {
+            peer.destroy();
+            delete this.#connections[peer.peerId];
+        }
+        debug(`closed ${peer.peerId}'s connection`);
+    };
+    #peerConnect = (peer) => {
+        debug(`${peer.peerId} connected`);
+        globalThis.pubsub.publishVerbose(this.#connectEvent, peer.peerId);
+    };
+    #noticeMessage = (message, id, from, peer) => {
+        if (globalThis.pubsub.subscribers[id]) {
+            globalThis.pubsub.publish(id, {
+                data: new Uint8Array(Object.values(message)),
+                id,
+                from,
+                peer
+            });
+        }
+        else {
+            globalThis.pubsub.publish('peer:data', {
+                data: new Uint8Array(Object.values(message)),
+                id,
+                from,
+                peer
+            });
+        }
+    };
+    #peerData = (peer, data) => {
+        const { id, size, chunk } = JSON.parse(new TextDecoder().decode(data));
+        peer.bw.down += size;
+        if (size <= MAX_MESSAGE_SIZE) {
+            this.#noticeMessage(chunk, id, peer.peerId, peer);
+        }
+        else {
+            if (!this.#messagesToHandle[id])
+                this.#messagesToHandle[id] = [];
+            this.#messagesToHandle[id] = [
+                ...this.#messagesToHandle[id],
+                ...Object.values(chunk)
+            ];
+            if (this.#messagesToHandle[id].length === Number(size)) {
+                this.#noticeMessage(this.#messagesToHandle[id], id, peer.peerId, peer);
+                delete this.#messagesToHandle[id];
+            }
+        }
+    };
+    #peerError = (peer, error) => {
+        console.warn(`Connection error: ${error.message}`);
+        peer.destroy();
+    };
+    async close() {
+        for (const star in this.#stars) {
+            if (this.#stars[star].connectionState() === 'open')
+                await this.#stars[star].send({ url: 'leave', params: this.peerId });
+        }
+        const promises = [
+            Object.values(this.#connections).map((connection) => connection.destroy()),
+            Object.values(this.#stars).map((connection) => connection.close(0))
+        ];
+        return Promise.allSettled(promises);
+    }
+}
+
+export { Client as default };

package/exports/browser/index-BeqbCwUk-DfNb2uRP.js

@@ -0,0 +1,37 @@
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-DewO13hB.js';
+import './index-CM4QYC3g.js';
+
+/**
+ * @params {String} network
+ * @return {object} { identity, accounts, config }
+ */
+var index = async (password, network) => {
+    if (!password)
+        throw new Error('wallets need to be password protected.');
+    let wallet = new MultiWallet(network);
+    /**
+     * @type {string}
+     */
+    let mnemonic = await wallet.generate(password);
+    wallet = new MultiWallet(network);
+    await wallet.recover(mnemonic, password, network);
+    mnemonic = new Uint8Array(await encrypt(password, mnemonic));
+    const multiWIF = new Uint8Array(await encrypt(password, await wallet.multiWIF));
+    /**
+     * @type {object}
+     */
+    const external = await wallet.account(1).external(1);
+    const externalAddress = await external.address;
+    const internal = await wallet.account(1).internal(1);
+    const internalAddress = await internal.address;
+    return {
+        identity: {
+            mnemonic: base58$1.encode(mnemonic),
+            multiWIF: base58$1.encode(multiWIF),
+            walletId: await external.id
+        },
+        accounts: [['main account', externalAddress, internalAddress]]
+    };
+};
+
+export { index as default };