@leofcoin/codec-format-interface 1.6.18 → 1.7.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 vandeurenglenn
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2022 vandeurenglenn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/exports/basic-interface.d.ts

@@ -7,7 +7,7 @@ export default class BasicInterface {
     set proto(value: object);
     get proto(): object;
     decode(encoded?: Uint8Array): Object;
-    encode(decoded?: any): Uint8Array | Promise<Uint8Array>;
+    encode(decoded?: object): Uint8Array;
     protoEncode(data: object): Uint8Array;
     protoDecode(data: Uint8Array): object;
     isHex(string: string): boolean;

package/exports/basic-interface.js

@@ -2,8 +2,9 @@ import bs32 from '@vandeurenglenn/base32';
 import base58 from '@vandeurenglenn/base58';
 import isHex from '@vandeurenglenn/is-hex';
 import proto from '@vandeurenglenn/proto-array';
-import { fromBase58, fromHex, toBase32, toBase58, toHex } from '@vandeurenglenn/typed-array-utils';
-export default class BasicInterface {
+import { fromBase58, fromHex, toHex, toBase32, toBase58 } from '@vandeurenglenn/typed-array-utils';
+
+class BasicInterface {
     encoded;
     decoded;
     keys;
@@ -77,7 +78,7 @@ export default class BasicInterface {
     toHex() {
         if (!this.encoded)
             this.encode();
-        return toHex(this.encoded);
+        return toHex(this.encoded.toString().split(',').map(number => Number(number)));
     }
     /**
      * @return {String} encoded
@@ -96,3 +97,5 @@ export default class BasicInterface {
         return toBase58(this.encoded);
     }
 }
+
+export { BasicInterface as default };

package/exports/codec-a830f1a0.js

@@ -0,0 +1,284 @@
+import varint from 'varint';
+import BasicInterface from './basic-interface.js';
+
+const blockchainCodecs = [
+    {
+        name: 'leofcoin-block',
+        codec: '0x6c62',
+        hashAlg: 'dbl-keccak-512',
+    },
+    {
+        name: 'leofcoin-tx',
+        codec: '0x6c74',
+        hashAlg: 'dbl-keccak-512',
+    },
+    {
+        name: 'leofcoin-itx',
+        codec: '0x6c69',
+        hashAlg: 'keccak-512',
+    },
+    {
+        name: 'leofcoin-pr',
+        codec: '0x6c70',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'contract-message',
+        codec: '0x63636d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'transaction-message',
+        codec: '0x746d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'raw-transaction-message',
+        codec: '0x772746d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'block-message',
+        codec: '0x626d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'bw-message',
+        codec: '0x62776d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'bw-request-message',
+        codec: '0x6277726d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'validator-message',
+        codec: '0x766d',
+        hashAlg: 'keccak-256'
+    }
+];
+
+const internalCodecs = [
+    {
+        name: 'disco-hash',
+        codec: '0x30',
+        hashAlg: 'dbl-keccak-256',
+    },
+    {
+        name: 'peernet-peer-response',
+        codec: '0x707072',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-peer',
+        codec: '0x7070',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-dht',
+        codec: '0x706468',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-dht-response',
+        codec: '0x706472',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-data',
+        codec: '0x706461',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-data-response',
+        codec: '0x70646172',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-message',
+        codec: '0x706d65',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-ps',
+        codec: '707073',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-response',
+        codec: '0x7072',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-request',
+        codec: '0x707271',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-file',
+        codec: '0x7066',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-file-response',
+        codec: '0x706672',
+        hashAlg: 'keccak-256',
+    }
+];
+
+var social = [{
+        name: 'chat-message',
+        codec: '0x70636d',
+        hashAlg: 'dbl-keccak-256',
+    }];
+
+const codecs = [
+    ...internalCodecs,
+    ...blockchainCodecs,
+    ...social
+];
+
+globalThis.peernetCodecs = globalThis.peernetCodecs || {};
+const addCodec = (codecInput) => {
+    let { hashAlg, codec, name } = codecInput;
+    if (!globalThis.peernetCodecs[name])
+        globalThis.peernetCodecs[name] = {
+            hashAlg,
+            codec: typeof codec === 'string' ? parseInt(codec, 16) : codec
+        };
+};
+const getCodec = (name) => {
+    if (typeof name === 'number')
+        return name;
+    return getCodecByName(name).codec;
+};
+const getCodecName = (codec) => {
+    return Object.keys(globalThis.peernetCodecs).reduce((p, c) => {
+        const item = globalThis.peernetCodecs[c];
+        if (item.codec === codec)
+            return c;
+        else
+            return p;
+    }, undefined);
+};
+const getCodecByName = (name) => globalThis.peernetCodecs[name];
+const getHashAlg = (name) => {
+    if (typeof name === 'number')
+        return getCodecByName(getCodecName(name)).hashAlg;
+    return getCodecByName(name).hashAlg;
+};
+const isCodec = (codec) => {
+    if (codec.codec !== undefined && codec.hashAlg)
+        return true;
+    return false;
+};
+const validateCodec = (codec) => {
+    if (codec.codec === undefined ||
+        codec.hashAlg === undefined ||
+        codec.name === undefined)
+        throw new Error(`invalid codecInput: ${codec}`);
+};
+for (const codec of codecs) {
+    addCodec(codec);
+}
+var utils = {
+    isCodec,
+    addCodec,
+    getCodec,
+    getHashAlg,
+    getCodecName,
+    validateCodec,
+    codecs: globalThis.peernetCodecs
+};
+
+class Codec extends BasicInterface {
+    codecBuffer;
+    codec;
+    hashAlg;
+    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(Number(new TextDecoder().decode(buffer)));
+                }
+            }
+            else if (buffer instanceof ArrayBuffer) {
+                const codec = varint.decode(buffer);
+                const name = this.getCodecName(codec);
+                if (name) {
+                    this.name = name;
+                    this.decode(buffer);
+                }
+                else {
+                    this.encode(Number(new TextDecoder().decode(new Uint8Array(buffer))));
+                }
+            }
+            else if (typeof buffer === 'string') {
+                if (utils.getCodec(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
+                    this.fromString(buffer);
+            }
+            if (!isNaN(buffer))
+                if (utils.getCodec(buffer))
+                    this.fromCodec(buffer);
+        }
+    }
+    fromEncoded(encoded) {
+        const codec = varint.decode(encoded);
+        const name = this.getCodecName(codec);
+        this.name = name;
+        this.encoded = encoded;
+        return this.decode(encoded);
+    }
+    getCodec(name) {
+        return utils.getCodec(name);
+    }
+    getCodecName(codec) {
+        return utils.getCodecName(codec);
+    }
+    getHashAlg(name) {
+        return utils.getHashAlg(name);
+    }
+    fromCodec(codec) {
+        this.name = this.getCodecName(codec);
+        this.hashAlg = this.getHashAlg(this.name);
+        this.codec = this.getCodec(this.name);
+        this.codecBuffer = varint.encode(this.codec);
+    }
+    fromName(name) {
+        const codec = this.getCodec(name);
+        this.name = name;
+        this.codec = codec;
+        this.hashAlg = this.getHashAlg(name);
+        this.codecBuffer = varint.encode(this.codec);
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = varint.decode(encoded);
+        this.fromCodec(codec);
+        return this.decoded;
+    }
+    encode(codec) {
+        codec = codec || this.codec;
+        this.encoded = varint.encode(codec);
+        return this.encoded;
+    }
+}
+
+export { Codec as C, codecs as c };

package/exports/codec-format-interface-07c55dde.js

@@ -0,0 +1,268 @@
+import BasicInterface from './basic-interface.js';
+import { createKeccak } from 'hash-wasm';
+import varint from 'varint';
+import { C as Codec } from './codec-a830f1a0.js';
+
+class CodecHash extends BasicInterface {
+  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(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(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(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,
+    }
+  }
+}
+
+class FormatInterface extends BasicInterface {
+    hashFormat;
+    init(buffer) {
+        if (buffer instanceof Uint8Array)
+            this.fromUint8Array(buffer);
+        else if (buffer instanceof ArrayBuffer)
+            this.fromArrayBuffer(buffer);
+        else if (buffer instanceof FormatInterface && buffer?.name === this.name)
+            return buffer;
+        else if (typeof buffer === '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
+                this.fromString(buffer);
+        }
+        else {
+            this.create(buffer);
+        }
+        return this;
+    }
+    hasCodec() {
+        if (!this.encoded)
+            return false;
+        const codec = new Codec(this.encoded);
+        if (codec.name)
+            return true;
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = new Codec(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;
+        decoded = decoded || this.decoded;
+        const codec = new Codec(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 ? options.hashFormat : 'bs32';
+        if (options?.name)
+            this.name = options.name;
+        this.init(buffer);
+    }
+    /**
+     * @return {PeernetHash}
+     */
+    get peernetHash() {
+        const decoded = this.decoded;
+        // @ts-ignore
+        delete decoded.hash;
+        return new CodecHash(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)));
+    }
+    /**
+     * @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(decoded);
+        }
+    }
+}
+
+export { CodecHash as C, FormatInterface as F };

package/exports/codec-format-interface-31a2dd5c.js

@@ -0,0 +1,268 @@
+import BasicInterface from './basic-interface.js';
+import { createKeccak } from 'hash-wasm';
+import varint from 'varint';
+import { C as Codec } from './codec-a830f1a0.js';
+
+class CodecHash extends BasicInterface {
+  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(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(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(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,
+    }
+  }
+}
+
+class FormatInterface extends BasicInterface {
+    hashFormat;
+    init(buffer) {
+        if (buffer instanceof Uint8Array)
+            this.fromUint8Array(buffer);
+        else if (buffer instanceof ArrayBuffer)
+            this.fromArrayBuffer(buffer);
+        else if (buffer instanceof FormatInterface && buffer?.name === this.name)
+            return buffer;
+        else if (typeof buffer === '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
+                this.fromString(buffer);
+        }
+        else {
+            this.create(buffer);
+        }
+        return this;
+    }
+    hasCodec() {
+        if (!this.encoded)
+            return false;
+        const codec = new Codec(this.encoded);
+        if (codec.name)
+            return true;
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = new Codec(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;
+        decoded = decoded || this.decoded;
+        const codec = new Codec(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 ? options.hashFormat : 'bs32';
+        if (options?.name)
+            this.name = options.name;
+        this.init(buffer);
+    }
+    /**
+     * @return {PeernetHash}
+     */
+    get peernetHash() {
+        const decoded = this.decoded;
+        // @ts-ignore
+        delete decoded.hash;
+        return new CodecHash(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)));
+    }
+    /**
+     * @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(decoded)
+        }
+    }
+}
+
+export { CodecHash as C, FormatInterface as F };

package/exports/codec-format-interface.d.ts

@@ -1,6 +1,7 @@
 import BasicInterface from './basic-interface.js';
 import Hash from './codec-hash.js';
 export default class FormatInterface extends BasicInterface implements FormatInterface {
+    #private;
     hashFormat: string;
     init(buffer: Uint8Array | ArrayBuffer | FormatInterface | string): FormatInterface;
     hasCodec(): boolean;
@@ -15,6 +16,7 @@ export default class FormatInterface extends BasicInterface implements FormatInt
         hashFormat?: string;
         name?: string;
     });
+    get format(): string;
     /**
      * @return {PeernetHash}
      */

