@gibme/base58 1.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018-2022 Brandon Lehmann
+
+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,13 @@
+# Simple Base58 Library
+
+```typescript
+import Base58 from '@gibme/base58';
+
+const encoded = Base58.encode('02c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cfeb05f9d2');
+
+console.log(encoded);
+
+const decoded = Base58.decode(encoded);
+
+console.log(decoded.toString('hex'));
+```

package/dist/base58.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { Base58Handler } from './types';
+import CryptoNoteBase58 from './cryptonote_base58';
+export default class Base58 implements Base58Handler {
+    static get CryptoNote(): CryptoNoteBase58;
+    /**
+     * Decodes the Base58 encoded string into a Buffer
+     *
+     * @param encoded
+     */
+    static decode(encoded: string): Buffer;
+    /**
+     * Encodes the data into Base58
+     *
+     * @param data
+     */
+    static encode(data: string | Uint8Array | Buffer): string;
+    /**
+     * Decodes the Base58 encoded string into a Buffer
+     *
+     * @param encoded
+     */
+    decode(encoded: string): Buffer;
+    /**
+     * Encodes the data into Base58
+     *
+     * @param data
+     */
+    encode(data: string | Uint8Array | Buffer): string;
+}

package/dist/base58.js

@@ -0,0 +1,55 @@
+"use strict";
+// Copyright (c) 2018-2022 Brandon Lehmann
+//
+// Please see the included LICENSE file for more information.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cryptonote_base58_1 = __importDefault(require("./cryptonote_base58"));
+/** @ignore */
+const { base58_to_binary, binary_to_base58 } = require('base58-js');
+class Base58 {
+    static get CryptoNote() {
+        return new cryptonote_base58_1.default();
+    }
+    /**
+     * Decodes the Base58 encoded string into a Buffer
+     *
+     * @param encoded
+     */
+    static decode(encoded) {
+        return Buffer.from(base58_to_binary(encoded));
+    }
+    /**
+     * Encodes the data into Base58
+     *
+     * @param data
+     */
+    static encode(data) {
+        if (data instanceof Buffer) {
+            data = data.valueOf();
+        }
+        else if (typeof data === 'string') {
+            data = Buffer.from(data, 'hex').valueOf();
+        }
+        return binary_to_base58(data);
+    }
+    /**
+     * Decodes the Base58 encoded string into a Buffer
+     *
+     * @param encoded
+     */
+    decode(encoded) {
+        return Base58.decode(encoded);
+    }
+    /**
+     * Encodes the data into Base58
+     *
+     * @param data
+     */
+    encode(data) {
+        return Base58.encode(data);
+    }
+}
+exports.default = Base58;

package/dist/cryptonote_base58.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { Base58Handler } from './types';
+export default class CryptoNoteBase58 implements Base58Handler {
+    /**
+     * Decodes the Base58 encoded string into a Buffer
+     *
+     * @param encoded
+     */
+    static decode(encoded: string): Buffer;
+    /**
+     * Encodes the data into Base58
+     *
+     * @param data
+     */
+    static encode(data: string | Uint8Array | Buffer): string;
+    /**
+     * Decodes a Base58 block
+     *
+     * @param data
+     * @param buffer
+     * @param index
+     * @private
+     */
+    private static decodeBlock;
+    /**
+     * Encodes the data into a block for Base58
+     *
+     * @param data
+     * @param buffer
+     * @param index
+     * @private
+     */
+    private static encodeBlock;
+    /**
+     * Decodes the Base58 encoded string into a Buffer
+     *
+     * @param encoded
+     */
+    decode(encoded: string): Buffer;
+    /**
+     * Encodes the data into Base58
+     *
+     * @param data
+     */
+    encode(data: string | Uint8Array | Buffer): string;
+}

package/dist/cryptonote_base58.js

