@leofcoin/peernet 1.1.46 → 1.1.47

package/exports/browser/peernet.d.ts

@@ -0,0 +1,233 @@
+/// <reference types="node" />
+import '@vandeurenglenn/debug';
+import PubSub from '@vandeurenglenn/little-pubsub';
+import DHT from './dht/dht.js';
+import MessageHandler from './handlers/message.js';
+import { LeofcoinStorage as LeofcoinStorageClass } from '@leofcoin/storage';
+import Identity from './identity.js';
+declare global {
+    var globalSub: PubSub;
+    var pubsub: PubSub;
+    var peernet: Peernet;
+    var LeofcoinStorage: typeof LeofcoinStorageClass;
+    var LeofcoinStorageClient: any;
+}
+/**
+ * @access public
+ * @example
+ * const peernet = new Peernet();
+ */
+export default class Peernet {
+    #private;
+    identity: Identity;
+    stores: string[];
+    /**
+     * @type {Object}
+     * @property {Object} peer Instance of Peer
+     */
+    dht: DHT;
+    /** @leofcoin/peernet-swarm/client */
+    client: {
+        connections: [];
+        id: string;
+        removePeer: (peer: string) => {};
+        close: () => {};
+    };
+    network: string;
+    stars: string[];
+    networkVersion: string;
+    bw: {
+        up: number;
+        down: number;
+    };
+    hasDaemon: boolean;
+    autoStart: boolean;
+    requestProtos: {};
+    _messageHandler: MessageHandler;
+    protos: {};
+    /**
+     * @access public
+     * @param {Object} options
+     * @param {String} options.network - desired network
+     * @param {String} options.stars - star list for selected network (these should match, don't mix networks)
+     * @param {String} options.root - path to root directory
+     * @param {String} options.storePrefix - prefix for datatores (lfc)
+     *
+     * @return {Promise} instance of Peernet
+     *
+     * @example
+     * const peernet = new Peernet({network: 'leofcoin', root: '.leofcoin'});
+     */
+    constructor(options: any, password: any);
+    get id(): string;
+    get accounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]>;
+    get defaultStores(): string[];
+    addProto(name: any, proto: any): void;
+    addCodec(codec: any): void;
+    addStore(name: any, prefix: any, root: any, isPrivate?: boolean): Promise<void>;
+    /**
+     * @see MessageHandler
+     */
+    prepareMessage(data: any): Promise<any>;
+    /**
+     * @access public
+     *
+     * @return {Array} peerId
+     */
+    get peers(): [string, unknown][];
+    get connections(): unknown[];
+    get peerEntries(): unknown[];
+    /**
+     * @return {String} id - peerId
+     */
+    getConnection(id: any): never;
+    /**
+     * @private
+     *
+     * @param {Object} options
+     * @param {String} options.root - path to root directory
+     *
+     * @return {Promise} instance of Peernet
+     */
+    _init(options: any, password: any): Peernet;
+    start(): Promise<void>;
+    addRequestHandler(name: any, method: any): void;
+    sendMessage(peer: any, id: any, data: any): Promise<void>;
+    handleDHT(peer: any, id: any, proto: any): Promise<void>;
+    handleData(peer: any, id: any, proto: any): Promise<void>;
+    handleRequest(peer: any, id: any, proto: any): Promise<void>;
+    /**
+     * @private
+     *
+     * @param {Buffer} message - peernet message
+     * @param {PeernetPeer} peer - peernet peer
+     */
+    _protoHandler(message: any, peer: any, from: any): Promise<void>;
+    /**
+     * performs a walk and resolves first encounter
+     *
+     * @param {String} hash
+     */
+    walk(hash: any): Promise<any[]>;
+    /**
+     * Override DHT behavior, try's finding the content three times
+     *
+     * @param {String} hash
+     */
+    providersFor(hash: string, store?: undefined): Promise<Set<string>>;
+    get block(): {
+        get: (hash: any) => Promise<any>;
+        put: (hash: any, data: any) => Promise<any>;
+        has: (hash: any) => Promise<any>;
+    };
+    get transaction(): {
+        get: (hash: any) => Promise<any>;
+        put: (hash: any, data: any) => Promise<any>;
+        has: (hash: any) => Promise<any>;
+    };
+    requestData(hash: any, store: any): any;
+    get message(): {
+        /**
+         * Get content for given message hash
+         *
+         * @param {String} hash
+         */
+        get: (hash: any) => Promise<any>;
+        /**
+         * put message content
+         *
+         * @param {String} hash
+         * @param {Buffer} message
+         */
+        put: (hash: any, message: any) => Promise<any>;
+        /**
+         * @param {String} hash
+         * @return {Boolean}
+         */
+        has: (hash: any) => Promise<any>;
+    };
+    get data(): {
+        /**
+         * Get content for given data hash
+         *
+         * @param {String} hash
+         */
+        get: (hash: any) => Promise<any>;
+        /**
+         * put data content
+         *
+         * @param {String} hash
+         * @param {Buffer} data
+         */
+        put: (hash: any, data: any) => Promise<any>;
+        /**
+         * @param {String} hash
+         * @return {Boolean}
+         */
+        has: (hash: any) => Promise<any>;
+    };
+    get folder(): {
+        /**
+         * Get content for given data hash
+         *
+         * @param {String} hash
+         */
+        get: (hash: any) => Promise<any>;
+        /**
+         * put data content
+         *
+         * @param {String} hash
+         * @param {Buffer} data
+         */
+        put: (hash: any, data: any) => Promise<any>;
+        /**
+         * @param {String} hash
+         * @return {Boolean}
+         */
+        has: (hash: any) => Promise<any>;
+    };
+    addFolder(files: any): Promise<any>;
+    ls(hash: any, options: any): Promise<any[]>;
+    cat(hash: any, options: any): Promise<any>;
+    /**
+     * goes trough given stores and tries to find data for given hash
+     * @param {Array} stores
+     * @param {string} hash
+     */
+    whichStore(stores: any, hash: any): any;
+    /**
+     * Get content for given hash
+     *
+     * @param {String} hash - the hash of the wanted data
+     * @param {String} store - storeName to access
+     */
+    get(hash: any, store: any): Promise<any>;
+    /**
+     * put content
+     *
+     * @param {String} hash
+     * @param {Buffer} data
+     * @param {String} store - storeName to access
+     */
+    put(hash: any, data: any, store?: string): Promise<any>;
+    /**
+     * @param {String} hash
+     * @return {Boolean}
+     */
+    has(hash: any): Promise<boolean>;
+    /**
+     *
+     * @param {String} topic
+     * @param {String|Object|Array|Boolean|Buffer} data
+     */
+    publish(topic: any, data: any): Promise<void>;
+    createHash(data: any, name: any): any;
+    /**
+     *
+     * @param {String} topic
+     * @param {Method} cb
+     */
+    subscribe(topic: any, callback: any): Promise<void>;
+    removePeer(peer: any): Promise<any>;
+    get Buffer(): BufferConstructor;
+}