package/exports/codec-format-interface.js

@@ -1,8 +1,17 @@
 import BasicInterface from './basic-interface.js';
-import Hash from './codec-hash.js';
 import Codec from './codec.js';
-export default class FormatInterface extends BasicInterface {
+import CodecHash from './codec-hash.js';
+import '@vandeurenglenn/base32';
+import '@vandeurenglenn/base58';
+import '@vandeurenglenn/is-hex';
+import '@vandeurenglenn/proto-array';
+import '@vandeurenglenn/typed-array-utils';
+import 'varint';
+import '@leofcoin/codecs';
+
+class FormatInterface extends BasicInterface {
     hashFormat;
+    #hash;
     init(buffer) {
         if (buffer instanceof Uint8Array)
             this.fromUint8Array(buffer);
@@ -34,7 +43,7 @@ export default class FormatInterface extends BasicInterface {
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = new Codec(this.encoded);
+        const codec = new Codec(encoded);
         if (codec.codecBuffer) {
             encoded = encoded.slice(codec.codecBuffer.length);
             this.name = codec.name;
@@ -51,8 +60,7 @@ export default class FormatInterface extends BasicInterface {
     }
     encode(decoded) {
         let encoded;
-        if (!decoded)
-            decoded = this.decoded;
+        decoded = decoded || this.decoded;
         const codec = new Codec(this.name);
         if (decoded instanceof Uint8Array)
             encoded = decoded;
@@ -82,16 +90,25 @@ export default class FormatInterface extends BasicInterface {
             this.name = options.name;
         this.init(buffer);
     }
+    get format() {
+        const upper = this.hashFormat.charAt(0).toUpperCase();
+        return `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
+    }
     /**
      * @return {PeernetHash}
      */
     get peernetHash() {
-        return new Hash(this.decoded, { name: this.name });
+        const decoded = this.decoded;
+        // @ts-ignore
+        delete decoded.hash;
+        return new CodecHash(decoded, { name: this.name });
     }
     /**
      * @return {peernetHash}
      */
     async hash() {
+        if (this.#hash)
+            return this.#hash;
         const upper = this.hashFormat.charAt(0).toUpperCase();
         const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
         return (await this.peernetHash)[`to${format}`]();
@@ -109,12 +126,16 @@ export default class FormatInterface extends BasicInterface {
      */
     create(data) {
         const decoded = {};
+        if (data.hash)
+            this.#hash = data.hash;
         if (this.keys?.length > 0) {
             for (const key of this.keys) {
                 decoded[key] = data[key];
             }
             this.decoded = decoded;
-            return this.encode(decoded);
+            // return this.encode(decoded)
         }
     }
 }
+
+export { FormatInterface as default };

package/exports/codec-hash.d.ts

@@ -1,27 +1,21 @@
 import BasicInterface from './basic-interface.js';
-import Codec from './codec.js';
 export default class CodecHash extends BasicInterface {
-    codec: Codec;
-    codecs: {};
-    digest: Uint8Array;
-    size: number;
-    constructor(buffer: any, options?: {
-        name: string;
-        codecs?: {};
-    });
+    codec: any;
+    discoCodec: any;
+    constructor(buffer: any, options?: {});
     init(uint8Array: any): Promise<this>;
     get prefix(): Uint8Array;
     get length(): number[];
     get buffer(): Uint8Array;
     get hash(): Uint8Array;
     fromJSON(json: any): Promise<Uint8Array>;
-    encode(buffer: Uint8Array, name?: string): Promise<Uint8Array>;
+    encode(buffer: any, name: any): Promise<Uint8Array>;
     validate(buffer: any): Promise<void>;
-    decode(encoded: Uint8Array): {
-        codec: Codec;
+    decode(buffer: any): {
+        codec: any;
         name: string;
-        size: number;
+        size: any;
         length: number[];
-        digest: Uint8Array;
+        digest: any;
     };
 }

package/exports/codec-hash.js

@@ -1,13 +1,17 @@
-import { createKeccak } from 'hash-wasm';
 import varint from 'varint';
 import BasicInterface from './basic-interface.js';
 import Codec from './codec.js';
-export default class CodecHash extends BasicInterface {
+import '@vandeurenglenn/base32';
+import '@vandeurenglenn/base58';
+import '@vandeurenglenn/is-hex';
+import '@vandeurenglenn/proto-array';
+import '@vandeurenglenn/typed-array-utils';
+import '@leofcoin/codecs';
+
+class CodecHash extends BasicInterface {
     codec;
-    codecs;
-    digest;
-    size;
-    constructor(buffer, options) {
+    discoCodec;
+    constructor(buffer, options = {}) {
         super();
         if (options.name)
             this.name = options.name;
@@ -15,14 +19,13 @@ export default class CodecHash extends BasicInterface {
             this.name = 'disco-hash';
         if (options.codecs)
             this.codecs = options.codecs;
-        // @ts-ignore
         return this.init(buffer);
     }
     async init(uint8Array) {
         if (uint8Array) {
             if (uint8Array instanceof Uint8Array) {
-                this.codec = new Codec(uint8Array);
-                const name = this.codec.name;
+                this.discoCodec = new Codec(uint8Array, this.codecs);
+                const name = this.discoCodec.name;
                 if (name) {
                     this.name = name;
                     this.decode(uint8Array);
@@ -48,9 +51,9 @@ export default class CodecHash extends BasicInterface {
     }
     get prefix() {
         const length = this.length;
-        const uint8Array = new Uint8Array(length.length + this.codec.codecBuffer.length);
+        const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
         uint8Array.set(length);
-        uint8Array.set(this.codec.codecBuffer, length.length);
+        uint8Array.set(this.discoCodec.codecBuffer, length.length);
         return uint8Array;
     }
     get length() {
@@ -63,29 +66,36 @@ export default class CodecHash extends BasicInterface {
         return this.encoded;
     }
     fromJSON(json) {
-        return this.encode(new TextEncoder().encode(JSON.stringify(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.codec = new Codec(this.name);
-        this.codec.fromName(this.name);
-        let hashAlg = this.codec.hashAlg;
+        this.discoCodec = new Codec(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)
+            // buffer = hasher.digest('binary')
+            buffer = await crypto.subtle.digest(`SHA-${hashVariant}`, buffer);
+        }
+        // const hasher = await createKeccak(hashVariant)
+        // await hasher.init()
+        // hasher.update(buffer)
+        // this.digest = hasher.digest('binary')
+        this.digest = await crypto.subtle.digest(`SHA-${hashVariant}`, buffer);
+        if (this.digest instanceof ArrayBuffer) {
+            this.digest = new Uint8Array(this.digest);
         }
-        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);
@@ -111,19 +121,19 @@ export default class CodecHash extends BasicInterface {
         if (typeof buffer === 'object')
             this.fromJSON(buffer);
     }
-    decode(encoded) {
-        this.encoded = encoded;
-        const codec = varint.decode(encoded);
-        this.codec = new Codec(codec);
+    decode(buffer) {
+        this.encoded = buffer;
+        const codec = varint.decode(buffer);
+        this.discoCodec = new Codec(codec, this.codecs);
         // TODO: validate codec
-        encoded = encoded.slice(varint.decode.bytes);
-        this.size = varint.decode(encoded);
-        this.digest = encoded.slice(varint.decode.bytes);
+        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: ${this.encoded.toString()}`);
+            throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`);
         }
-        // const codec = new Codec(codec, this.codecs)
-        this.name = this.codec.name;
+        // const discoCodec = new Codec(codec, this.codecs)
+        this.name = this.discoCodec.name;
         this.size = this.digest.length;
         return {
             codec: this.codec,
@@ -134,3 +144,5 @@ export default class CodecHash extends BasicInterface {
         };
     }
 }
+
+export { CodecHash as default };

package/exports/codec.js

@@ -1,7 +1,13 @@
 import varint from 'varint';
-import { utils as codecUtils } from '@leofcoin/codecs';
+import { utils } from '@leofcoin/codecs';
 import BasicInterface from './basic-interface.js';
-export default class Codec extends BasicInterface {
+import '@vandeurenglenn/base32';
+import '@vandeurenglenn/base58';
+import '@vandeurenglenn/is-hex';
+import '@vandeurenglenn/proto-array';
+import '@vandeurenglenn/typed-array-utils';
+
+class Codec extends BasicInterface {
     codecBuffer;
     codec;
     hashAlg;
@@ -21,7 +27,7 @@ export default class Codec extends BasicInterface {
                 }
             }
             else if (buffer instanceof ArrayBuffer) {
-                const codec = varint.decode(new Uint8Array(buffer));
+                const codec = varint.decode(buffer);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -32,7 +38,7 @@ export default class Codec extends BasicInterface {
                 }
             }
             else if (typeof buffer === 'string') {
-                if (codecUtils.getCodec(buffer))
+                if (utils.getCodec(buffer))
                     this.fromName(buffer);
                 else if (this.isHex(buffer))
                     this.fromHex(buffer);
@@ -44,7 +50,7 @@ export default class Codec extends BasicInterface {
                     this.fromString(buffer);
             }
             if (!isNaN(buffer))
-                if (codecUtils.getCodec(buffer))
+                if (utils.getCodec(buffer))
                     this.fromCodec(buffer);
         }
     }
@@ -56,13 +62,13 @@ export default class Codec extends BasicInterface {
         return this.decode(encoded);
     }
     getCodec(name) {
-        return codecUtils.getCodec(name);
+        return utils.getCodec(name);
     }
     getCodecName(codec) {
-        return codecUtils.getCodecName(codec);
+        return utils.getCodecName(codec);
     }
     getHashAlg(name) {
-        return codecUtils.getHashAlg(name);
+        return utils.getHashAlg(name);
     }
     fromCodec(codec) {
         this.name = this.getCodecName(codec);
@@ -89,3 +95,5 @@ export default class Codec extends BasicInterface {
         return this.encoded;
     }
 }
+
+export { Codec as default };

package/exports/index.js

@@ -1,9 +1,18 @@
-import basicInterface from './basic-interface.js';
-import formatInterface from './codec-format-interface.js';
-import codecHash from './codec-hash.js';
-import codec from './codec.js';
+import BasicInterface$1 from './basic-interface.js';
+import FormatInterface$1 from './codec-format-interface.js';
+import CodecHash$1 from './codec-hash.js';
+import Codec$1 from './codec.js';
 export { codecs } from '@leofcoin/codecs';
-export const BasicInterface = basicInterface;
-export const FormatInterface = formatInterface;
-export const CodecHash = codecHash;
-export const Codec = codec;
+import '@vandeurenglenn/base32';
+import '@vandeurenglenn/base58';
+import '@vandeurenglenn/is-hex';
+import '@vandeurenglenn/proto-array';
+import '@vandeurenglenn/typed-array-utils';
+import 'varint';
+
+const BasicInterface = BasicInterface$1;
+const FormatInterface = FormatInterface$1;
+const CodecHash = CodecHash$1;
+const Codec = Codec$1;
+
+export { BasicInterface, Codec, CodecHash, FormatInterface };

package/package.json

@@ -1,46 +1,50 @@
-{
-  "name": "@leofcoin/codec-format-interface",
-  "version": "1.6.18",
-  "description": "",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./exports/index.js",
-      "types": "./exports/index.d.ts"
-    }
-  },
-  "files": [
-    "exports"
-  ],
-  "scripts": {
-    "prepublish": "npm run build && npm version patch",
-    "build": "npx tsc",
-    "test": "node test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/leofcoin/codec-format-interface.git"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/leofcoin/codec-format-interface/issues"
-  },
-  "homepage": "https://github.com/leofcoin/codec-format-interface#readme",
-  "dependencies": {
-    "@leofcoin/codecs": "^1.0.0",
-    "@vandeurenglenn/base32": "^1.1.0",
-    "@vandeurenglenn/base58": "^1.1.1",
-    "@vandeurenglenn/is-hex": "^1.1.1",
-    "@vandeurenglenn/proto-array": "^1.0.0",
-    "@vandeurenglenn/typed-array-utils": "^1.1.0",
-    "hash-wasm": "^4.9.0",
-    "varint": "^6.0.0"
-  },
-  "devDependencies": {
-    "@types/varint": "^6.0.1",
-    "tape": "^5.5.3",
-    "typescript": "^5.2.2"
-  }
-}
+{
+  "name": "@leofcoin/codec-format-interface",
+  "version": "1.7.0",
+  "description": "",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "exports"
+  ],
+  "typings": "dist/index.d.ts",
+  "scripts": {
+    "prepublish": "npm run build && npm version patch",
+    "build": "rollup -c",
+    "test": "node test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leofcoin/codec-format-interface.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/leofcoin/codec-format-interface/issues"
+  },
+  "homepage": "https://github.com/leofcoin/codec-format-interface#readme",
+  "dependencies": {
+    "@leofcoin/codecs": "^1.0.0",
+    "@leofcoin/crypto": "^0.2.7",
+    "@vandeurenglenn/base32": "^1.1.0",
+    "@vandeurenglenn/base58": "^1.1.1",
+    "@vandeurenglenn/is-hex": "^1.0.0",
+    "@vandeurenglenn/proto-array": "^1.0.0",
+    "@vandeurenglenn/typed-array-utils": "^1.1.0",
+    "hash-wasm": "^4.9.0",
+    "varint": "^6.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^23.0.3",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-typescript": "^10.0.1",
+    "@types/varint": "^6.0.1",
+    "rollup": "^3.5.1",
+    "tape": "^5.5.3",
+    "tinybench": "^2.5.1",
+    "tslib": "^2.4.1"
+  }
+}