@fleet-sdk/crypto 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# @fleet-sdk/crypto
+
+## 0.2.0
+
+### Minor Changes
+
+- 8a13a29: Introduce `crypto` package with Ergo crypto primitives.
+- 2ab9661: Add byte coders
+  - `base64` - encode/decode base64 string;
+  - `base58` - encode/decode base58 string;
+  - `base58check` - encode/decode base58check string;
+  - `hex` - encode/decode hex string;
+  - `utf8` - encode/decode hex string.
+- 2ab9661: Add hashing functions:
+  - `blake2b256()`
+  - `sha256()`
+
+### Patch Changes
+
+- Updated dependencies [5a79c57]
+- Updated dependencies [a491ab9]
+- Updated dependencies [3236dd8]
+- Updated dependencies [9bd393b]
+  - @fleet-sdk/common@0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Nautilus Team
+
+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/README.md

@@ -0,0 +1,3 @@
+# @fleet-sdk/crypto [![License](https://badgen.net/github/license/fleet-sdk/fleet/)](https://github.com/fleet-sdk/fleet/blob/master/LICENSE) [![npm](https://badgen.net/npm/v/@fleet-sdk/crypto)](https://www.npmjs.com/package/@fleet-sdk/crypto)
+
+Ergo blockchain crypto primitives.

package/dist/index.d.mts

@@ -0,0 +1,35 @@
+import * as _scure_base from '@scure/base';
+
+type BytesInput = Uint8Array | string;
+interface Coder<F, T> {
+    encode(from: F): T;
+    decode(to: T): F;
+}
+interface BytesCoder extends Coder<Uint8Array, string> {
+    /**
+     * Encodes an array of bytes to a string
+     */
+    encode: (data: Uint8Array) => string;
+    /**
+     * Decodes a string to an array of bytes
+     */
+    decode: (str: string) => Uint8Array;
+}
+
+declare const blake2b256: (message: BytesInput) => Uint8Array;
+declare const sha256: (message: BytesInput) => Uint8Array;
+
+declare const hex: BytesCoder;
+
+declare const utf8: BytesCoder;
+
+declare const base58check: _scure_base.BytesCoder;
+declare const base58: BytesCoder;
+declare const base64: BytesCoder;
+
+/**
+ * Secure PRNG from "@noble/hashes". Uses crypto.getRandomValues, which defers to OS.
+ */
+declare const randomBytes: (bytesLength?: number) => Uint8Array;
+
+export { BytesCoder, BytesInput, Coder, base58, base58check, base64, blake2b256, hex, randomBytes, sha256, utf8 };

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import * as _scure_base from '@scure/base';
+
+type BytesInput = Uint8Array | string;
+interface Coder<F, T> {
+    encode(from: F): T;
+    decode(to: T): F;
+}
+interface BytesCoder extends Coder<Uint8Array, string> {
+    /**
+     * Encodes an array of bytes to a string
+     */
+    encode: (data: Uint8Array) => string;
+    /**
+     * Decodes a string to an array of bytes
+     */
+    decode: (str: string) => Uint8Array;
+}
+
+declare const blake2b256: (message: BytesInput) => Uint8Array;
+declare const sha256: (message: BytesInput) => Uint8Array;
+
+declare const hex: BytesCoder;
+
+declare const utf8: BytesCoder;
+
+declare const base58check: _scure_base.BytesCoder;
+declare const base58: BytesCoder;
+declare const base64: BytesCoder;
+
+/**
+ * Secure PRNG from "@noble/hashes". Uses crypto.getRandomValues, which defers to OS.
+ */
+declare const randomBytes: (bytesLength?: number) => Uint8Array;
+
+export { BytesCoder, BytesInput, Coder, base58, base58check, base64, blake2b256, hex, randomBytes, sha256, utf8 };

