@interop/bnid 6.0.0

package/CHANGELOG.md

@@ -0,0 +1,88 @@
+# bnid ChangeLog
+
+## 6.0.0 - 2026-06-08
+
+### Changed
+
+- **BREAKING**: Fork to `@interop/bnid`.
+- **BREAKING**: Replace `base-x` dependency with `@scure/base` (`base58`).
+- **BREAKING**: React Native now uses the Web Crypto `crypto.getRandomValues()`
+  API instead of `react-native-securerandom`. Consumers must install the
+  `react-native-get-random-values` polyfill (declared as an optional
+  `peerDependency`) and import it once at their app entry. See the README.
+
+### Removed
+
+- Remove `react-native-securerandom` dependency.
+
+## 5.0.0 - 2026-05-24
+
+### Changed
+
+- Bump `base-x` dependency to latest (v5.0.0).
+
+## 4.0.0 - 2025-05-16
+
+### Changed
+
+- **BREAKING**: Convert to Typescript (still also exports Javascript).
+
+## 3.0.1 - 2024-01-23
+
+### Changed
+
+- Replace `@digitalcredentials/base58-universal` with `base-x` dependency.
+
+## 3.0.0 - 2024-01-23
+
+### Removed
+
+- **BREAKING**: Move command line client into
+  [`bnid-cli`](https://github.com/digitalbazaar/bnid-cli). The primary reason is
+  to reduce `bnid` dependencies.
+
+## 2.1.2 - 2022-01-28
+
+### Changed
+
+- Fix Rollup config for React Native.
+
+## 2.1.1 - 2022-01-26
+
+### Changed
+
+- Remove runtime `esm` transpiler usage, add support for Typescript and React
+  Native.
+
+## 2.1.0 - 2021-11-18
+
+### Added
+
+- Add `generateSecretKeySeed()` and `decodeSecretKeySeed()`.
+- Add `multihash` boolean parameter to IdEncoder and IdDecoder. A
+  multihash-encoded identifier will use the `identity` multicodec tag (`0x00`).
+  Using multihash has the advantage of including the size of the identifier
+  which can then be verified to have not changed when decoding.
+- Add `expectedSize` optional parameter to IdDecoder for multihash-encoded ID
+  bytes. (default: 32).
+
+## 2.0.0 - 2020-05-22
+
+### Changed
+
+- **BREAKING**: `multibase` now defaults to `true` for all APIs.
+- Remove travis-ci testing in favor of GitHub Actions.
+
+### Added
+
+- Command line tool `bnid`.
+- `min/maxEncodedIdBytes` utiltiies. Useful for variable length encodings such
+  as `base58`.
+
+## 1.0.0 - 2020-05-07
+
+### Added
+
+- Add core files.
+
+- See git history for changes previous to this release.

package/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2020, Digital Bazaar, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,329 @@
+# JS/TS Base-N Id Generator _(@interop/bnid)_
+
+[![CI](https://github.com/interop-alliance/bnid/actions/workflows/ci.yml/badge.svg)](https://github.com/interop-alliance/bnid/actions/workflows/ci.yml)
+[![NPM Version](https://img.shields.io/npm/v/@interop/bnid.svg)](https://npm.im/@interop/bnid)
+
+> A Typescript/JavaScript library for Web browsers, React Native, and Node.js
+> apps to generate random ids and encode and decode them using various base-N
+> encodings.
+
+## Table of Contents
+
+- [Background](#background)
+- [Install](#install)
+- [Usage](#usage)
+- [API](#api)
+- [CLI](#cli)
+- [Contribute](#contribute)
+- [Commercial Support](#commercial-support)
+- [License](#license)
+
+## Background
+
+This library provides tools for Web browsers, React Native, and Node.js apps to
+generate random ids and encode and decode them in various base-N encodings.
+
+## Install
+
+### NPM
+
+```
+npm install @interop/bnid
+```
+
+### Git
+
+To install locally (for development):
+
+```
+git clone https://github.com/interop-alliance/bnid.git
+cd bnid
+pnpm install
+```
+
+### React Native
+
+This library is isomorphic and runs on React Native, with one environment
+requirement: it uses the Web Crypto `crypto.getRandomValues()` API to generate
+random id material, which React Native does not provide natively. Consumers must
+install the [`react-native-get-random-values`][] polyfill and import it
+**once**, before any `@interop/bnid` code runs (typically at the very
+top of your app entry, e.g. `index.js`):
+
+```sh
+npm install react-native-get-random-values
+```
+
+```js
+// must be the first import in your app entry
+import 'react-native-get-random-values'
+```
+
+It is declared as an optional `peerDependency`.
+
+[`react-native-get-random-values`]:
+  https://github.com/LinusU/react-native-get-random-values
+
+## Usage
+
+The interface follows the [TextEncoder][]/[TextDecoder][] interfaces and
+provides [IdEncoder](#idencoder) and [IdDecoder](#iddecoder) classes. Instances
+can be configured with reusable encodings and other parameters. The encoder
+operates on a `Uint8Array` of input bytes. A [IdGenerator](#idgenerator) class
+is provided that can be used to generate random ids with selectable bit lengths,
+but any id data can be used.
+
+The encoder and decoder support various encodings and options:
+
+- `base16`/`hex`, `base16upper`: The simple [Base16][].
+- `base58`/`base58btc`: The [Base58][] Bitcoin alphabet.
+- Optional [multibase][] type prefix.
+- Fixed bit length. This is useful to ensure the output id length is constant
+  even when the id starts with an arbitrary number of zeros.
+
+The fixed length options can be important when using encodings that have
+variable length outputs depending on the input length. `base58btc` is and
+example. When encoding, the `fixedLength` or `fixedBitLength` options can be
+used to force the output to be a constant length. When decoding, the
+`fixedBitLength` options can be used to ensure a constant length array of bytes.
+
+### Generate an ID
+
+To generate a default [Base58][], 128 bit, non-fixed-length, multibase encoded
+id:
+
+```js
+import { generateId } from '@interop/bnid'
+
+const id = await generateId()
+```
+
+To generate a [Base58][], 128 bit, fixed-length id:
+
+```js
+import { generateId } from '@interop/bnid'
+
+const id = await generateId({
+  fixedLength: true
+})
+```
+
+### Reusable Components
+
+Some setup overhead can be avoided by using the component `IdGenerator` and
+`IdEncoder` classes.
+
+```js
+import { IdGenerator, IdEncoder } from '@interop/bnid'
+
+// 64 bit random id generator
+const generator = new IdGenerator({
+  bitLength: 64
+})
+// base58, multibase, fixed-length encoder
+const encoder = new IdEncoder({
+  encoding: 'base58',
+  fixedLength: true,
+  multibase: true
+})
+const id1 = encoder.encode(await generator.generate())
+const id2 = encoder.encode(await generator.generate())
+```
+
+### Reusable Components
+
+Some setup overhead can be avoided by using the component `IdGenerator` and
+`IdEncoder` classes.
+
+```js
+import { IdGenerator, IdEncoder, IdDecoder } from '@interop/bnid'
+
+// 64 bit random id generator
+const generator = new IdGenerator({
+  bitLength: 64
+})
+// base58, multibase, fixed-length encoder
+const encoder = new IdEncoder({
+  encoding: 'base58',
+  fixedLength: true,
+  multibase: true
+})
+const id1 = encoder.encode(await generator.generate())
+// => "z..."
+const id2 = encoder.encode(await generator.generate())
+// => "z..."
+
+const decoder = new IdDecoder({
+  fixedBitLength: 64,
+  multibase: true
+})
+const id1bytes = decoder.decode(id1)
+// => Uint8Array([...])
+const id2bytes = decoder.decode(id2)
+// => Uint8Array([...])
+```
+
+## API
+
+### `generateId(options)`
+
+Generate a string id. See `IdGenerator` and `IdEncoder` for options.
+
+### `decodeId(options)`
+
+Decode the options.id string. See `IdDecoder` for other options.
+
+### `IdGenerator`
+
+An `IdGenerator` generates an array of id bytes.
+
+#### `constuctor(options)` / `constructor(bitLength)`
+
+Options:
+
+- `bitLength`: Number of id bits. Must be multiple of 8. (default: 128)
+
+#### `generate()`
+
+Generate random id bytes.
+
+### `IdEncoder`
+
+An `IdEncoder` encodes an array of id bytes into a specific encoding.
+
+#### `constuctor(options)`
+
+Options:
+
+- `encoding`: Output encoding. (default: `base58`)
+  - `base16`/`base16upper`/`hex`: base16 encoded string.
+  - `base58`/`base58btc`: base58btc encoded string.
+- `fixedLength`: `true` to ensure fixed output length. (default: false)
+- `fixedBitLength`: fixed output bit length or 0 to base on input byte size.
+  (default: 0)
+- `multibase`: `true` to use multibase encoding. (default: `true`)
+- `multihash`: `true` to use multihash encoding. (default: `false`)
+
+#### `encode(bytes)`
+
+Encode id bytes into a string.
+
+### `IdDecoder`
+
+An `IdDecoder` decodes a specific encoding into an array of bytes representing
+an ID.
+
+#### `constuctor(options)`
+
+Options:
+
+- `encoding`: Input encoding. Ignored if `multibase` is `true`. (default:
+  `base58`)
+  - Same options as for `IdEncoder`.
+- `fixedBitLength`: fixed output bit length. (default: none)
+- `multibase`: `true` to use multibase encoding to detect id format. (default:
+  `true`)
+- `multihash`: `true` to use multihash encoding. (default: `false`)
+- `expectedSize`: Expected size for multihash-encoded ID bytes. Use `0` to
+  disable size check. (default: 32)
+
+#### `decode(id)`
+
+Decode id string into bytes.
+
+### `minEncodedIdBytes(options)`
+
+Minimum number of bytes needed to encode an id of a given bit length.
+
+Options:
+
+- `encoding`: Encoding. (default: `base58`)
+- `bitLength`: Number of id bits. (default: 128)
+- `multibase`: Account for multibase encoding. (default: true)
+
+### `maxEncodedIdBytes(options)`
+
+Maximum number of bytes needed to encode an id of a given bit length.
+
+Options:
+
+- `encoding`: Encoding. (default: `base58`)
+- `bitLength`: Number of id bits. (default: 128)
+- `multibase`: Account for multibase encoding. (default: true)
+
+### `generateSecretKeySeed(options)`
+
+`generateSecretKeySeed()` and `decodeSecretKeySeed()` methods are for creating
+and decoding secret key pair seeds which can be used to generate public key
+based identifiers.
+
+`generateSecretKeySeed()` generates a secret key seed encoded as a string that
+can be stored and later used to generate a key pair. The public key from the key
+pair can be used as an identifier. The encoded key seed MUST be kept secret.
+
+```js
+import { generateSecretKeySeed } from '@interop/bnid'
+
+const secretKeySeed = await generateSecretKeySeed()
+// Example secretKeySeed: z1Aaj5A4UCsdMpXwdYAReXa4bxWYiKJtdAvB1zMzCHtCbtD
+```
+
+Options:
+
+- `encoding`: Encoding. (default: `base58`)
+- `bitLength`: Number of id bits. (default: 32 \* 8)
+- `multibase`: Account for multibase encoding. (default: true)
+- `multihash`: Account for multihash encoding. (default: true)
+
+### `decodeSecretKeySeed(options)`
+
+Decodes an encoded secret key seed into an array of secret key seed bytes
+(default size: 32 bytes). Both the encoded key seed and the decoded bytes MUST
+be kept secret.
+
+```js
+import { decodeSecretKeySeed } from '@interop/bnid'
+
+const secretKeySeed = 'z1Aaj5A4UCsdMpXwdYAReXa4bxWYiKJtdAvB1zMzCHtCbtD'
+decoded = decodeSecretKeySeed({ secretKeySeed })
+// Example decoded:
+// Uint8Array(32) [
+//    80, 174,  15, 131, 124,  59,   9,  51,
+//   145, 129,  92, 157, 157, 172, 161,  79,
+//    74,  61, 152, 152,  48, 151,  20,  89,
+//   225, 169,  71,  34,  49,  61,  21, 215
+// ]
+```
+
+Options:
+
+- `secretKeySeed`: The secret key seed to be decoded.
+- `multibase`: Account for multibase encoding. (default: true)
+- `multihash`: Account for multihash encoding. (default: true)
+- `expectedSize`: Expected size for multihash-encoded ID bytes. Use `0` to
+  disable size check. (default: 32)
+
+## CLI
+
+A command line interface tool to generate and encode ids is provided in
+[`bnid-cli`](https://github.com/digitalbazaar/bnid-cli).
+
+## Contribute
+
+Please follow the existing code style.
+
+PRs accepted.
+
+If editing the README, please conform to the
+[standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+- MIT License - DCC - TypeScript and ReactNative compatibility.
+- [BSD-3-Clause](LICENSE.md) © Digital Bazaar
+
+[Base16]: https://en.wikipedia.org/wiki/Base16
+[Base58]: https://en.wikipedia.org/wiki/Base58
+[TextDecoder]: https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder
+[TextEncoder]: https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder
+[multibase]: https://github.com/multiformats/multibase

package/dist/baseX.d.ts

@@ -0,0 +1,2 @@
+export declare const base58btc: import("@scure/base").BytesCoder;
+//# sourceMappingURL=baseX.d.ts.map

package/dist/baseX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseX.d.ts","sourceRoot":"","sources":["../src/baseX.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,kCAAS,CAAA"}

package/dist/baseX.js

@@ -0,0 +1,3 @@
+import { base58 } from '@scure/base';
+export const base58btc = base58;
+//# sourceMappingURL=baseX.js.map

package/dist/baseX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseX.js","sourceRoot":"","sources":["../src/baseX.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,192 @@
+export interface IEncoder {
+    bytes: Uint8Array;
+    idEncoder: IdEncoder;
+}
+export declare class IdGenerator {
+    bitLength: number;
+    /**
+     * Creates a new IdGenerator instance.
+     *
+     * An IdGenerator generates an array of id bytes.
+     *
+     * @param {object} [options] - The options to use.
+     * @param {number} [options.bitLength=128] - Number of bits to generate.
+     *
+     * @returns {IdGenerator} - New IdGenerator.
+     */
+    constructor({ bitLength }?: {
+        bitLength?: number;
+    });
+    /**
+     * Generate random id bytes.
+     *
+     * @returns {Uint8Array} - Array of random id bytes.
+     */
+    generate(): Promise<Uint8Array>;
+}
+export interface IIdEncoder {
+    encoding?: string;
+    fixedLength?: boolean;
+    fixedBitLength?: number;
+    bitLength?: number;
+    multibase?: boolean;
+    multihash?: boolean;
+}
+export declare class IdEncoder {
+    encoder: ({ bytes, idEncoder }: IEncoder) => string;
+    encoding: string;
+    multibasePrefix: string;
+    fixedLength: boolean;
+    fixedBitLength?: number;
+    multibase: boolean;
+    multihash: boolean;
+    /**
+     * Creates a new IdEncoder instance.
+     *
+     * An IdEncoder encodes an array of id bytes into a specific encoding.
+     *
+     * @param {object} [options] - The options to use.
+     * @param {string} [options.encoding='base58'] - Encoding format.
+     * @param {boolean} [options.fixedLength=false] - `true` to ensure fixed
+     *   output length.
+     * @param {number} [options.fixedBitLength] - Fixed output bit length or 0 to
+     *   base on input byte size.
+     * @param {boolean} [options.multibase=true] - Use multibase encoding.
+     * @param {boolean} [options.multihash=false] - Use multihash encoding.
+     *
+     * @returns {IdEncoder} - New IdEncoder.
+     */
+    constructor({ encoding, fixedLength, fixedBitLength, multibase, multihash }?: IIdEncoder);
+    /**
+     * Encode id bytes into a string.
+     *
+     * @param {Uint8Array} bytes - Bytes to encode.
+     *
+     * @returns {string} - Encoded string.
+     */
+    encode(bytes: Uint8Array): string;
+}
+export interface IIdDecoder {
+    encoding?: string;
+    fixedBitLength?: number;
+    multibase?: boolean;
+    multihash?: boolean;
+    expectedSize?: number;
+}
+export declare class IdDecoder {
+    encoding: string;
+    fixedBitLength?: number;
+    multibase: boolean;
+    multihash: boolean;
+    expectedSize: number;
+    /**
+     * Creates a new IdDecoder instance.
+     *
+     * An IdDecoder decodes an id string into a byte array. It is recommended to
+     * use the fixedBitLength option to avoid padding ids resulting in a larger
+     * than expected byte length.
+     *
+     * @param {object} [options] - The options to use.
+     * @param {string} [options.encoding='base58'] - Encoding format. Ignored if
+     *   multibase is true.
+     * @param {number} [options.fixedBitLength] - Fixed output bit length. Values
+     *   with leading non-zero data will error.
+     * @param {boolean} [options.multibase=true] - Use multibase encoding to
+     *   detect the id format.
+     * @param {boolean} [options.multihash=false] - Use multihash encoding to
+     *   detect the id format.
+     * @param {number} [options.expectedSize=32] - Optional expected identifier
+     *   size in bytes (only for multihash encoding). Use `0` to disable size
+     *   check.
+     * @returns {IdDecoder} - New IdDecoder.
+     */
+    constructor({ encoding, fixedBitLength, multibase, multihash, expectedSize }?: IIdDecoder);
+    /**
+     * Decode id string into bytes.
+     *
+     * @param {string} id - Id to decode.
+     *
+     * @returns {Uint8Array} - Array of decoded id bytes.
+     */
+    decode(id: string): Uint8Array;
+}
+/**
+ * Generates an encoded id string from random bits.
+ *
+ * @param {object} [options] - The options to use. See `IdEncoder` and
+ *   `IdGenerator` for available options.
+ *
+ * @returns {string} - Encoded string id.
+ */
+export declare function generateId(options: IIdEncoder): Promise<string>;
+/**
+ * Decodes an encoded id string to an array of bytes.
+ *
+ * @param {object} options - The options to use. See `IdDecoder` for available
+ *   options.
+ * @param {string} options.id - Id to decode.
+ *
+ * @returns {Uint8Array} - Decoded array of id bytes.
+ */
+export declare function decodeId(options: IIdDecoder & {
+    id: string;
+}): Uint8Array;
+/**
+ * Minimum number of bytes needed to encode an id of a given bit length.
+ *
+ * @param {object} options - The options to use.
+ * @param {string} [options.encoding='base58'] - Encoding format.
+ * @param {number} [options.bitLength=128] - Number of id bits.
+ * @param {boolean} [options.multibase=true] - Account for multibase encoding.
+ *
+ * @returns {number} - The minimum number of encoded bytes.
+ */
+export declare function minEncodedIdBytes({ encoding, bitLength, multibase }?: IIdEncoder): number;
+/**
+ * Maximum number of bytes needed to encode an id of a given bit length.
+ *
+ * @param {object} options - The options to use.
+ * @param {string} [options.encoding='base58'] - Encoding format.
+ * @param {number} [options.bitLength=128] - Number of id bits.
+ * @param {boolean} [options.multibase=true] - Account for multibase encoding.
+ *
+ * @returns {number} - The maximum number of encoded bytes.
+ */
+export declare function maxEncodedIdBytes({ encoding, bitLength, multibase }?: IIdEncoder): number;
+/**
+ * Generates a secret key seed encoded as a string that can be stored and later
+ * used to generate a key pair. The public key from the key pair can be used as
+ * an identifier. The key seed (both raw and encoded form) MUST be kept secret.
+ *
+ * @param {object} [options] - The options to use.
+ * @param {string} [options.encoding='base58'] - Encoding format.
+ * @param {number} [options.bitLength=32 * 8] - Number of bits to generate.
+ * @param {boolean} [options.multibase=true] - Use multibase encoding.
+ * @param {boolean} [options.multihash=true] - Use multihash encoding.
+
+ * @returns {string} - Secret key seed encoded as a string.
+ */
+export declare function generateSecretKeySeed({ bitLength, encoding, multibase, multihash }?: IIdEncoder): Promise<string>;
+/**
+ * Decodes an encoded secret key seed into an array of secret key seed bytes.
+ * The key seed bytes MUST be kept secret.
+ *
+ * @param {object} options - The options to use.
+ * @param {boolean} [options.multibase=true] - Use multibase encoding to detect
+ *   the id format.
+ * @param {boolean} [options.multihash=true] - Use multihash encoding to detect
+ *   the id format.
+ * @param {number} [options.expectedSize] - Optional expected identifier size
+ *   in bytes (only for multihash encoding). Use `0` to disable size check.
+ * @param {string} options.secretKeySeed - The secret key seed to be decoded.
+ *
+ * @returns {Uint8Array} - An array of secret key seed bytes (default size:
+ *   32 bytes).
+ */
+export declare function decodeSecretKeySeed({ multibase, multihash, expectedSize, secretKeySeed }: {
+    multibase?: boolean;
+    multihash?: boolean;
+    expectedSize?: number;
+    secretKeySeed: string;
+}): Uint8Array;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}