@leofcoin/codec-format-interface 1.6.0 → 1.6.2

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()
-    }
-  }
-}

package/src/codec-format-interface.ts

@@ -1,116 +0,0 @@
-import BasicInterface from './basic-interface.js'
-import Hash from './codec-hash.js'
-import Codec from './codec.js';
-
-export default class FormatInterface extends BasicInterface implements FormatInterface {
-
-  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(this.encoded)
-    if (codec.name) return true
-  }
-
-  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 = this.protoDecode(encoded)
-      try {
-        this.decoded = JSON.parse(this.decoded)
-      } catch {
-        
-      }
-    } else {
-      throw new Error(`no codec found`)
-    }
-    
-    return this.decoded
-  }
-
-  
-  encode(decoded?: object) {
-    let encoded: Uint8Array
-    if (!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 || 'bs32'
-    if (options.name) this.name = options.name
-    this.init(buffer)
-  }
-
-  /**
-   * @return {PeernetHash}
-   */
-  get peernetHash() {
-    return new Hash(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))
-    )
-  }
-}

package/src/codec-hash.js

@@ -1,139 +0,0 @@
-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 {
-  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,
-    }
-  }
-}

package/src/codec.ts

@@ -1,94 +0,0 @@
-import varint from 'varint';
-import codecs from './codecs.js'
-import BasicInterface from './basic-interface.js'
-
-export default class Codec extends BasicInterface {
-  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
-  }
-}

package/src/codecs.js

@@ -1,87 +0,0 @@
-export default {
-  // 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',
-  }
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-import basicInterface from './basic-interface.js'
-import formatInterface from './codec-format-interface.js'
-import codecHash from './codec-hash.js'
-import codec from './codec.js'
-export * as codecs from './codecs.js'
-
-export const BasicInterface = basicInterface
-export const FormatInterface = formatInterface
-export const CodecHash = codecHash
-export const Codec = codec

package/test/index.js

@@ -1,38 +0,0 @@
-import test from 'tape'
-import {FormatInterface, codecs} from './../dist/index.js'
-
-globalThis.peernet = {codecs: {}}
-class FormatTest extends FormatInterface {
-  get messageName() { return 'Message' }
-
-  constructor(data) {
-    super(data, {
-      somedata: 'test'
-    } , {name: 'disco-hash'})
-  }
-}
-
-const encoded =  [48,  10,   5, 104, 101, 108, 108, 111]
-
-test('format', async  (tape) => {
-  tape.plan(2)
-  const message = new FormatTest({somedata: 'hello'})
-  
-  const m2 = new FormatTest(message.encoded)
-  
-  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 = 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.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-      "outDir": "./dist",
-      "esModuleInterop": true,
-      "allowSyntheticDefaultImports": true,
-      "allowJs": true,
-      "target": "es2022",
-      "module": "es2022",
-      "moduleResolution": "nodeNext",
-      "declaration": true
-  },
-  "include": [
-    "./src/**/*"
-  ],
-  "exclude": [
-    "./node_modules/**/*"
-  ]
-}

package/typings/Base58.d.ts

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

package/typings/BasicInterface.d.ts

@@ -1,48 +0,0 @@
-
-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

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

package/typings/index.d.ts

@@ -1,15 +0,0 @@
-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 {}
-}