package/dist/index.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var utils = require('@noble/hashes/utils');
+var blake2b = require('@noble/hashes/blake2b');
+var sha256$1 = require('@noble/hashes/sha256');
+var base = require('@scure/base');
+var common = require('@fleet-sdk/common');
+
+// src/index.ts
+var blake2b256 = (message) => blake2b.blake2b(message, { dkLen: 32 });
+var sha256 = sha256$1.sha256;
+var HEXES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  common.assertInstanceOf(bytes, Uint8Array);
+  let hex2 = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex2 += HEXES[bytes[i]];
+  }
+  return hex2;
+}
+function hexToBytes(hex2) {
+  common.assertTypeOf(hex2, "string");
+  common.assert(hex2.length % 2 === 0, "Invalid hex padding.");
+  const bytes = new Uint8Array(hex2.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    const j = i * 2;
+    const hexByte = hex2.slice(j, j + 2);
+    const byte = parseInt(hexByte, 16);
+    common.assert(!isNaN(byte) && byte >= 0, "Invalid byte sequence.");
+    bytes[i] = byte;
+  }
+  return bytes;
+}
+var hex = {
+  encode: bytesToHex,
+  decode: hexToBytes
+};
+function bytesToUtf8(bytes) {
+  common.assertInstanceOf(bytes, Uint8Array);
+  return new TextDecoder().decode(bytes);
+}
+function utf8ToBytes(str) {
+  common.assertTypeOf(str, "string");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+var utf8 = {
+  encode: bytesToUtf8,
+  decode: utf8ToBytes
+};
+
+// src/coders/index.ts
+var base58check = base.base58check(sha256);
+var base58 = base.base58;
+var base64 = base.base64;
+
+// src/index.ts
+var randomBytes = utils.randomBytes;
+
+exports.base58 = base58;
+exports.base58check = base58check;
+exports.base64 = base64;
+exports.blake2b256 = blake2b256;
+exports.hex = hex;
+exports.randomBytes = randomBytes;
+exports.sha256 = sha256;
+exports.utf8 = utf8;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/hashes.ts","../src/coders/index.ts","../src/coders/hex.ts","../src/coders/utf8.ts"],"names":["hex","assertInstanceOf","assertTypeOf"],"mappings":";AAAA,SAAS,eAAe,wBAAwB;;;ACAhD,SAAS,eAAe;AACxB,SAAS,UAAU,mBAAmB;AAG/B,IAAM,aAAa,CAAC,YAAwB,QAAQ,SAAS,EAAE,OAAO,GAAG,CAAC;AAC1E,IAAM,SAAS;;;ACLtB;AAAA,EACE,eAAe;AAAA,EACf,UAAU;AAAA,EACV,UAAU;AAAA,OACL;;;ACJP,SAAS,QAAQ,kBAAkB,oBAAoB;AAGvD,IAAM,QAAQ,MAAM,KAAK,EAAE,QAAQ,IAAI,GAAG,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAEnF,SAAS,WAAW,OAA2B;AAC7C,mBAAiB,OAAO,UAAU;AAElC,MAAIA,OAAM;AACV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,IAAAA,QAAO,MAAM,MAAM,CAAC,CAAC;AAAA,EACvB;AAEA,SAAOA;AACT;AAEA,SAAS,WAAWA,MAAyB;AAC3C,eAAaA,MAAK,QAAQ;AAC1B,SAAOA,KAAI,SAAS,MAAM,GAAG,sBAAsB;AAEnD,QAAM,QAAQ,IAAI,WAAWA,KAAI,SAAS,CAAC;AAC3C,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAM,IAAI,IAAI;AACd,UAAM,UAAUA,KAAI,MAAM,GAAG,IAAI,CAAC;AAClC,UAAM,OAAO,SAAS,SAAS,EAAE;AACjC,WAAO,CAAC,MAAM,IAAI,KAAK,QAAQ,GAAG,wBAAwB;AAE1D,UAAM,CAAC,IAAI;AAAA,EACb;AAEA,SAAO;AACT;AAEO,IAAM,MAAkB;AAAA,EAC7B,QAAQ;AAAA,EACR,QAAQ;AACV;;;ACpCA,SAAS,oBAAAC,mBAAkB,gBAAAC,qBAAoB;AAG/C,SAAS,YAAY,OAA2B;AAC9C,EAAAD,kBAAiB,OAAO,UAAU;AAElC,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK;AACvC;AAEA,SAAS,YAAY,KAAyB;AAC5C,EAAAC,cAAa,KAAK,QAAQ;AAE1B,SAAO,IAAI,WAAW,IAAI,YAAY,EAAE,OAAO,GAAG,CAAC;AACrD;AAEO,IAAM,OAAmB;AAAA,EAC9B,QAAQ;AAAA,EACR,QAAQ;AACV;;;AFVO,IAAM,cAAc,iBAAiB,MAAM;AAC3C,IAAM,SAAS;AACf,IAAM,SAAS;;;AFLf,IAAM,cAAc","sourcesContent":["import { randomBytes as nobleRandomBytes } from \"@noble/hashes/utils\";\n\n/**\n * Secure PRNG from \"@noble/hashes\". Uses crypto.getRandomValues, which defers to OS.\n */\nexport const randomBytes = nobleRandomBytes as (bytesLength?: number) => Uint8Array;\n\nexport * from \"./hashes\";\nexport * from \"./types\";\nexport * from \"./coders\";\n","import { blake2b } from \"@noble/hashes/blake2b\";\nimport { sha256 as nobleSha256 } from \"@noble/hashes/sha256\";\nimport { BytesInput } from \"./types\";\n\nexport const blake2b256 = (message: BytesInput) => blake2b(message, { dkLen: 32 });\nexport const sha256 = nobleSha256 as (message: BytesInput) => Uint8Array;\n","import {\n  base58check as base58checkCoder,\n  base58 as base58Coder,\n  base64 as base64Coder\n} from \"@scure/base\";\nimport { sha256 } from \"../hashes\";\nimport { BytesCoder } from \"../types\";\n\nexport const base58check = base58checkCoder(sha256);\nexport const base58 = base58Coder as BytesCoder;\nexport const base64 = base64Coder as BytesCoder;\n\n// export const base64utf8: BytesCoder =  {\n//   encode: (data: Uint8Array) => utf8.decode()\n// }\n\nexport { hex } from \"./hex\";\nexport { utf8 } from \"./utf8\";\n","import { assert, assertInstanceOf, assertTypeOf } from \"@fleet-sdk/common\";\nimport { BytesCoder } from \"../types\";\n\nconst HEXES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, \"0\"));\n\nfunction bytesToHex(bytes: Uint8Array): string {\n  assertInstanceOf(bytes, Uint8Array);\n\n  let hex = \"\";\n  for (let i = 0; i < bytes.length; i++) {\n    hex += HEXES[bytes[i]];\n  }\n\n  return hex;\n}\n\nfunction hexToBytes(hex: string): Uint8Array {\n  assertTypeOf(hex, \"string\");\n  assert(hex.length % 2 === 0, \"Invalid hex padding.\");\n\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < bytes.length; i++) {\n    const j = i * 2;\n    const hexByte = hex.slice(j, j + 2);\n    const byte = parseInt(hexByte, 16);\n    assert(!isNaN(byte) && byte >= 0, \"Invalid byte sequence.\");\n\n    bytes[i] = byte;\n  }\n\n  return bytes;\n}\n\nexport const hex: BytesCoder = {\n  encode: bytesToHex,\n  decode: hexToBytes\n};\n","import { assertInstanceOf, assertTypeOf } from \"@fleet-sdk/common\";\nimport { BytesCoder } from \"../types\";\n\nfunction bytesToUtf8(bytes: Uint8Array): string {\n  assertInstanceOf(bytes, Uint8Array);\n\n  return new TextDecoder().decode(bytes);\n}\n\nfunction utf8ToBytes(str: string): Uint8Array {\n  assertTypeOf(str, \"string\");\n\n  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n\nexport const utf8: BytesCoder = {\n  encode: bytesToUtf8,\n  decode: utf8ToBytes\n};\n"]}

