@openclaw/nostr 2026.5.20 → 2026.5.22

package/node_modules/@noble/hashes/webcrypto.js

@@ -0,0 +1,126 @@
+import {} from "./pbkdf2.js";
+import { abytes, ahash, anumber, checkOpts, kdfInputToBytes, } from "./utils.js";
+function _subtle() {
+    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;
+    const sb = cr?.subtle;
+    if (typeof sb === 'object' && sb != null)
+        return sb;
+    throw new Error('crypto.subtle must be defined');
+}
+function createWebHash(name, blockLen, outputLen) {
+    const hashC = async (msg) => {
+        abytes(msg);
+        const crypto = _subtle();
+        return new Uint8Array(await crypto.digest(name, msg));
+    };
+    hashC.webCryptoName = name; // make sure it won't interfere with function name
+    hashC.outputLen = outputLen;
+    hashC.blockLen = blockLen;
+    hashC.create = () => {
+        throw new Error('not implemented');
+    };
+    return hashC;
+}
+function ahashWeb(hash) {
+    ahash(hash);
+    if (typeof hash.webCryptoName !== 'string')
+        throw new Error('non-web hash');
+}
+/** WebCrypto SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+// export const sha1: WebHash = createHash('SHA-1', 64, 20);
+/** WebCrypto SHA2-256 hash function from RFC 4634. */
+export const sha256 = /* @__PURE__ */ createWebHash('SHA-256', 64, 32);
+/** WebCrypto SHA2-384 hash function from RFC 4634. */
+export const sha384 = /* @__PURE__ */ createWebHash('SHA-384', 128, 48);
+/** WebCrypto SHA2-512 hash function from RFC 4634. */
+export const sha512 = /* @__PURE__ */ createWebHash('SHA-512', 128, 64);
+/**
+ * WebCrypto HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256. Webcrypto version.
+ * @param key - key which would be used to authenticate message
+ * @param message - message
+ * @example
+ * ```js
+ * import { hmac, sha256 } from '@noble/hashes/webcrypto.js';
+ * const mac1 = await hmac(sha256, 'key', 'message');
+ * ```
+ */
+export const hmac = /* @__PURE__ */ (() => {
+    const hmac_ = async (hash, key, message) => {
+        const crypto = _subtle();
+        abytes(key, undefined, 'key');
+        abytes(message, undefined, 'message');
+        ahashWeb(hash);
+        // WebCrypto keys can't be zeroized
+        // prettier-ignore
+        const wkey = await crypto.importKey('raw', key, { name: 'HMAC', hash: hash.webCryptoName }, false, ['sign']);
+        return new Uint8Array(await crypto.sign('HMAC', wkey, message));
+    };
+    hmac_.create = (_hash, _key) => {
+        throw new Error('not implemented');
+    };
+    return hmac_;
+})();
+/**
+ * WebCrypto HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256). Webcrypto version.
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ * @example
+ * ```js
+ * import { hkdf, sha256 } from '@noble/hashes/webcrypto.js';
+ * import { randomBytes } from '@noble/hashes/utils.js';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = 'application-key';
+ * const hk1w = await hkdf(sha256, inputKey, salt, info, 32);
+ * ```
+ */
+export async function hkdf(hash, ikm, salt, info, length) {
+    const crypto = _subtle();
+    ahashWeb(hash);
+    abytes(ikm, undefined, 'ikm');
+    anumber(length, 'length');
+    if (salt !== undefined)
+        abytes(salt, undefined, 'salt');
+    if (info !== undefined)
+        abytes(info, undefined, 'info');
+    const wkey = await crypto.importKey('raw', ikm, 'HKDF', false, ['deriveBits']);
+    const opts = {
+        name: 'HKDF',
+        hash: hash.webCryptoName,
+        salt: salt === undefined ? new Uint8Array(0) : salt,
+        info: info === undefined ? new Uint8Array(0) : info,
+    };
+    return new Uint8Array(await crypto.deriveBits(opts, wkey, 8 * length));
+}
+/**
+ * WebCrypto PBKDF2-HMAC: RFC 2898 key derivation function
+ * @param hash - hash function that would be used e.g. sha256. Webcrypto version.
+ * @param password - password from which a derived key is generated
+ * @param salt - cryptographic salt
+ * @param opts - {c, dkLen} where c is work factor and dkLen is output message size
+ * @example
+ * ```js
+ * const key = await pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+ * ```
+ */
+export async function pbkdf2(hash, password, salt, opts) {
+    const crypto = _subtle();
+    ahashWeb(hash);
+    const _opts = checkOpts({ dkLen: 32 }, opts);
+    const { c, dkLen } = _opts;
+    anumber(c, 'c');
+    anumber(dkLen, 'dkLen');
+    const _password = kdfInputToBytes(password, 'password');
+    const _salt = kdfInputToBytes(salt, 'salt');
+    const key = await crypto.importKey('raw', _password, 'PBKDF2', false, [
+        'deriveBits',
+    ]);
+    const deriveOpts = { name: 'PBKDF2', salt: _salt, iterations: c, hash: hash.webCryptoName };
+    return new Uint8Array(await crypto.deriveBits(deriveOpts, key, 8 * dkLen));
+}
+//# sourceMappingURL=webcrypto.js.map

