@leofcoin/codec-format-interface 1.5.3 → 1.6.1

package/dist/index.js

@@ -0,0 +1,549 @@
+import bs32 from '@vandeurenglenn/base32';
+import base58 from '@vandeurenglenn/base58';
+import proto from '@vandeurenglenn/proto-array';
+import { fromBase58, fromHex, toHex, toBase32, toBase58 } from '@vandeurenglenn/typed-array-utils';
+import { createKeccak } from 'hash-wasm';
+import varint from 'varint';
+
+/**
+ * @param {string}
+ */
+var isHex = (function (string) { return /^[A-F0-9]+$/i.test(string); });
+
+let BasicInterface$1 = class BasicInterface {
+    encoded;
+    decoded;
+    keys;
+    name;
+    // get Codec(): Codec {}
+    protoEncode(data) {
+        // check schema
+        return proto.encode(this.proto, data);
+    }
+    protoDecode(data) {
+        // check schema
+        return proto.decode(this.proto, data);
+    }
+    isHex(string) {
+        return isHex(string);
+    }
+    isBase32(string) {
+        return bs32.isBase32(string);
+    }
+    isBase58(string) {
+        return base58.isBase58(string);
+    }
+    fromBs32(encoded) {
+        this.encoded = bs32.decode(encoded);
+        return this.decode();
+    }
+    fromBs58(encoded) {
+        this.encoded = fromBase58(encoded);
+        return this.decode();
+    }
+    async toArray() {
+        const array = [];
+        for await (const value of this.encoded.values()) {
+            array.push(value);
+        }
+        return array;
+    }
+    fromString(string) {
+        const array = string.split(',');
+        const arrayLike = array.map(string => Number(string));
+        this.encoded = Uint8Array.from(arrayLike);
+        return this.decode();
+    }
+    fromHex(string) {
+        this.encoded = fromHex(string);
+        return this.decode();
+    }
+    fromArray(array) {
+        this.encoded = Uint8Array.from([...array]);
+        return this.decode();
+    }
+    fromEncoded(encoded) {
+        this.encoded = encoded;
+        return this.decode();
+    }
+    toString() {
+        if (!this.encoded)
+            this.encode();
+        return this.encoded.toString();
+    }
+    toHex() {
+        if (!this.encoded)
+            this.encode();
+        return toHex(this.encoded);
+    }
+    /**
+     * @return {String} encoded
+     */
+    toBs32() {
+        if (!this.encoded)
+            this.encode();
+        return toBase32(this.encoded);
+    }
+    /**
+     * @return {String} encoded
+     */
+    toBs58() {
+        if (!this.encoded)
+            this.encode();
+        return toBase58(this.encoded);
+    }
+    /**
+     * @param {Object} data
+     */
+    create(data) {
+        const decoded = {};
+        if (this.keys?.length > 0) {
+            for (const key of this.keys) {
+                Object.defineProperties(decoded, {
+                    [key]: {
+                        enumerable: true,
+                        configurable: true,
+                        set: (value) => data[key],
+                        get: () => data[key]
+                    }
+                });
+            }
+            this.decoded = decoded;
+            return this.encode();
+        }
+    }
+};
+
+var codecs = {
+    // just a hash
+    'disco-hash': {
+        codec: parseInt('30', 16),
+        hashAlg: 'dbl-keccak-256', // ,
+        // testnet: 'olivia'
+    },
+    'peernet-peer-response': {
+        codec: parseInt('707072', 16),
+        hashAlg: 'keccak-256',
+    },
+    'peernet-peer': {
+        codec: parseInt('7070', 16),
+        hashAlg: 'keccak-256',
+    },
+    'peernet-dht': {
+        codec: parseInt('706468', 16),
+        hashAlg: 'keccak-256',
+    },
+    'peernet-dht-response': {
+        codec: parseInt('706472', 16),
+        hashAlg: 'keccak-256',
+    },
+    // data
+    'peernet-data': {
+        codec: parseInt('706461', 16),
+        hashAlg: 'keccak-256',
+    },
+    'peernet-data-response': {
+        codec: parseInt('70646172', 16),
+        hashAlg: 'keccak-256',
+    },
+    // message
+    'peernet-message': {
+        codec: parseInt('706d65', 16),
+        hashAlg: 'keccak-256',
+    },
+    // pubsub
+    'peernet-ps': {
+        codec: parseInt('707073', 16),
+        hashAlg: 'keccak-256',
+    },
+    'peernet-response': {
+        codec: parseInt('7072', 16),
+        hashAlg: 'keccak-256',
+    },
+    'peernet-request': {
+        codec: parseInt('707271', 16),
+        hashAlg: 'keccak-256',
+    },
+    // normal block
+    'leofcoin-block': {
+        codec: parseInt('6c62', 16),
+        hashAlg: 'dbl-keccak-512', // ,
+        // testnet: 'olivia'
+    },
+    'leofcoin-tx': {
+        codec: parseInt('6c74', 16),
+        hashAlg: 'dbl-keccak-512', // ,
+        // testnet: 'olivia'
+    },
+    // itx
+    'leofcoin-itx': {
+        codec: parseInt('6c69', 16),
+        hashAlg: 'keccak-512', // ,
+        // testnet: 'olivia'
+    },
+    // peer reputation
+    'leofcoin-pr': {
+        codec: parseInt('6c70', 16),
+        hashAlg: 'keccak-256', // ,
+        // testnet: 'olivia'
+    },
+    // chat message
+    'chat-message': {
+        codec: parseInt('70636d', 16),
+        hashAlg: 'dbl-keccak-256',
+    },
+    'peernet-file': {
+        codec: parseInt('7066', 16),
+        hashAlg: 'keccak-256',
+    },
+    'peernet-file-response': {
+        codec: parseInt('706672', 16),
+        hashAlg: 'keccak-256',
+    }
+};
+
+var codecs$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: codecs
+});
+
+let Codec$1 = class Codec extends BasicInterface$1 {
+    get codecs() {
+        return { ...globalThis.peernet.codecs, ...codecs };
+    }
+    constructor(buffer) {
+        super();
+        if (buffer) {
+            if (buffer instanceof Uint8Array) {
+                const codec = varint.decode(buffer);
+                const name = this.getCodecName(codec);
+                if (name) {
+                    this.name = name;
+                    this.encoded = buffer;
+                    this.decode(buffer);
+                }
+                else {
+                    this.encode(buffer);
+                }
+            }
+            else if (buffer instanceof ArrayBuffer) {
+                const encoded = new Uint8Array(buffer.byteLength);
+                for (let i = 0; i < buffer.byteLength; i++) {
+                    encoded[i] = buffer[i];
+                }
+                this.encoded = encoded;
+                // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
+                this.decode(buffer);
+                return;
+            }
+            if (typeof buffer === 'string') {
+                if (this.codecs[buffer])
+                    this.fromName(buffer);
+                else if (this.isHex(buffer))
+                    this.fromHex(buffer);
+                else if (this.isBase32(buffer))
+                    this.fromBs32(buffer);
+                else if (this.isBase58(buffer))
+                    this.fromBs58(buffer);
+                else
+                    throw new Error(`unsupported string ${buffer}`);
+            }
+            if (!isNaN(buffer))
+                if (this.codecs[this.getCodecName(buffer)])
+                    this.fromCodec(buffer);
+        }
+    }
+    fromEncoded(encoded) {
+        const codec = varint.decode(encoded);
+        const name = this.getCodecName(codec);
+        this.name = name;
+        this.encoded = encoded;
+        this.decode(encoded);
+    }
+    getCodec(name) {
+        return this.codecs[name].codec;
+    }
+    getCodecName(codec) {
+        return Object.keys(this.codecs).reduce((p, c) => {
+            const item = this.codecs[c];
+            if (item.codec === codec)
+                return c;
+            else
+                return p;
+        }, undefined);
+    }
+    getHashAlg(name) {
+        return this.codecs[name].hashAlg;
+    }
+    fromCodec(codec) {
+        this.name = this.getCodecName(codec);
+        this.hashAlg = this.getHashAlg(this.name);
+        this.codec = this.getCodec(this.name);
+        this.codecBuffer = varint.encode(codec);
+    }
+    fromName(name) {
+        const codec = this.getCodec(name);
+        this.name = name;
+        this.codec = codec;
+        this.hashAlg = this.getHashAlg(name);
+        this.codecBuffer = varint.encode(codec);
+    }
+    decode() {
+        const codec = varint.decode(this.encoded);
+        this.fromCodec(codec);
+    }
+    encode() {
+        const codec = varint.encode(this.decoded);
+        this.encoded = codec;
+        return this.encoded;
+    }
+};
+
+let CodecHash$1 = class CodecHash extends BasicInterface$1 {
+    constructor(buffer, options = {}) {
+        super();
+        if (options.name)
+            this.name = options.name;
+        else
+            this.name = 'disco-hash';
+        if (options.codecs)
+            this.codecs = options.codecs;
+        return this.init(buffer);
+    }
+    async init(uint8Array) {
+        if (uint8Array) {
+            if (uint8Array instanceof Uint8Array) {
+                this.discoCodec = new Codec$1(uint8Array, this.codecs);
+                const name = this.discoCodec.name;
+                if (name) {
+                    this.name = name;
+                    this.decode(uint8Array);
+                }
+                else {
+                    await this.encode(uint8Array);
+                }
+            }
+            if (typeof uint8Array === 'string') {
+                if (this.isHex(uint8Array))
+                    await this.fromHex(uint8Array);
+                if (this.isBase32(uint8Array))
+                    await this.fromBs32(uint8Array);
+                else if (this.isBase58(uint8Array))
+                    await this.fromBs58(uint8Array);
+                else
+                    throw new Error(`unsupported string ${uint8Array}`);
+            }
+            else if (typeof uint8Array === 'object')
+                await this.fromJSON(uint8Array);
+        }
+        return this;
+    }
+    get prefix() {
+        const length = this.length;
+        const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
+        uint8Array.set(length);
+        uint8Array.set(this.discoCodec.codecBuffer, length.length);
+        return uint8Array;
+    }
+    get length() {
+        return varint.encode(this.size);
+    }
+    get buffer() {
+        return this.encoded;
+    }
+    get hash() {
+        return this.encoded;
+    }
+    fromJSON(json) {
+        return this.encode(Buffer.from(JSON.stringify(json)));
+    }
+    async encode(buffer, name) {
+        if (!this.name && name)
+            this.name = name;
+        if (!buffer)
+            buffer = this.buffer;
+        this.discoCodec = new Codec$1(this.name, this.codecs);
+        this.discoCodec.fromName(this.name);
+        let hashAlg = this.discoCodec.hashAlg;
+        const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
+        if (hashAlg.includes('dbl')) {
+            hashAlg = hashAlg.replace('dbl-', '');
+            const hasher = await createKeccak(hashVariant);
+            await hasher.init();
+            hasher.update(buffer);
+            buffer = hasher.digest('binary');
+        }
+        const hasher = await createKeccak(hashVariant);
+        await hasher.init();
+        hasher.update(buffer);
+        this.digest = hasher.digest('binary');
+        this.size = this.digest.length;
+        this.codec = this.discoCodec.encode();
+        this.codec = this.discoCodec.codecBuffer;
+        const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
+        uint8Array.set(this.prefix);
+        uint8Array.set(this.digest, this.prefix.length);
+        this.encoded = uint8Array;
+        return this.encoded;
+    }
+    async validate(buffer) {
+        if (Buffer.isBuffer(buffer)) {
+            const codec = varint.decode(buffer);
+            if (this.codecs[codec]) {
+                this.decode(buffer);
+            }
+            else {
+                await this.encode(buffer);
+            }
+        }
+        if (typeof buffer === 'string') {
+            if (this.isHex(buffer))
+                this.fromHex(buffer);
+            if (this.isBase32(buffer))
+                this.fromBs32(buffer);
+        }
+        if (typeof buffer === 'object')
+            this.fromJSON(buffer);
+    }
+    decode(buffer) {
+        this.encoded = buffer;
+        const codec = varint.decode(buffer);
+        this.discoCodec = new Codec$1(codec, this.codecs);
+        // TODO: validate codec
+        buffer = buffer.slice(varint.decode.bytes);
+        this.size = varint.decode(buffer);
+        this.digest = buffer.slice(varint.decode.bytes);
+        if (this.digest.length !== this.size) {
+            throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`);
+        }
+        // const discoCodec = new Codec(codec, this.codecs)
+        this.name = this.discoCodec.name;
+        this.size = this.digest.length;
+        return {
+            codec: this.codec,
+            name: this.name,
+            size: this.size,
+            length: this.length,
+            digest: this.digest,
+        };
+    }
+};
+
+let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
+    set proto(value) {
+        this._proto = value;
+        this.keys = Object.keys(this._proto);
+    }
+    get proto() {
+        return this._proto;
+    }
+    init(buffer) {
+        if (buffer instanceof Uint8Array)
+            this.fromUint8Array(buffer);
+        else if (buffer instanceof ArrayBuffer)
+            this.fromArrayBuffer(buffer);
+        else if (buffer?.name === this.name)
+            return buffer;
+        else if (buffer instanceof String) {
+            if (this.isHex(buffer))
+                this.fromHex(buffer);
+            else if (this.isBase58(buffer))
+                this.fromBs58(buffer);
+            else if (this.isBase32(buffer))
+                this.fromBs32(buffer);
+            else
+                throw new Error(`unsupported ${buffer}`);
+        }
+        else {
+            this.create(buffer);
+        }
+        return this;
+    }
+    hasCodec() {
+        if (!this.encoded)
+            return false;
+        const codec = new Codec$1(this.encoded);
+        if (codec.name)
+            return true;
+    }
+    decode() {
+        let encoded = this.encoded;
+        const codec = new Codec$1(this.encoded);
+        if (codec.codecBuffer) {
+            encoded = encoded.slice(codec.codecBuffer.length);
+            this.name = codec.name;
+            this.decoded = this.protoDecode(encoded);
+            try {
+                this.decoded = JSON.parse(this.decoded);
+            }
+            catch {
+            }
+        }
+        else {
+            throw new Error(`no codec found`);
+        }
+        return this.decoded;
+    }
+    encode(decoded) {
+        let encoded;
+        if (!decoded)
+            decoded = this.decoded;
+        const codec = new Codec$1(this.name);
+        if (decoded instanceof Uint8Array)
+            encoded = decoded;
+        else
+            encoded = this.protoEncode(decoded);
+        if (codec.codecBuffer) {
+            const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
+            uint8Array.set(codec.codecBuffer);
+            uint8Array.set(encoded, codec.codecBuffer.length);
+            this.encoded = uint8Array;
+        }
+        else {
+            throw new Error(`invalid codec`);
+        }
+        return this.encoded;
+    }
+    /**
+     * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
+     * @param {Object} proto - {protoObject}
+     * @param {Object} options - {hashFormat, name}
+     */
+    constructor(buffer, proto, options = {}) {
+        super();
+        this.proto = proto;
+        this.hashFormat = options.hashFormat || 'bs32';
+        if (options.name)
+            this.name = options.name;
+        this.init(buffer);
+    }
+    /**
+     * @return {PeernetHash}
+     */
+    get peernetHash() {
+        return new CodecHash$1(this.decoded, { name: this.name });
+    }
+    /**
+     * @return {peernetHash}
+     */
+    async hash() {
+        const upper = this.hashFormat.charAt(0).toUpperCase();
+        const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
+        return (await this.peernetHash)[`to${format}`]();
+    }
+    fromUint8Array(buffer) {
+        this.encoded = buffer;
+        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
+    }
+    fromArrayBuffer(buffer) {
+        this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
+        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
+    }
+};
+
+const BasicInterface = BasicInterface$1;
+const FormatInterface = FormatInterface$1;
+const CodecHash = CodecHash$1;
+const Codec = Codec$1;
+
+export { BasicInterface, Codec, CodecHash, FormatInterface, codecs$1 as codecs };

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@leofcoin/codec-format-interface",
-  "version": "1.5.3",
+  "version": "1.6.1",
   "description": "",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"
   },
+  "files": [
+    "dist"
+  ],
   "typings": "dist/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/rollup.config.js

@@ -1,13 +0,0 @@
-import typescript from '@rollup/plugin-typescript'
-import tsConfig from './tsconfig.json' assert { type: 'json' }
-
-export default [{
-  input: ['src/index.ts'],
-  output: [{
-    file: 'dist/index.js',
-    format: 'es'
-  }],
-  plugins: [
-    typescript(tsConfig)
-  ]
-}]

package/src/basic-interface.ts

@@ -1,123 +0,0 @@
-import bs32 from '@vandeurenglenn/base32';
-import base58 from '@vandeurenglenn/base58';
-import isHex from '@vandeurenglenn/is-hex';
-import proto from '@vandeurenglenn/proto-array'
-import { fromBase32, fromBase58, fromString, fromHex, fromArrayLike, fromUintArrayString, toBase32, toBase58, toHex } from '@vandeurenglenn/typed-array-utils'
-
-
-export default class BasicInterface {
-  encoded: Uint8Array;
-  decoded: object | string;
-  keys: string[]
-  name: string
-  // get Codec(): Codec {}
-
-  protoEncode(data: object): Uint8Array {
-    // check schema
-    
-    return proto.encode(this.proto, data)
-  }
-
-  protoDecode(data: Uint8Array): object {
-    // check schema
-    return proto.decode(this.proto, data)
-  }
-
-  isHex(string: any) {
-    return isHex(string)
-  }
-  isBase32(string: any) {
-    return bs32.isBase32(string)
-  }
-  isBase58(string: any) {
-    return base58.isBase58(string)
-  }
-
-  fromBs32(encoded: base58String): object {
-    this.encoded = bs32.decode(encoded)
-    return this.decode()
-  }
-
-
-  fromBs58(encoded: any): object {
-    this.encoded = fromBase58(encoded)
-    return this.decode()
-  }
-
-  async toArray() {
-    const array: number[] = []
-    for await (const value of this.encoded.values()) {
-      array.push(value)
-    }
-    return array
-  }
-
-  fromString(string: string): object {
-    const array: string[] = string.split(',')
-    const arrayLike = array.map(string => Number(string))
-    this.encoded = Uint8Array.from(arrayLike)
-    return this.decode()
-  }
-
-  fromHex(string) {
-    this.encoded = fromHex(string)
-    return this.decode()
-  }
-
-  fromArray(array: number[]): object {
-    this.encoded = Uint8Array.from([...array])
-    return this.decode()
-  }
-
-  fromEncoded(encoded: Uint8Array) {
-    this.encoded = encoded
-    return this.decode()
-  }
-
-  toString(): string {
-    if (!this.encoded) this.encode()
-    return this.encoded.toString()
-  }
-
-  toHex() {
-    if (!this.encoded) this.encode()
-    return toHex(this.encoded)
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toBs32() {
-    if (!this.encoded) this.encode()
-    return toBase32(this.encoded)
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toBs58() {
-    if (!this.encoded) this.encode()
-    return toBase58(this.encoded)
-  }
-
-  /**
-   * @param {Object} data
-   */
-  create(data: object) {
-    const decoded = {}
-    if (this.keys?.length > 0) {
-      for (const key of this.keys) {
-        Object.defineProperties(decoded, {
-          [key]: {
-            enumerable: true,
-            configurable: true,
-            set: (value) => value = data[key],
-            get: () => data[key]
-          }
-        })
-      }
-      this.decoded = decoded
-      return this.encode()
-    }
-  }
-}