package/dist/index.mjs

@@ -0,0 +1,59 @@
+import { randomBytes as randomBytes$1 } from '@noble/hashes/utils';
+import { blake2b } from '@noble/hashes/blake2b';
+import { sha256 as sha256$1 } from '@noble/hashes/sha256';
+import { base58check as base58check$1, base58 as base58$1, base64 as base64$1 } from '@scure/base';
+import { assertInstanceOf, assertTypeOf, assert } from '@fleet-sdk/common';
+
+// src/index.ts
+var blake2b256 = (message) => blake2b(message, { dkLen: 32 });
+var sha256 = sha256$1;
+var HEXES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  assertInstanceOf(bytes, Uint8Array);
+  let hex2 = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex2 += HEXES[bytes[i]];
+  }
+  return hex2;
+}
+function hexToBytes(hex2) {
+  assertTypeOf(hex2, "string");
+  assert(hex2.length % 2 === 0, "Invalid hex padding.");
+  const bytes = new Uint8Array(hex2.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    const j = i * 2;
+    const hexByte = hex2.slice(j, j + 2);
+    const byte = parseInt(hexByte, 16);
+    assert(!isNaN(byte) && byte >= 0, "Invalid byte sequence.");
+    bytes[i] = byte;
+  }
+  return bytes;
+}
+var hex = {
+  encode: bytesToHex,
+  decode: hexToBytes
+};
+function bytesToUtf8(bytes) {
+  assertInstanceOf(bytes, Uint8Array);
+  return new TextDecoder().decode(bytes);
+}
+function utf8ToBytes(str) {
+  assertTypeOf(str, "string");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+var utf8 = {
+  encode: bytesToUtf8,
+  decode: utf8ToBytes
+};
+
+// src/coders/index.ts
+var base58check = base58check$1(sha256);
+var base58 = base58$1;
+var base64 = base64$1;
+
+// src/index.ts
+var randomBytes = randomBytes$1;
+
+export { base58, base58check, base64, blake2b256, hex, randomBytes, sha256, utf8 };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/hashes.ts","../src/coders/index.ts","../src/coders/hex.ts","../src/coders/utf8.ts"],"names":["hex","assertInstanceOf","assertTypeOf"],"mappings":";AAAA,SAAS,eAAe,wBAAwB;;;ACAhD,SAAS,eAAe;AACxB,SAAS,UAAU,mBAAmB;AAG/B,IAAM,aAAa,CAAC,YAAwB,QAAQ,SAAS,EAAE,OAAO,GAAG,CAAC;AAC1E,IAAM,SAAS;;;ACLtB;AAAA,EACE,eAAe;AAAA,EACf,UAAU;AAAA,EACV,UAAU;AAAA,OACL;;;ACJP,SAAS,QAAQ,kBAAkB,oBAAoB;AAGvD,IAAM,QAAQ,MAAM,KAAK,EAAE,QAAQ,IAAI,GAAG,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAEnF,SAAS,WAAW,OAA2B;AAC7C,mBAAiB,OAAO,UAAU;AAElC,MAAIA,OAAM;AACV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,IAAAA,QAAO,MAAM,MAAM,CAAC,CAAC;AAAA,EACvB;AAEA,SAAOA;AACT;AAEA,SAAS,WAAWA,MAAyB;AAC3C,eAAaA,MAAK,QAAQ;AAC1B,SAAOA,KAAI,SAAS,MAAM,GAAG,sBAAsB;AAEnD,QAAM,QAAQ,IAAI,WAAWA,KAAI,SAAS,CAAC;AAC3C,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAM,IAAI,IAAI;AACd,UAAM,UAAUA,KAAI,MAAM,GAAG,IAAI,CAAC;AAClC,UAAM,OAAO,SAAS,SAAS,EAAE;AACjC,WAAO,CAAC,MAAM,IAAI,KAAK,QAAQ,GAAG,wBAAwB;AAE1D,UAAM,CAAC,IAAI;AAAA,EACb;AAEA,SAAO;AACT;AAEO,IAAM,MAAkB;AAAA,EAC7B,QAAQ;AAAA,EACR,QAAQ;AACV;;;ACpCA,SAAS,oBAAAC,mBAAkB,gBAAAC,qBAAoB;AAG/C,SAAS,YAAY,OAA2B;AAC9C,EAAAD,kBAAiB,OAAO,UAAU;AAElC,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK;AACvC;AAEA,SAAS,YAAY,KAAyB;AAC5C,EAAAC,cAAa,KAAK,QAAQ;AAE1B,SAAO,IAAI,WAAW,IAAI,YAAY,EAAE,OAAO,GAAG,CAAC;AACrD;AAEO,IAAM,OAAmB;AAAA,EAC9B,QAAQ;AAAA,EACR,QAAQ;AACV;;;AFVO,IAAM,cAAc,iBAAiB,MAAM;AAC3C,IAAM,SAAS;AACf,IAAM,SAAS;;;AFLf,IAAM,cAAc","sourcesContent":["import { randomBytes as nobleRandomBytes } from \"@noble/hashes/utils\";\n\n/**\n * Secure PRNG from \"@noble/hashes\". Uses crypto.getRandomValues, which defers to OS.\n */\nexport const randomBytes = nobleRandomBytes as (bytesLength?: number) => Uint8Array;\n\nexport * from \"./hashes\";\nexport * from \"./types\";\nexport * from \"./coders\";\n","import { blake2b } from \"@noble/hashes/blake2b\";\nimport { sha256 as nobleSha256 } from \"@noble/hashes/sha256\";\nimport { BytesInput } from \"./types\";\n\nexport const blake2b256 = (message: BytesInput) => blake2b(message, { dkLen: 32 });\nexport const sha256 = nobleSha256 as (message: BytesInput) => Uint8Array;\n","import {\n  base58check as base58checkCoder,\n  base58 as base58Coder,\n  base64 as base64Coder\n} from \"@scure/base\";\nimport { sha256 } from \"../hashes\";\nimport { BytesCoder } from \"../types\";\n\nexport const base58check = base58checkCoder(sha256);\nexport const base58 = base58Coder as BytesCoder;\nexport const base64 = base64Coder as BytesCoder;\n\n// export const base64utf8: BytesCoder =  {\n//   encode: (data: Uint8Array) => utf8.decode()\n// }\n\nexport { hex } from \"./hex\";\nexport { utf8 } from \"./utf8\";\n","import { assert, assertInstanceOf, assertTypeOf } from \"@fleet-sdk/common\";\nimport { BytesCoder } from \"../types\";\n\nconst HEXES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, \"0\"));\n\nfunction bytesToHex(bytes: Uint8Array): string {\n  assertInstanceOf(bytes, Uint8Array);\n\n  let hex = \"\";\n  for (let i = 0; i < bytes.length; i++) {\n    hex += HEXES[bytes[i]];\n  }\n\n  return hex;\n}\n\nfunction hexToBytes(hex: string): Uint8Array {\n  assertTypeOf(hex, \"string\");\n  assert(hex.length % 2 === 0, \"Invalid hex padding.\");\n\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < bytes.length; i++) {\n    const j = i * 2;\n    const hexByte = hex.slice(j, j + 2);\n    const byte = parseInt(hexByte, 16);\n    assert(!isNaN(byte) && byte >= 0, \"Invalid byte sequence.\");\n\n    bytes[i] = byte;\n  }\n\n  return bytes;\n}\n\nexport const hex: BytesCoder = {\n  encode: bytesToHex,\n  decode: hexToBytes\n};\n","import { assertInstanceOf, assertTypeOf } from \"@fleet-sdk/common\";\nimport { BytesCoder } from \"../types\";\n\nfunction bytesToUtf8(bytes: Uint8Array): string {\n  assertInstanceOf(bytes, Uint8Array);\n\n  return new TextDecoder().decode(bytes);\n}\n\nfunction utf8ToBytes(str: string): Uint8Array {\n  assertTypeOf(str, \"string\");\n\n  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n\nexport const utf8: BytesCoder = {\n  encode: bytesToUtf8,\n  decode: utf8ToBytes\n};\n"]}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@fleet-sdk/crypto",
+  "version": "0.2.0",
+  "description": "Ergo blockchain crypto primitives.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "require": "./dist/index.js",
+    "import": "./dist/index.mjs"
+  },
+  "sideEffects": true,
+  "repository": "fleet-sdk/fleet",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [
+    "ergo",
+    "blockchain",
+    "crypto"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.3.1",
+    "@scure/base": "^1.1.1",
+    "@fleet-sdk/common": "^0.2.0"
+  },
+  "files": [
+    "src",
+    "dist",
+    "!**/*.spec.*",
+    "!**/*.json",
+    "!tests",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup"
+  }
+}