package/node_modules/@noble/hashes/webcrypto.js.map

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

package/node_modules/@scure/base/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Paul Miller (https://paulmillr.com)
+
+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/node_modules/@scure/base/README.md

@@ -0,0 +1,226 @@
+# scure-base
+
+Audited & minimal implementation of bech32, base64, base58, base32 & base16.
+
+- 🔒 [Audited](#security) by an independent security firm
+- 🔻 Tree-shakeable: unused code is excluded from your builds
+- ✍️ Written in [functional style](#design-rationale), easily composable
+- 💼 Matches specs
+  - [BIP173](https://en.bitcoin.it/wiki/BIP_0173), [BIP350](https://en.bitcoin.it/wiki/BIP_0350) for bech32 / bech32m
+  - [RFC 4648](https://datatracker.ietf.org/doc/html/rfc4648) (aka RFC 3548) for Base16, Base32, Base32Hex, Base64, Base64Url
+  - [Base58](https://www.ietf.org/archive/id/draft-msporny-base58-03.txt),
+    [Base58check](https://en.bitcoin.it/wiki/Base58Check_encoding),
+    [Base32 Crockford](https://www.crockford.com/base32.html)
+- 🪶 4KB (gzipped)
+
+Check out [Projects using scure-base](#projects-using-scure-base).
+
+### This library belongs to _scure_
+
+> **scure** — audited micro-libraries.
+
+- Zero or minimal dependencies
+- Highly readable TypeScript / JS code
+- PGP-signed releases and transparent NPM builds
+- Check out [homepage](https://paulmillr.com/noble/#scure) & all libraries:
+  [base](https://github.com/paulmillr/scure-base),
+  [bip32](https://github.com/paulmillr/scure-bip32),
+  [bip39](https://github.com/paulmillr/scure-bip39),
+  [btc-signer](https://github.com/paulmillr/scure-btc-signer),
+  [sr25519](https://github.com/paulmillr/scure-sr25519),
+  [starknet](https://github.com/paulmillr/scure-starknet)
+
+## Usage
+
+> `npm install @scure/base`
+
+> `deno add jsr:@scure/base`
+
+We support all major platforms and runtimes. The library is hybrid ESM / Common.js package.
+
+```js
+import { base16, base32, base64, base58 } from '@scure/base';
+// Flavors
+import {
+  base58xmr,
+  base58xrp,
+  base32nopad,
+  base32hex,
+  base32hexnopad,
+  base32crockford,
+  base64nopad,
+  base64url,
+  base64urlnopad,
+} from '@scure/base';
+
+const data = Uint8Array.from([1, 2, 3]);
+base64.decode(base64.encode(data));
+
+// Convert utf8 string to Uint8Array
+const data2 = new TextEncoder().encode('hello');
+base58.encode(data2);
+
+// Everything has the same API except for bech32 and base58check
+base32.encode(data);
+base16.encode(data);
+base32hex.encode(data);
+```
+
+base58check is a special case: you need to pass `sha256()` function:
+
+```js
+import { createBase58check } from '@scure/base';
+createBase58check(sha256).encode(data);
+```
+
+## Bech32, Bech32m and Bitcoin
+
+We provide low-level bech32 operations.
+If you need high-level methods for BTC (addresses, and others), use
+[scure-btc-signer](https://github.com/paulmillr/scure-btc-signer) instead.
+
+Bitcoin addresses use both 5-bit words and bytes representations.
+They can't be parsed using `bech32.decodeToBytes`.
+
+Same applies to Lightning Invoice Protocol
+[BOLT-11](https://github.com/lightning/bolts/blob/master/11-payment-encoding.md).
+We have many tests in `./test/bip173.test.js` that serve as minimal examples of
+Bitcoin address and Lightning Invoice Protocol parsers.
+Keep in mind that you'll need to verify the examples before using them in your code.
+
+Do something like this:
+
+```ts
+const decoded = bech32.decode(address);
+// NOTE: words in bitcoin addresses contain version as first element,
+// with actual witness program words in rest
+// BIP-141: The value of the first push is called the "version byte".
+// The following byte vector pushed is called the "witness program".
+const [version, ...dataW] = decoded.words;
+const program = bech32.fromWords(dataW); // actual witness program
+```
+
+## Design rationale
+
+The code may feel unnecessarily complicated; but actually it's much easier to reason about.
+Any encoding library consists of two functions:
+
+```
+encode(A) -> B
+decode(B) -> A
+  where X = decode(encode(X))
+  # encode(decode(X)) can be !== X!
+  # because decoding can normalize input
+
+e.g.
+base58checksum = {
+  encode(): {
+    // checksum
+    // radix conversion
+    // alphabet
+  },
+  decode(): {
+    // alphabet
+    // radix conversion
+    // checksum
+  }
+}
+```
+
+But instead of creating two big functions for each specific case,
+we create them from tiny composable building blocks:
+
+```
+base58checksum = chain(checksum(), radix(), alphabet())
+```
+
+Which is the same as chain/pipe/sequence function in Functional Programming,
+but significantly more useful since it enforces same order of execution of encode/decode.
+Basically you only define encode (in declarative way) and get correct decode for free.
+So, instead of reasoning about two big functions you need only reason about primitives and encode chain.
+The design revealed obvious bug in older version of the lib,
+where xmr version of base58 had errors in decode's block processing.
+
+Besides base-encodings, we can reuse the same approach with any encode/decode function
+(`bytes2number`, `bytes2u32`, etc).
+For example, you can easily encode entropy to mnemonic (BIP-39):
+
+```ts
+export function getCoder(wordlist: string[]) {
+  if (!Array.isArray(wordlist) || wordlist.length !== 2 ** 11 || typeof wordlist[0] !== 'string') {
+    throw new Error('Wordlist: expected array of 2048 strings');
+  }
+  return mbc.chain(mbu.checksum(1, checksum), mbu.radix2(11, true), mbu.alphabet(wordlist));
+}
+```
+
+### base58 is O(n^2) and radixes
+
+`Uint8Array` is represented as big-endian number:
+
+```
+[1, 2, 3, 4, 5] -> 1*(256**4) + 2*(256**3) 3*(256**2) + 4*(256**1) + 5*(256**0)
+where 256 = 2**8 (8 bits per byte)
+```
+
+which is then converted to a number in another radix/base (16/32/58/64, etc).
+
+However, generic conversion between bases has [quadratic O(n^2) time complexity](https://cs.stackexchange.com/q/21799).
+
+Which means base58 has quadratic time complexity too. Use base58 only when you have small
+constant sized input, because variable length sized input from user can cause DoS.
+
+On the other hand, if both bases are power of same number (like `2**8 <-> 2**64`),
+there is linear algorithm. For now we have implementation for power-of-two bases only (radix2).
+
+## Security
+
+The library has been independently audited:
+
+- at version 1.0.0, in Jan 2022, by [cure53](https://cure53.de)
+  - PDFs: [online](https://cure53.de/pentest-report_hashing-libs.pdf), [offline](./audit/2022-01-05-cure53-audit-nbl2.pdf)
+  - [Changes since audit](https://github.com/paulmillr/scure-base/compare/1.0.0..main).
+  - The audit has been funded by [Ethereum Foundation](https://ethereum.org/en/) with help of [Nomic Labs](https://nomiclabs.io)
+
+The library was initially developed for [js-ethereum-cryptography](https://github.com/ethereum/js-ethereum-cryptography).
+At commit [ae00e6d7](https://github.com/ethereum/js-ethereum-cryptography/commit/ae00e6d7d24fb3c76a1c7fe10039f6ecd120b77e),
+it was extracted to a separate package called `micro-base`.
+After the audit we've decided to use `@scure` NPM namespace for security.
+
+### Supply chain security
+
+- **Commits** are signed with PGP keys, to prevent forgery. Make sure to verify commit signatures
+- **Releases** are transparent and built on GitHub CI. Make sure to verify [provenance](https://docs.npmjs.com/generating-provenance-statements) logs
+  - Use GitHub CLI to verify single-file builds:
+    `gh attestation verify --owner paulmillr scure-base.js`
+- **Rare releasing** is followed to ensure less re-audit need for end-users
+- **Dependencies** are minimized and locked-down: any dependency could get hacked and users will be downloading malware with every install.
+  - We make sure to use as few dependencies as possible
+  - Automatic dep updates are prevented by locking-down version ranges; diffs are checked with `npm-diff`
+- **Dev Dependencies** are disabled for end-users; they are only used to develop / build the source code
+
+For this package, there are 0 dependencies; and a few dev dependencies:
+
+- micro-bmark, micro-should and jsbt are used for benchmarking / testing / build tooling and developed by the same author
+- prettier, fast-check and typescript are used for code quality / test generation / ts compilation. It's hard to audit their source code thoroughly and fully because of their size
+
+## Contributing & testing
+
+- `npm install && npm run build && npm test` will build the code and run tests.
+- `npm run lint` / `npm run format` will run linter / fix linter issues.
+- `npm run build:release` will build single file
+
+### Projects using scure-base
+
+- [scure-btc-signer](https://github.com/paulmillr/scure-btc-signer)
+- [prefixed-api-key](https://github.com/truestamp/prefixed-api-key)
+- [coinspace](https://github.com/CoinSpace/CoinSpace) wallet and its modules:
+  [ada](https://github.com/CoinSpace/cs-cardano-wallet),
+  [btc](https://github.com/CoinSpace/cs-bitcoin-wallet)
+  [eos](https://github.com/CoinSpace/cs-eos-wallet),
+  [sol](https://github.com/CoinSpace/cs-solana-wallet),
+  [xmr](https://github.com/CoinSpace/cs-monero-wallet)
+
+## License
+
+MIT (c) Paul Miller [(https://paulmillr.com)](https://paulmillr.com), see LICENSE file.

package/node_modules/@scure/base/index.d.ts

@@ -0,0 +1,294 @@
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+export interface Coder<F, T> {
+    encode(from: F): T;
+    decode(to: T): F;
+}
+export interface BytesCoder extends Coder<Uint8Array, string> {
+    encode: (data: Uint8Array) => string;
+    decode: (str: string) => Uint8Array;
+}
+type Chain = [Coder<any, any>, ...Coder<any, any>[]];
+type Input<F> = F extends Coder<infer T, any> ? T : never;
+type Output<F> = F extends Coder<any, infer T> ? T : never;
+type First<T> = T extends [infer U, ...any[]] ? U : never;
+type Last<T> = T extends [...any[], infer U] ? U : never;
+type Tail<T> = T extends [any, ...infer U] ? U : never;
+type AsChain<C extends Chain, Rest = Tail<C>> = {
+    [K in keyof C]: Coder<Input<C[K]>, Input<K extends keyof Rest ? Rest[K] : any>>;
+};
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function chain<T extends Chain & AsChain<T>>(...args: T): Coder<Input<First<T>>, Output<Last<T>>>;
+/**
+ * Encodes integer radix representation to array of strings using alphabet and back.
+ * Could also be array of strings.
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function alphabet(letters: string | string[]): Coder<number[], string[]>;
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function join(separator?: string): Coder<string[], string>;
+/**
+ * Pad strings array so it has integer number of bits
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function padding(bits: number, chr?: string): Coder<string[], string[]>;
+/**
+ * Slow: O(n^2) time complexity
+ */
+declare function convertRadix(data: number[], from: number, to: number): number[];
+/**
+ * Implemented with numbers, because BigInt is 5x slower
+ */
+declare function convertRadix2(data: number[], from: number, to: number, padding: boolean): number[];
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function radix(num: number): Coder<Uint8Array, number[]>;
+/**
+ * If both bases are power of same number (like `2**8 <-> 2**64`),
+ * there is a linear algorithm. For now we have implementation for power-of-two bases only.
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function radix2(bits: number, revPadding?: boolean): Coder<Uint8Array, number[]>;
+declare function checksum(len: number, fn: (data: Uint8Array) => Uint8Array): Coder<Uint8Array, Uint8Array>;
+export declare const utils: {
+    alphabet: typeof alphabet;
+    chain: typeof chain;
+    checksum: typeof checksum;
+    convertRadix: typeof convertRadix;
+    convertRadix2: typeof convertRadix2;
+    radix: typeof radix;
+    radix2: typeof radix2;
+    join: typeof join;
+    padding: typeof padding;
+};
+/**
+ * base16 encoding from RFC 4648.
+ * @example
+ * ```js
+ * base16.encode(Uint8Array.from([0x12, 0xab]));
+ * // => '12AB'
+ * ```
+ */
+export declare const base16: BytesCoder;
+/**
+ * base32 encoding from RFC 4648. Has padding.
+ * Use `base32nopad` for unpadded version.
+ * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.
+ * @example
+ * ```js
+ * base32.encode(Uint8Array.from([0x12, 0xab]));
+ * // => 'CKVQ===='
+ * base32.decode('CKVQ====');
+ * // => Uint8Array.from([0x12, 0xab])
+ * ```
+ */
+export declare const base32: BytesCoder;
+/**
+ * base32 encoding from RFC 4648. No padding.
+ * Use `base32` for padded version.
+ * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.
+ * @example
+ * ```js
+ * base32nopad.encode(Uint8Array.from([0x12, 0xab]));
+ * // => 'CKVQ'
+ * base32nopad.decode('CKVQ');
+ * // => Uint8Array.from([0x12, 0xab])
+ * ```
+ */
+export declare const base32nopad: BytesCoder;
+/**
+ * base32 encoding from RFC 4648. Padded. Compared to ordinary `base32`, slightly different alphabet.
+ * Use `base32hexnopad` for unpadded version.
+ * @example
+ * ```js
+ * base32hex.encode(Uint8Array.from([0x12, 0xab]));
+ * // => '2ALG===='
+ * base32hex.decode('2ALG====');
+ * // => Uint8Array.from([0x12, 0xab])
+ * ```
+ */
+export declare const base32hex: BytesCoder;
+/**
+ * base32 encoding from RFC 4648. No padding. Compared to ordinary `base32`, slightly different alphabet.
+ * Use `base32hex` for padded version.
+ * @example
+ * ```js
+ * base32hexnopad.encode(Uint8Array.from([0x12, 0xab]));
+ * // => '2ALG'
+ * base32hexnopad.decode('2ALG');
+ * // => Uint8Array.from([0x12, 0xab])
+ * ```
+ */
+export declare const base32hexnopad: BytesCoder;
+/**
+ * base32 encoding from RFC 4648. Doug Crockford's version.
+ * https://www.crockford.com/base32.html
+ * @example
+ * ```js
+ * base32crockford.encode(Uint8Array.from([0x12, 0xab]));
+ * // => '2ANG'
+ * base32crockford.decode('2ANG');
+ * // => Uint8Array.from([0x12, 0xab])
+ * ```
+ */
+export declare const base32crockford: BytesCoder;
+/**
+ * base64 from RFC 4648. Padded.
+ * Use `base64nopad` for unpadded version.
+ * Also check out `base64url`, `base64urlnopad`.
+ * Falls back to built-in function, when available.
+ * @example
+ * ```js
+ * base64.encode(Uint8Array.from([0x12, 0xab]));
+ * // => 'Eqs='
+ * base64.decode('Eqs=');
+ * // => Uint8Array.from([0x12, 0xab])
+ * ```
+ */
+export declare const base64: BytesCoder;
+/**
+ * base64 from RFC 4648. No padding.
+ * Use `base64` for padded version.
+ * @example
+ * ```js
+ * base64nopad.encode(Uint8Array.from([0x12, 0xab]));
+ * // => 'Eqs'
+ * base64nopad.decode('Eqs');
+ * // => Uint8Array.from([0x12, 0xab])
+ * ```
+ */
+export declare const base64nopad: BytesCoder;
+/**
+ * base64 from RFC 4648, using URL-safe alphabet. Padded.
+ * Use `base64urlnopad` for unpadded version.
+ * Falls back to built-in function, when available.
+ * @example
+ * ```js
+ * base64url.encode(Uint8Array.from([0x12, 0xab]));
+ * // => 'Eqs='
+ * base64url.decode('Eqs=');
+ * // => Uint8Array.from([0x12, 0xab])
+ * ```
+ */
+export declare const base64url: BytesCoder;
+/**
+ * base64 from RFC 4648, using URL-safe alphabet. No padding.
+ * Use `base64url` for padded version.
+ * @example
+ * ```js
+ * base64urlnopad.encode(Uint8Array.from([0x12, 0xab]));
+ * // => 'Eqs'
+ * base64urlnopad.decode('Eqs');
+ * // => Uint8Array.from([0x12, 0xab])
+ * ```
+ */
+export declare const base64urlnopad: BytesCoder;
+/**
+ * base58: base64 without ambigous characters +, /, 0, O, I, l.
+ * Quadratic (O(n^2)) - so, can't be used on large inputs.
+ * @example
+ * ```js
+ * base58.decode('01abcdef');
+ * // => '3UhJW'
+ * ```
+ */
+export declare const base58: BytesCoder;
+/**
+ * base58: flickr version. Check out `base58`.
+ */
+export declare const base58flickr: BytesCoder;
+/**
+ * base58: XRP version. Check out `base58`.
+ */
+export declare const base58xrp: BytesCoder;
+/**
+ * base58: XMR version. Check out `base58`.
+ * Done in 8-byte blocks (which equals 11 chars in decoding). Last (non-full) block padded with '1' to size in XMR_BLOCK_LEN.
+ * Block encoding significantly reduces quadratic complexity of base58.
+ */
+export declare const base58xmr: BytesCoder;
+/**
+ * Method, which creates base58check encoder.
+ * Requires function, calculating sha256.
+ */
+export declare const createBase58check: (sha256: (data: Uint8Array) => Uint8Array) => BytesCoder;
+/**
+ * Use `createBase58check` instead.
+ * @deprecated
+ */
+export declare const base58check: (sha256: (data: Uint8Array) => Uint8Array) => BytesCoder;
+export interface Bech32Decoded<Prefix extends string = string> {
+    prefix: Prefix;
+    words: number[];
+}
+export interface Bech32DecodedWithArray<Prefix extends string = string> {
+    prefix: Prefix;
+    words: number[];
+    bytes: Uint8Array;
+}
+export interface Bech32 {
+    encode<Prefix extends string>(prefix: Prefix, words: number[] | Uint8Array, limit?: number | false): `${Lowercase<Prefix>}1${string}`;
+    decode<Prefix extends string>(str: `${Prefix}1${string}`, limit?: number | false): Bech32Decoded<Prefix>;
+    encodeFromBytes(prefix: string, bytes: Uint8Array): string;
+    decodeToBytes(str: string): Bech32DecodedWithArray;
+    decodeUnsafe(str: string, limit?: number | false): void | Bech32Decoded<string>;
+    fromWords(to: number[]): Uint8Array;
+    fromWordsUnsafe(to: number[]): void | Uint8Array;
+    toWords(from: Uint8Array): number[];
+}
+/**
+ * bech32 from BIP 173. Operates on words.
+ * For high-level, check out scure-btc-signer:
+ * https://github.com/paulmillr/scure-btc-signer.
+ */
+export declare const bech32: Bech32;
+/**
+ * bech32m from BIP 350. Operates on words.
+ * It was to mitigate `bech32` weaknesses.
+ * For high-level, check out scure-btc-signer:
+ * https://github.com/paulmillr/scure-btc-signer.
+ */
+export declare const bech32m: Bech32;
+/**
+ * UTF-8-to-byte decoder. Uses built-in TextDecoder / TextEncoder.
+ * @example
+ * ```js
+ * const b = utf8.decode("hey"); // => new Uint8Array([ 104, 101, 121 ])
+ * const str = utf8.encode(b); // "hey"
+ * ```
+ */
+export declare const utf8: BytesCoder;
+/**
+ * hex string decoder. Uses built-in function, when available.
+ * @example
+ * ```js
+ * const b = hex.decode("0102ff"); // => new Uint8Array([ 1, 2, 255 ])
+ * const str = hex.encode(b); // "0102ff"
+ * ```
+ */
+export declare const hex: BytesCoder;
+export type SomeCoders = {
+    utf8: BytesCoder;
+    hex: BytesCoder;
+    base16: BytesCoder;
+    base32: BytesCoder;
+    base64: BytesCoder;
+    base64url: BytesCoder;
+    base58: BytesCoder;
+    base58xmr: BytesCoder;
+};
+type CoderType = keyof SomeCoders;
+/** @deprecated */
+export declare const bytesToString: (type: CoderType, bytes: Uint8Array) => string;
+/** @deprecated */
+export declare const str: (type: CoderType, bytes: Uint8Array) => string;
+/** @deprecated */
+export declare const stringToBytes: (type: CoderType, str: string) => Uint8Array;
+/** @deprecated */
+export declare const bytes: (type: CoderType, str: string) => Uint8Array;
+export {};
+//# sourceMappingURL=index.d.ts.map