package/exports/browser/peernet.js

@@ -1,2 +1 @@
-export { P as default } from './peernet-4dde5a19.js';
-import './value-157ab062.js';
+export { P as default } from './peernet-20a06ecc.js';

package/exports/messages-dc960cb3.js

@@ -0,0 +1,224 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+
+var proto$b = {
+  data: new Uint8Array(),
+  signature: new Uint8Array(),
+  'from?': String(),
+  'to?': String(),
+  'id?': String()
+};
+
+class PeernetMessage extends FormatInterface {
+
+  get messageName() {
+    return 'PeernetMessage'
+  }
+
+  constructor(buffer) {
+    const name = 'peernet-message';
+    super(buffer, proto$b, {name});
+  }
+}
+
+var proto$a = {
+  hash: String(),
+  'store?': String()
+};
+
+/**
+ * @example `
+   new DHTMessage(hash, store)
+   // store = optional if not set, peernet checks every store
+   let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
+   message = new DHTMessage('hashmvbs124xcfd...', 'block')
+ `
+ */
+class DHTMessage extends FormatInterface {
+
+  get messageName() {
+    return 'PeernetDHTMessage'
+  }
+
+  constructor(data) {
+    const name = 'peernet-dht';
+    super(data, proto$a, {name});
+  }
+}
+
+var proto$9 = {
+  hash: String(),
+  has: Boolean()
+};
+
+class DHTMessageResponse extends FormatInterface {
+
+  get messageName() {
+    return 'PeernetDHTMessageResponse'
+  }
+
+  constructor(data) {
+    const name = 'peernet-dht-response';
+    super(data, proto$9, {name});
+  }
+}
+
+var proto$8 = {
+  hash: String(),
+  'store?': String()
+};
+
+/**
+ * @extends {CodecFormat}
+ */
+class DataMessage extends FormatInterface {
+
+  get messageName() {
+    return 'PeernetDataMessage'
+  }
+  /**
+   * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
+   */
+  constructor(data) {
+    super(data, proto$8, {name: 'peernet-data'});
+  }
+}
+
+var proto$7 = {
+  data: new Uint8Array(),
+  topic: new Uint8Array()
+};
+
+class PsMessage extends FormatInterface {
+  get messageName() {
+    return 'PsMessage'
+  }
+
+  constructor(buffer) {
+    const name = 'peernet-ps';
+    super(buffer, proto$7, {name});
+  }
+}
+
+var proto$6 = {
+  id: String()
+};
+
+class PeerMessage extends FormatInterface {
+  get messageName() {
+    return 'PeernetPeerMessage'
+  }
+
+  constructor(data) {
+    const name = 'peernet-peer';
+    super(data, proto$6, {name});
+  }
+}
+
+var proto$5 = {
+  request: String(),
+  'requested?': new Uint8Array()
+};
+
+class RequestMessage extends FormatInterface {
+
+  get messageName() {
+    return 'PeernetRequestMessage'
+  }
+
+  constructor(data) {
+    const name = 'peernet-request';
+    super(data, proto$5, {name});
+  }
+}
+
+var proto$4 = {
+  response: {}
+};
+
+class ResponseMessage extends FormatInterface {
+
+  get messageName() {
+    return 'PeernetResponseMessage'
+  }
+
+  constructor(data) {
+    const name = 'peernet-response';
+    super(data, proto$4, {name});
+  }
+}
+
+var proto$3 = {
+  id: String()
+};
+
+class PeerMessageResponse extends FormatInterface {
+
+  get messageName() {
+    return 'PeernetPeerMessageResponse'
+  }
+
+  constructor(data) {
+    const name = 'peernet-peer-response';
+    super(data, proto$3, {name});
+  }
+}
+
+var proto$2 = {
+  hash: String(),
+  data: new Uint8Array(),
+};
+
+class DataMessageResponse extends FormatInterface {
+
+  get messageName() {
+    return 'PeernetDataMessageResponse'
+  }
+
+  constructor(data) {
+    const name = 'peernet-data-response';
+    super(data, proto$2, {name});
+  }
+}
+
+var proto$1 = {
+  value: String(),
+  author: String(),
+  timestamp: Number(),
+  files: [String()],
+};
+
+class ChatMessage extends FormatInterface {
+
+  get messageName() {
+    return 'ChatMessage'
+  }
+
+  constructor(buffer) {
+    const name = 'chat-message';
+    super(buffer, proto$1, {name});
+  }
+}
+
+var proto = {
+  path: String(),
+  'content?': '',
+  'links?': []
+};
+
+/**
+ * @extends {CodecFormat}
+ */
+class PeernetFile extends FormatInterface {
+
+  get messageName() {
+    return 'PeernetFile'
+  }
+  /**
+   * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
+   */
+  constructor(data) {
+    super(data, proto, {name: 'peernet-file'});
+  }
+}
+
+export { ChatMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PeerMessage, PeerMessageResponse, PeernetFile, PeernetMessage, PsMessage, RequestMessage, ResponseMessage };