package/src/coders/hex.bench.ts

@@ -0,0 +1,15 @@
+import { hex as scureHex } from "@scure/base";
+import { bench, describe } from "vitest";
+import { hex as fleetHex } from "./hex";
+
+describe("HEX <> Bytes decoding", () => {
+  const validHex = "0008cd026dc059d64a50d0dbf07755c2c4a4e557e3df8afa7141868b3ab200643d437ee7";
+
+  bench("@scure implementation", () => {
+    scureHex.encode(scureHex.decode(validHex));
+  });
+
+  bench("Fleet implementation", () => {
+    fleetHex.encode(fleetHex.decode(validHex));
+  });
+});

package/src/coders/hex.ts

@@ -0,0 +1,37 @@
+import { assert, assertInstanceOf, assertTypeOf } from "@fleet-sdk/common";
+import { BytesCoder } from "../types";
+
+const HEXES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+
+function bytesToHex(bytes: Uint8Array): string {
+  assertInstanceOf(bytes, Uint8Array);
+
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += HEXES[bytes[i]];
+  }
+
+  return hex;
+}
+
+function hexToBytes(hex: string): Uint8Array {
+  assertTypeOf(hex, "string");
+  assert(hex.length % 2 === 0, "Invalid hex padding.");
+
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    const j = i * 2;
+    const hexByte = hex.slice(j, j + 2);
+    const byte = parseInt(hexByte, 16);
+    assert(!isNaN(byte) && byte >= 0, "Invalid byte sequence.");
+
+    bytes[i] = byte;
+  }
+
+  return bytes;
+}
+
+export const hex: BytesCoder = {
+  encode: bytesToHex,
+  decode: hexToBytes
+};