@@ -0,0 +1,161 @@
+"use strict";
+// Copyright (c) 2018-2022 Brandon Lehmann
+//
+// Please see the included LICENSE file for more information.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bytepack_1 = require("@gibme/bytepack");
+const helpers_1 = __importDefault(require("./helpers"));
+/** @ignore */
+const ALPHABET = (() => {
+    const str = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+    return str.split('')
+        .map(char => char.charCodeAt(0));
+})();
+/** @ignore */
+const ENCODED_BLOCK_SIZES = [0, 2, 3, 5, 6, 7, 9, 10, 11];
+/** @ignore */
+const FULL_BLOCK_SIZE = 8;
+/** @ignore */
+const FULL_ENCODED_BLOCK_SIZE = 11;
+/** @ignore */
+const UINT64_MAX = (0, bytepack_1.BytePackBigInt)(2).pow(64);
+class CryptoNoteBase58 {
+    /**
+     * Decodes the Base58 encoded string into a Buffer
+     *
+     * @param encoded
+     */
+    static decode(encoded) {
+        const enc = helpers_1.default.stringToBin(encoded);
+        if (enc.length === 0) {
+            return Buffer.alloc(0);
+        }
+        const fullBlockCount = Math.floor(enc.length / FULL_ENCODED_BLOCK_SIZE);
+        const lastBlockSize = enc.length % FULL_ENCODED_BLOCK_SIZE;
+        const lastBlockDecodedSize = ENCODED_BLOCK_SIZES.indexOf(lastBlockSize);
+        if (lastBlockDecodedSize < 0) {
+            throw new Error('Invalid encoded length');
+        }
+        const dataSize = fullBlockCount * FULL_BLOCK_SIZE + lastBlockDecodedSize;
+        let result = new Uint8Array(dataSize);
+        for (let i = 0; i < fullBlockCount; i++) {
+            result = CryptoNoteBase58.decodeBlock(enc.subarray(i * FULL_ENCODED_BLOCK_SIZE, i * FULL_ENCODED_BLOCK_SIZE + FULL_ENCODED_BLOCK_SIZE), result, i * FULL_BLOCK_SIZE);
+        }
+        if (lastBlockSize > 0) {
+            result = CryptoNoteBase58.decodeBlock(enc.subarray(fullBlockCount * FULL_ENCODED_BLOCK_SIZE, fullBlockCount * FULL_ENCODED_BLOCK_SIZE + lastBlockSize), result, fullBlockCount * FULL_BLOCK_SIZE);
+        }
+        return Buffer.from(result);
+    }
+    /**
+     * Encodes the data into Base58
+     *
+     * @param data
+     */
+    static encode(data) {
+        if (data instanceof Buffer) {
+            data = data.toString('hex');
+        }
+        else if (data instanceof Uint8Array) {
+            data = Buffer.from(data).toString('hex');
+        }
+        const _data = helpers_1.default.hexToBin(data);
+        if (_data.length === 0) {
+            return '';
+        }
+        const fullBlockCount = Math.floor(_data.length / FULL_BLOCK_SIZE);
+        const lastBlockSize = _data.length % FULL_BLOCK_SIZE;
+        const resSize = fullBlockCount * FULL_ENCODED_BLOCK_SIZE + ENCODED_BLOCK_SIZES[lastBlockSize];
+        let result = new Uint8Array(resSize);
+        let i;
+        for (i = 0; i < resSize; ++i) {
+            result[i] = ALPHABET[0];
+        }
+        for (i = 0; i < fullBlockCount; i++) {
+            result = CryptoNoteBase58.encodeBlock(_data.subarray(i * FULL_BLOCK_SIZE, i * FULL_BLOCK_SIZE + FULL_BLOCK_SIZE), result, i *
+                FULL_ENCODED_BLOCK_SIZE);
+        }
+        if (lastBlockSize > 0) {
+            result = CryptoNoteBase58.encodeBlock(_data.subarray(fullBlockCount * FULL_BLOCK_SIZE, fullBlockCount * FULL_BLOCK_SIZE + lastBlockSize), result, fullBlockCount * FULL_ENCODED_BLOCK_SIZE);
+        }
+        return helpers_1.default.binToString(result);
+    }
+    /**
+     * Decodes a Base58 block
+     *
+     * @param data
+     * @param buffer
+     * @param index
+     * @private
+     */
+    static decodeBlock(data, buffer, index) {
+        if (data.length < 1 || data.length > FULL_ENCODED_BLOCK_SIZE) {
+            throw new Error('Invalid block length: ' + data.length);
+        }
+        const resSize = ENCODED_BLOCK_SIZES.indexOf(data.length);
+        if (resSize <= 0) {
+            throw new Error('Invalid block size');
+        }
+        let resNum = bytepack_1.BytePackBigInt.zero;
+        let order = bytepack_1.BytePackBigInt.one;
+        for (let i = data.length - 1; i >= 0; i--) {
+            const digit = ALPHABET.indexOf(data[i]);
+            if (digit < 0) {
+                throw new Error('Invalid symbol');
+            }
+            const product = order.multiply(digit).add(resNum);
+            if (product.compare(UINT64_MAX) === 1) {
+                throw new Error('Overflow');
+            }
+            resNum = product;
+            order = order.multiply(ALPHABET.length);
+        }
+        if (resSize < FULL_BLOCK_SIZE && ((0, bytepack_1.BytePackBigInt)(2).pow(8 * resSize).compare(resNum) <= 0)) {
+            throw new Error('Overflow 2');
+        }
+        buffer.set(helpers_1.default.uint64To8be(resNum, resSize), index);
+        return buffer;
+    }
+    /**
+     * Encodes the data into a block for Base58
+     *
+     * @param data
+     * @param buffer
+     * @param index
+     * @private
+     */
+    static encodeBlock(data, buffer, index) {
+        if (data.length < 1 || data.length > FULL_ENCODED_BLOCK_SIZE) {
+            throw new Error('Invalid block length: ' + data.length);
+        }
+        let num = helpers_1.default.uint8BeTo64(data);
+        let i = ENCODED_BLOCK_SIZES[data.length] - 1;
+        while (num.compare(0) === 1) {
+            const div = num.divmod(ALPHABET.length);
+            const remainder = div.remainder;
+            num = div.quotient;
+            buffer[index + i] = ALPHABET[remainder.toJSNumber()];
+            i--;
+        }
+        return buffer;
+    }
+    /**
+     * Decodes the Base58 encoded string into a Buffer
+     *
+     * @param encoded
+     */
+    decode(encoded) {
+        return CryptoNoteBase58.decode(encoded);
+    }
+    /**
+     * Encodes the data into Base58
+     *
+     * @param data
+     */
+    encode(data) {
+        return CryptoNoteBase58.encode(data);
+    }
+}
+exports.default = CryptoNoteBase58;

