@leofcoin/codec-format-interface 1.5.0 → 1.5.2

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@leofcoin/codec-format-interface",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "",
   "main": "dist/index.js",
   "type": "module",
+  "typings": "typings/basicInterface.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "rollup -c"
@@ -21,9 +22,9 @@
   "homepage": "https://github.com/leofcoin/codec-format-interface#readme",
   "dependencies": {
     "@vandeurenglenn/base32": "^1.1.0",
-    "@vandeurenglenn/base58": "^1.1.0",
+    "@vandeurenglenn/base58": "^1.1.1",
     "@vandeurenglenn/is-hex": "^1.0.0",
-    "keccak": "^3.0.2",
+    "hash-wasm": "^4.9.0",
     "varint": "^6.0.0"
   },
   "devDependencies": {

package/src/basic-interface.ts

@@ -0,0 +1,126 @@
+import bs32 from '@vandeurenglenn/base32';
+import base58 from '@vandeurenglenn/base58';
+import isHex from '@vandeurenglenn/is-hex';
+
+
+export default class BasicInterface implements basicInterface {
+  encoded: Uint8Array;
+  decoded: object | string;
+  keys: string[]
+  name: string
+  // get Codec(): Codec {}
+
+  async protoEncode(data: string): Promise<Uint8Array> {
+    // check schema
+    return new TextEncoder().encode(data)
+  }
+
+  async protoDecode(data: Uint8Array): Promise<string> {
+    // check schema
+    return new TextDecoder().decode(data)
+  }
+
+  decode: () => DecodeResult;
+  
+  encode:() => Promise<Uint8Array>;
+
+  isHex(string: any) {
+    return isHex(string)
+  }
+  isBase32(string: any) {
+    return bs32.isBase32(string)
+  }
+  isBase58(string: any) {
+    return base58.isBase58(string)
+  }
+
+  fromBs32(encoded: base58): DecodeResult {
+    this.encoded = bs32.decode(encoded)
+    return this.decode()
+  }
+
+
+  fromBs58(encoded: any): DecodeResult {
+    this.encoded = base58.decode(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()
+  }
+
+  fromArray(array: number[]): object {
+    this.encoded = Uint8Array.from([...array])
+    return this.decode()
+  }
+
+  fromEncoded(encoded: Uint8Array) {
+    this.encoded = encoded
+    return this.decode()
+  }
+
+  fromHex(encoded: string): Promise<string | object> {
+    this.encoded = Buffer.from(encoded, 'hex')
+    return this.decode()
+  }
+
+  async toString(encoding: string = 'utf8'): Promise<string> {
+    if (!this.encoded) await this.encode()
+    return this.encoded.toString(encoding)
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toHex() {
+    return this.toString('hex')
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  async toBs32() {
+    if (!this.encoded) await this.encode()
+    return bs32.encode(this.encoded)
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  async toBs58() {
+    if (!this.encoded) await this.encode()
+    return base58.encode(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()
+    }
+  }
+}

package/src/{codec-format-interface.js → codec-format-interface.ts}

@@ -1,19 +1,8 @@
 import BasicInterface from './basic-interface.js'
-import Codec from './codec.js';
 import Hash from './codec-hash.js'
+import Codec from './codec.js';
 
-export default class FormatInterface extends BasicInterface {
-
-  async protoEncode(data) {
-    // check schema
-    return new TextEncoder().encode(data)
-  }
-
-  async protoDecode(data) {
-    // check schema
-    return new TextDecoder().decode(data)
-  }
-
+export default class FormatInterface extends BasicInterface implements FormatInterface {
   async init(buffer) {
     if (buffer instanceof Uint8Array) await this.fromUint8Array(buffer)
     else if (buffer instanceof ArrayBuffer) await this.fromArrayBuffer(buffer)
@@ -29,6 +18,50 @@ export default class FormatInterface extends BasicInterface {
     return this
   }
 
+  hasCodec() {
+    if (!this.encoded) return false
+    const codec = new Codec(this.encoded)
+    if (codec.name) return true
+  }
+
+  async decode() {
+    let encoded = this.encoded;
+    const codec = new Codec(this.encoded)
+    if (codec.codecBuffer) {
+      encoded = encoded.slice(codec.codecBuffer.length)
+      this.name = codec.name
+      this.decoded = await this.protoDecode(encoded)
+      try {
+        this.decoded = JSON.parse(this.decoded)
+      } catch {
+        
+      }
+    } else {
+      throw new Error(`no codec found`)
+    }
+    
+    return this.decoded
+  }
+
+  
+  async encode(decoded?: object | string) {
+    let encoded: Uint8Array
+    if (!decoded) decoded = this.decoded;
+    const codec = new Codec(this.name)
+
+    if (decoded instanceof Uint8Array) encoded = decoded
+    else encoded = await this.protoEncode(typeof decoded === 'object' ? JSON.stringify(decoded) : 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 - {encode, decode}
@@ -52,52 +85,10 @@ export default class FormatInterface extends BasicInterface {
   /**
    * @return {peernetHash}
    */
-  get hash() {
+  async hash() {
     const upper = this.hashFormat.charAt(0).toUpperCase()
     const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`
-    return this.peernetHash[`to${format}`]()
-  }
-
-  /**
-   * @return {Object}
-   */
-  async decode() {
-    let encoded = this.encoded;
-    const discoCodec = new Codec(this.encoded)
-    encoded = encoded.slice(discoCodec.codecBuffer.length)
-    this.name = discoCodec.name
-    this.decoded = await this.protoDecode(encoded)
-    try {
-      this.decoded = JSON.parse(this.decoded)
-    } catch {
-      
-    }
-    return this.decoded
-  }
-
-  /**
-   * @return {Buffer}
-   */
-  async encode(decoded) {
-    let encoded
-    if (!decoded) decoded = this.decoded;
-    const codec = new Codec(this.name)
-
-    if (decoded instanceof Uint8Array) encoded = decoded
-    else encoded = await this.protoEncode(typeof decoded === 'object' ? JSON.stringify(decoded) : decoded)
-
-    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length)
-    uint8Array.set(codec.codecBuffer)
-    uint8Array.set(encoded, codec.codecBuffer.length)
-
-    this.encoded = uint8Array
-    return this.encoded
-  }
-
-  hasCodec() {
-    if (!this.encoded) return false
-    const codec = new Codec(this.encoded)
-    if (codec.name) return true
+    return (await this.peernetHash)[`to${format}`]()
   }
 
   fromUint8Array(buffer) {

package/src/codec-hash.js

@@ -1,7 +1,7 @@
-import createKeccakHash from 'keccak';
+import {createKeccak} from 'hash-wasm';
 import varint from 'varint';
 import BasicInterface from './basic-interface.js'
-import Codec from './codec';
+import Codec from './codec.js';
 
 export default class CodecHash extends BasicInterface {
   constructor(buffer, options = {}) {
@@ -9,28 +9,32 @@ export default class CodecHash extends BasicInterface {
     if (options.name) this.name = options.name
     else this.name = 'disco-hash'
     if (options.codecs) this.codecs = options.codecs
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        this.discoCodec = new Codec(buffer, this.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(buffer)
+          this.decode(uint8Array)
         } else {
-          this.encode(buffer)
+          await this.encode(uint8Array)
         }
       }
 
-      if (typeof buffer === 'string') {
-        if (this.isHex(buffer)) this.fromHex(buffer)
-        if (this.isBase32(buffer)) this.fromBs32(buffer)
-        else if (this.isBase58(buffer)) this.fromBs58(buffer)
-        else throw new Error(`unsupported string ${buffer}`)
-      } else if (typeof buffer === 'object') this.fromJSON(buffer)
+      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)
@@ -56,17 +60,25 @@ export default class CodecHash extends BasicInterface {
     return this.encode(Buffer.from(JSON.stringify(json)))
   }
 
-  encode(buffer, name) {
+  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-', '')
-      buffer = createKeccakHash(hashAlg.replace('-', '')).update(buffer).digest()
+      const hasher = await createKeccak(hashVariant)
+      await hasher.init()
+      hasher.update(buffer)
+      buffer = hasher.digest('binary')
     }
-    this.digest = createKeccakHash(hashAlg.replace('-', '')).update(buffer).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();
@@ -80,13 +92,13 @@ export default class CodecHash extends BasicInterface {
     return this.encoded
   }
 
-  validate(buffer) {
+  async validate(buffer) {
     if (Buffer.isBuffer(buffer)) {
       const codec = varint.decode(buffer);
       if (this.codecs[codec]) {
         this.decode(buffer)
       } else {
-        this.encode(buffer)
+        await this.encode(buffer)
       }
     }
     if (typeof buffer === 'string') {

package/src/{codec.js → codec.ts}

@@ -2,7 +2,7 @@ import varint from 'varint';
 import codecs from './codecs.js'
 import BasicInterface from './basic-interface.js'
 
-export default class PeernetCodec extends BasicInterface {
+export default class Codec extends BasicInterface {
   get codecs() {
     return {...globalThis.peernet.codecs, ...codecs}
   }

package/src/index.ts

@@ -2,10 +2,9 @@ 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 codecs from './codecs.js'
+export * as codecs from './codecs.js'
 
 export const BasicInterface = basicInterface
 export const FormatInterface = formatInterface
 export const CodecHash = codecHash
 export const Codec = codec
-export const Codecs = codecs

package/test/index.js

@@ -1,5 +1,5 @@
 import test from 'tape'
-import {FormatInterface} from './../dist/index.js'
+import {FormatInterface, codecs} from './../dist/index.js'
 
 globalThis.peernet = {codecs: {}}
 class FormatTest extends FormatInterface {
@@ -18,9 +18,22 @@ const encoded =  [48,  10,   5, 104, 101, 108, 108, 111]
 test('format', async  (tape) => {
   tape.plan(2)
   const message = await new FormatTest({somedata: 'hello'})
-  await message.encode()
+  
   const m2 = await new FormatTest(message.encoded)
-  await m2.decode()
+  
   tape.ok(message.encoded, 'can encode')
   tape.ok(m2.decoded.somedata === 'hello', 'can decode')
 })
+
+test('format can hash', async  (tape) => {
+  tape.plan(1)
+  const message = await new FormatTest({somedata: 'hello'})
+  const hash = await message.hash()
+  tape.ok(hash, 'can hash')
+  
+})
+
+test('has codecs', async  (tape) => {
+  tape.plan(1)
+  tape.ok(Object.keys(codecs).length !== 0)
+})

package/tsconfig.js

@@ -11,6 +11,7 @@ export default {
   },
       "include": [
       "./src/**/*",
-      "./node_modules/**/*"
+      "./node_modules/**/*",
+      "./typings/**/*"
   ]
 }

package/typings/Base58.d.ts

@@ -0,0 +1,5 @@
+
+declare interface base58 {
+  ALPHABET: string;
+  encode: () => base58String;
+}

package/typings/BasicInterface.d.ts

@@ -0,0 +1,48 @@
+
+type DecodeResult = Promise<string | object>;
+
+declare interface basicInterface {
+  encoded: Uint8Array;
+  decoded: object | string;
+  name: string;
+  protoDecode: (encoded: Uint8Array) => Promise<string>;
+  /**
+   * @return Promise(resolve: Uint8Array)
+   */
+  encode: (decoded?: object | string) => Promise<Uint8Array>;
+  /**
+   * @return {Promise(resolve: object|string)}
+   */
+  decode: () => Promise<object | string>;
+  toString: (encoding: string) => Promise<string>;
+  keys: string[];
+  toArray: () => Promise<number[]>;
+
+  /**
+   * @param {Uint8Array} source
+   */
+  fromEncoded: (source: Uint8Array) => Promise<object | string>;
+
+  /**
+   * @param {String} encoded
+   */
+  fromHex: (source: string) => Promise<object | string>;
+
+
+  isHex(string): boolean;
+  isBase32(string): boolean;
+  /**
+   *
+   * @param {base58} string
+   */
+  isBase58(string: base58): boolean;
+  /**
+   * @param {base58} encoded
+   */
+  fromBs32(encoded: base58): Promise<string | object>;
+
+  /**
+   * @param {base58} encoded
+   */
+   fromBs58(encoded: base58): Promise<string | object>;
+}

package/typings/FormatInterface.d.ts

@@ -0,0 +1,5 @@
+import { BasicInterface } from "../dist";
+
+declare class FormatInterface extends BasicInterface {
+  decode: () => Promise<object | string>
+}

package/typings/index.d.ts

@@ -0,0 +1,15 @@
+declare interface base58String {
+  
+}
+declare class Codec {
+  construct():any 
+}
+
+declare const codecs: object
+
+declare module '@leofcoin/code-format-interface' {
+  export module basicInterface {}
+  export module formatInterface {}
+  export module codec {}
+  export module codecs {}
+}

package/src/basic-interface.js

@@ -1,123 +0,0 @@
-import bs32 from '@vandeurenglenn/base32';
-import base58 from '@vandeurenglenn/base58';
-import isHex from '@vandeurenglenn/is-hex';
-
-export default class BasicInterface {
-  handleDecode() {
-    if (!this.decode) throw new Error('bad implementation: needs decode func')
-    return this.decode()
-  }
-
-  handleEncode() {
-    if (!this.encode) throw new Error('bad implementation: needs encode func')
-    return this.encode()
-  }
-  isHex(string) {
-    return isHex(string)
-  }
-  isBase32(string) {
-    return bs32.isBase32(string)
-  }
-  isBase58(string) {
-    return base58.isBase58(string)
-  }
-  /**
-   * @param {String} encoded
-   */
-  fromBs32(encoded) {
-    this.encoded = bs32.decode(encoded)
-    return this.handleDecode()
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  frombase58(encoded) {
-    this.encoded = base58.decode(encoded)
-    return this.handleDecode()
-  }
-
-  async toArray() {
-    const array = []
-    for await (const value of this.encoded.values()) {
-      array.push(value)
-    }
-    return array
-  }
-
-  fromString(string) {
-    this.encoded = new Uint8Array(string.split(','))
-    return this.handleDecode()
-  }
-
-  fromArray(array) {
-    this.encoded = new Uint8Array([...array])
-    return this.handleDecode()
-  }
-
-  /**
-   * @param {Buffer} encoded
-   */
-  fromEncoded(encoded) {
-    this.encoded = encoded
-    return this.handleDecode()
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromHex(encoded) {
-    this.encoded = Buffer.from(encoded, 'hex')
-    return this.handleDecode()
-  }
-
-  async toString(encoding = 'utf8') {
-    if (!this.encoded) await this.handleEncode()
-    return this.encoded.toString(encoding)
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toHex() {
-    return this.toString('hex')
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  async toBs32() {
-    if (!this.encoded) await this.handleEncode()
-    return bs32.encode(this.encoded)
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  async tobase58() {
-    if (!this.encoded) await this.handleEncode()
-    return base58.encode(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: (val) => value = data[key],
-            get: () => data[key]
-          }
-        })
-      }
-
-      this.decoded = decoded
-      return this.encode()
-    }
-  }
-}