package/src/coders/index.ts

@@ -0,0 +1,18 @@
+import {
+  base58check as base58checkCoder,
+  base58 as base58Coder,
+  base64 as base64Coder
+} from "@scure/base";
+import { sha256 } from "../hashes";
+import { BytesCoder } from "../types";
+
+export const base58check = base58checkCoder(sha256);
+export const base58 = base58Coder as BytesCoder;
+export const base64 = base64Coder as BytesCoder;
+
+// export const base64utf8: BytesCoder =  {
+//   encode: (data: Uint8Array) => utf8.decode()
+// }
+
+export { hex } from "./hex";
+export { utf8 } from "./utf8";

package/src/coders/utf8.ts

@@ -0,0 +1,19 @@
+import { assertInstanceOf, assertTypeOf } from "@fleet-sdk/common";
+import { BytesCoder } from "../types";
+
+function bytesToUtf8(bytes: Uint8Array): string {
+  assertInstanceOf(bytes, Uint8Array);
+
+  return new TextDecoder().decode(bytes);
+}
+
+function utf8ToBytes(str: string): Uint8Array {
+  assertTypeOf(str, "string");
+
+  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+
+export const utf8: BytesCoder = {
+  encode: bytesToUtf8,
+  decode: utf8ToBytes
+};

package/src/hashes.ts

@@ -0,0 +1,6 @@
+import { blake2b } from "@noble/hashes/blake2b";
+import { sha256 as nobleSha256 } from "@noble/hashes/sha256";
+import { BytesInput } from "./types";
+
+export const blake2b256 = (message: BytesInput) => blake2b(message, { dkLen: 32 });
+export const sha256 = nobleSha256 as (message: BytesInput) => Uint8Array;

package/src/index.ts

@@ -0,0 +1,10 @@
+import { randomBytes as nobleRandomBytes } from "@noble/hashes/utils";
+
+/**
+ * Secure PRNG from "@noble/hashes". Uses crypto.getRandomValues, which defers to OS.
+ */
+export const randomBytes = nobleRandomBytes as (bytesLength?: number) => Uint8Array;
+
+export * from "./hashes";
+export * from "./types";
+export * from "./coders";

package/src/types.ts

@@ -0,0 +1,17 @@
+export type BytesInput = Uint8Array | string;
+
+export interface Coder<F, T> {
+  encode(from: F): T;
+  decode(to: T): F;
+}
+
+export interface BytesCoder extends Coder<Uint8Array, string> {
+  /**
+   * Encodes an array of bytes to a string
+   */
+  encode: (data: Uint8Array) => string;
+  /**
+   * Decodes a string to an array of bytes
+   */
+  decode: (str: string) => Uint8Array;
+}