package/dist/helpers.d.ts

@@ -0,0 +1,14 @@
+import { BigInteger } from '@gibme/bytepack';
+/** @ignore */
+export default class Helpers {
+    /** @ignore */
+    static binToString(binary: Uint8Array): string;
+    /** @ignore */
+    static hexToBin(hex: string): Uint8Array;
+    /** @ignore */
+    static stringToBin(str: string): Uint8Array;
+    /** @ignore */
+    static uint8BeTo64(data: Uint8Array): BigInteger;
+    /** @ignore */
+    static uint64To8be(num: BigInteger, size: number): Uint8Array;
+}

package/dist/helpers.js

@@ -0,0 +1,88 @@
+"use strict";
+// Copyright (c) 2018-2022 Brandon Lehmann
+//
+// Please see the included LICENSE file for more information.
+Object.defineProperty(exports, "__esModule", { value: true });
+const bytepack_1 = require("@gibme/bytepack");
+/** @ignore */
+class Helpers {
+    /** @ignore */
+    static binToString(binary) {
+        const result = [];
+        binary.forEach(bit => {
+            result.push(String.fromCharCode(bit));
+        });
+        return result.join('');
+    }
+    /** @ignore */
+    static hexToBin(hex) {
+        if (hex.length % 2 !== 0) {
+            throw new Error('hex string has invalid length!');
+        }
+        const result = new Uint8Array(hex.length / 2);
+        for (let i = 0; i < hex.length / 2; ++i) {
+            result[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+        }
+        return result;
+    }
+    /** @ignore */
+    static stringToBin(str) {
+        const result = new Uint8Array(str.length);
+        for (let i = 0; i < str.length; i++) {
+            result[i] = str.charCodeAt(i);
+        }
+        return result;
+    }
+    /** @ignore */
+    static uint8BeTo64(data) {
+        if (data.length < 1 || data.length > 8) {
+            throw new Error('Invalid input length');
+        }
+        let res = bytepack_1.BytePackBigInt.zero;
+        const twoPow8 = (0, bytepack_1.BytePackBigInt)(2).pow(8);
+        let i = 0;
+        switch (9 - data.length) {
+            case 1:
+                res = res.add(data[i++]);
+            /* falls through */
+            case 2:
+                res = res.multiply(twoPow8).add(data[i++]);
+            /* falls through */
+            case 3:
+                res = res.multiply(twoPow8).add(data[i++]);
+            /* falls through */
+            case 4:
+                res = res.multiply(twoPow8).add(data[i++]);
+            /* falls through */
+            case 5:
+                res = res.multiply(twoPow8).add(data[i++]);
+            /* falls through */
+            case 6:
+                res = res.multiply(twoPow8).add(data[i++]);
+            /* falls through */
+            case 7:
+                res = res.multiply(twoPow8).add(data[i++]);
+            /* falls through */
+            case 8:
+                res = res.multiply(twoPow8).add(data[i++]);
+                break;
+            default:
+                throw new Error('Impossible condition');
+        }
+        return res;
+    }
+    /** @ignore */
+    static uint64To8be(num, size) {
+        const res = new Uint8Array(size);
+        if (size < 1 || size > 8) {
+            throw new Error('Invalid input length');
+        }
+        const twopow8 = (0, bytepack_1.BytePackBigInt)(2).pow(8);
+        for (let i = size - 1; i >= 0; i--) {
+            res[i] = num.remainder(twopow8).toJSNumber();
+            num = num.divide(twopow8);
+        }
+        return res;
+    }
+}
+exports.default = Helpers;

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/** @ignore */
+export interface Base58Handler {
+    decode: (encoded: string) => Buffer;
+    encode: (decoded: string | Uint8Array | Buffer) => string;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+// Copyright (c) 2018-2022 Brandon Lehmann
+//
+// Please see the included LICENSE file for more information.
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@gibme/base58",
+  "version": "1.0.0",
+  "description": "A simple base58 helper",
+  "main": "dist/base58.js",
+  "types": "dist/base58.d.ts",
+  "files": [
+    "dist/*"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "./node_modules/.bin/tsc",
+    "test": "yarn test:style && yarn test:mocha",
+    "test:style": "yarn style",
+    "test:mocha": "./node_modules/.bin/mocha --exit --timeout 30000 --require ts-node/register test/test.ts",
+    "style": "./node_modules/.bin/eslint src/**/*.ts test/**/*.ts",
+    "fix-style": "./node_modules/.bin/eslint --fix src/**/*.ts test/**/*.ts",
+    "fix:style": "yarn fix-style",
+    "prepublishOnly": "yarn build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gibme-npm/base58.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gibme-npm/base58/issues"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "engineStrict": true,
+  "author": {
+    "name": "Brandon Lehmann",
+    "email": "brandonlehmann@gmail.com"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.0",
+    "@types/node": "^18.11.9",
+    "@typescript-eslint/eslint-plugin": "^5.42.0",
+    "@typescript-eslint/parser": "^5.42.0",
+    "eslint": "^8.26.0",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.4.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "mocha": "^10.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.8.4"
+  },
+  "dependencies": {
+    "@gibme/bytepack": "^1.0.0",
+    "base58-js": "^1.0.5"
+  }
+}