@scure/btc-signer 1.6.0 → 1.7.0

package/README.md

@@ -8,11 +8,12 @@ Audited & minimal library for creating, signing & decoding Bitcoin transactions.
 - 🔀 UTXO selection with different strategies
 - 🎻 Classic & SegWit: P2PK, P2PKH, P2WPKH, P2SH, P2WSH, P2MS
 - 🧪 Schnorr & Taproot BIP340/BIP341: P2TR, P2TR-NS, P2TR-MS
-- 📨 BIP174 PSBT
+- 📨 BIP174 PSBT, BIP327 MuSig2
 - 🗳️ Easy ordinals and inscriptions
 - 🪶 3300 lines
 
 Initial development has been funded by [Ryan Shea](https://shea.io).
+Musig2 feature has been funded by [Arklabs](https://arklabs.to).
 
 For discussions, questions and support, visit
 [GitHub Discussions](https://github.com/paulmillr/scure-btc-signer/discussions)
@@ -40,7 +41,7 @@ _Check out all web3 utility libraries:_ [ETH](https://github.com/paulmillr/micro
 
 > `deno add jsr:@scure/btc-signer`
 
-> `deno doc jsr:@scure/btc-signer`  # command-line documentation
+> `deno doc jsr:@scure/btc-signer` # command-line documentation
 
 We support all major platforms and runtimes.
 For [Deno](https://deno.land), ensure to use [npm specifier](https://deno.land/manual@v1.28.0/node/npm_specifiers).
@@ -62,6 +63,7 @@ import * as btc from '@scure/btc-signer';
   - [P2TR-NS Taproot multisig](#p2tr-ns-taproot-multisig)
   - [P2TR-MS Taproot M-of-N multisig](#p2tr-ms-taproot-m-of-n-multisig)
   - [P2TR-PK Taproot single P2PK script](#p2tr-pk-taproot-single-p2pk-script)
+  - [P2A Pay To Anchor](#p2a-pay-to-anchor)
 - [Transaction](#transaction)
   - [Encode/decode](#encodedecode)
   - [Inputs](#inputs)
@@ -69,14 +71,15 @@ import * as btc from '@scure/btc-signer';
   - [Basic transaction sign](#basic-transaction-sign)
   - [BIP174 PSBT multi-sig example](#bip174-psbt-multi-sig-example)
 - [UTXO selection](#utxo-selection)
+- [MuSig2](#musig2)
 - [Ordinals and custom scripts](#ordinals-and-custom-scripts)
 - [Utils](#utils)
   - [getAddress](#getaddress)
     - [WIF](#wif)
   - [Script](#script)
   - [OutScript](#outscript)
+- [Bitcoin is flawed](#bitcoin-is-flawed)
 - [Security](#security)
-  - [Supply chain security](#supply-chain-security)
 - [License](#license)
 
 ## Payments
@@ -398,6 +401,17 @@ deepStrictEqual(clean(btc.p2tr(undefined, [btc.p2tr_pk(PubKey)])), {
 });
 ```
 
+### P2A (Pay to Anchor)
+
+Ephemeral anchors are supported. [Check out docs](https://bitcoinops.org/en/topics/ephemeral-anchors/).
+
+```ts
+const p2aScript = hex.decode('51024e73');
+const decoded = btc.OutScript.decode(p2aScript);
+deepStrictEqual(decoded, { type: 'p2a', script: p2aScript });
+deepStrictEqual(hex.encode(btc.OutScript.encode(decoded)), '51024e73');
+```
+
 ## Transaction
 
 ### Encode/decode
@@ -881,6 +895,65 @@ deepStrictEqual(tx.id, 'b702078d65edd65a84b2a97a669df5631b06f42a67b0d7090e540b02
 deepStrictEqual(tx.fee, 394n);
 ```
 
+## MuSig2
+
+MuSig2 implementation conforming to [BIP-327](https://github.com/bitcoin/bips/blob/master/bip-0327.mediawiki)
+is available in `@scure/btc-signer/musig2`. Check out [bip327-musig2.test.js](./test/bip327-musig2.test.js) as well:
+
+```ts
+import * as musig2 from '@scure/btc-signer/musig2';
+// MuSig2 Multi-signature for Alice, Bob, and Carol
+// 1. Key Generation (for each signer: Alice, Bob, Carol)
+// - Alice's key generation
+const aliceSecretKey = randomBytes(32); // Alice generates a random 32-byte secret key
+const alicePublicKey = musig2.IndividualPubkey(aliceSecretKey); // Alice derives her individual public key from her secret key
+// - Bob's key generation
+const bobSecretKey = randomBytes(32); // Bob generates a random 32-byte secret key
+const bobPublicKey = musig2.IndividualPubkey(bobSecretKey); // Bob derives his individual public key from his secret key
+// - Carol's key generation
+const carolSecretKey = randomBytes(32); // Carol generates a random 32-byte secret key
+const carolPublicKey = musig2.IndividualPubkey(carolSecretKey); // Carol derives her individual public key from her secret key
+
+// 2. Key Aggregation (All signers participate by sharing public keys)
+const individualPublicKeys = [alicePublicKey, bobPublicKey, carolPublicKey]; // Collect all individual public keys
+const sortedPublicKeys = musig2.sortKeys(individualPublicKeys); // Sort public keys lexicographically (as required by MuSig2)
+const aggregatePublicKey = musig2.keyAggExport(musig2.keyAggregate(sortedPublicKeys)); // Extract the X-only aggregate public key (32 bytes)
+// At this point, all signers have the 'aggregatePublicKey' and 'keyAggContext'.
+// 3. Nonce Generation - Round 1 (Each signer generates and broadcasts public nonce)
+const msg = new Uint8Array(32).fill(5); // Example message to be signed (32-byte message is recommended for BIP340)
+// Alice generates her nonce
+const aliceNonces = musig2.nonceGen(alicePublicKey, aliceSecretKey, aggregatePublicKey, msg);
+// Secret nonce: must be kept secret and used only once per signing session!
+// Public nonce: to be shared with Bob and Carol
+// Bob generates his nonce
+const bobNonces = musig2.nonceGen(bobPublicKey, bobSecretKey, aggregatePublicKey, msg);
+// Carol generates her nonce
+const carolNonces = musig2.nonceGen(carolPublicKey, carolSecretKey, aggregatePublicKey, msg);
+// Each signer creates own instance
+const session = new musig2.Session(
+  // 4. Nonce Aggregation (All signers participate by sharing public nonces)
+  musig2.nonceAggregate([aliceNonces.public, bobNonces.public, carolNonces.public]),
+  sortedPublicKeys,
+  msg
+);
+// At this point, all signers have the 'aggregateNonce'.
+// 5. Partial Signature Generation - Round 2 (Each signer generates partial signature)
+// Alice generates her partial signature
+const alicePartialSignature = session.sign(aliceNonces.secret, aliceSecretKey);
+// Bob generates his partial signature
+const bobPartialSignature = session.sign(bobNonces.secret, bobSecretKey);
+// Carol generates her partial signature
+const carolPartialSignature = session.sign(carolNonces.secret, carolSecretKey);
+// 6. Partial Signature Aggregation (Anyone can aggregate partial signatures)
+const partialSignatures = [alicePartialSignature, bobPartialSignature, carolPartialSignature]; // Collect all partial signatures
+const finalSignature = session.partialSigAgg(partialSignatures); // Aggregate partial signatures to create the final signature
+
+// 7. Signature Verification (Anyone can verify the final signature)
+// Verify the final signature
+import { schnorr } from '@noble/curves/secp256k1';
+schnorr.verify(finalSignature, msg, aggregatePublicKey);
+```
+
 ## Ordinals and custom scripts
 
 We support custom scripts. You can pass it as last argument to `p2tr`.
@@ -1003,6 +1076,47 @@ deepStrictEqual(
 );
 ```
 
+## Bitcoin is flawed
+
+Bitcoin is more complex than ETH / SOL despite having less features:
+
+- **Legacy:** too much decade-old code / standards
+- **Overengineering:** features were designed to be extensible and future-proof; then abandoned when future arrived.
+  - Transaction has `version` field, which is nice, allowing to change format later, however when there
+    was first change (SegWit V0), instead of using different tx version, there was hack with zero-inputs prefix
+    (tx cannot have zero inputs, so inputsCount=0 + '01' flag after that for tx version with witness data).
+    Probably it was done so it won't interfere with different transaction versions of different coins.
+    However, there is also `txVersion=2` (BIP68) which changes lockTime behaviour, but not tx format.
+  - There is bech32/witness program addresses, which is very extensible. By default rules software should
+    support future versions (0..16), so there will be no change in libraries to support new addresses.
+    However, even after first update (version 0 to 1) format of addresses itself changed from bech32 to bech32m,
+    so whole mechanic of different address versions is already unused. Also, supporting future version
+    of addresses is cool, but they are currently unspendable and we cannot know rules for spending new version address,
+    which means any new version address created now will be unspendable in future (SegWitV0->SegWitV1(taproot) even
+    changes public key format). So we cannot use this whole mechanic of future addresses at all (or users can accidentally create unspendable address and lose coins).
+  - PSBT supports unknown fields, according to spec we need to pass them as is, without modifications.
+    It was probably done this way to be future-proof: new version of PSBT can be parsed with old parser, which will ignore new fields. However, when future came (PSBTv2), format significantly changed (no `global.unsignedTx`) anyway.
+- **Bad BIP specs:** likely because there is only one relevant BTC Core implementation.
+  - To implement something, specs are not enough: need to read source code of Core (which is very complex, especially functional tests which re-implement parts in python) and other bitcoin libraries (such as bitcoinjs-lib)
+  - No one cares about specs much: for example, in [BIP174](https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki),
+    despite being old 2017 spec, formatting issues still haven't been fixed: `m/0'/0'/0'`
+  - [BIP174](https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki) multisig example has unsorted partialSig field
+    inside input (it's better to sort it)
+  - Many PSBT tests are in format of `valid/invalid` (especially for PSBTv2), which isn't very helpful.
+    Parser which produces garbage, but doesn't throw exception, is still broken.
+- **Major flaws in PSBT:**
+  - PSBT was designed to be opaque key-value store. Combiner only needed to merge dictories, without a need to understand
+    fields. However, parsing requires to understand `unsignedTx`, since there is no input/output count in format itself.
+  - Instead of `global, inputCount, inputs[], outputCount, outputs[]`, inputCount and outputCount are stored inside
+    `global.unsignedTx` (v0) or `global.inputCount/global.outputCount` (v2), which means in order to parse
+    basic structure we need to completely parse global KV and understand its fields.
+  - **Security issue:** Unknown PSBT fields can be used to pass some code to backdoored wallets while being ignore by others.
+  - In JS, it is even harder to implement properly, because JS doesn't support complex keys in objects / dicts.
+    There is whole controlBlock of taproot in key inside tapLeafScript, which we need to parse, leading to structure like:
+    `{key: {version, internalKey, merklePath}, value: {script, version}`.
+    But, since there is no support for complex keys, we cannot do `correct by construction` using js objects,
+    we need to do this dict as array and constantly check if keys are unique.
+
 ## Security
 
 The library has been independently audited:
@@ -1012,32 +1126,36 @@ The library has been independently audited:
   - [Changes since audit](https://github.com/paulmillr/scure-btc-signer/compare/0.3.0..main).
   - The audit has been funded by [Ryan Shea](https://shea.io)
 
-UTXO selection functionality has not been audited yet. Commit [58d4554](58d455480919e968aabff132503560effb2f8eaf)
+MuSig2 and UTXO selection has not been audited yet.
+Commit [58d4554](58d455480919e968aabff132503560effb2f8eaf)
 split the library from one into several files to ease future maintainability.
 
+If you see anything unusual: investigate and report.
+
 ### Supply chain security
 
-1. **Commits** are signed with PGP keys, to prevent forgery. Make sure to verify commit signatures.
-2. **Releases** are transparent and built on GitHub CI. Make sure to verify [provenance](https://docs.npmjs.com/generating-provenance-statements) logs
-3. **Rare releasing** is followed.
-   The less often it is done, the less code dependents would need to audit
-4. **Dependencies** are minimal:
-   - All deps are prevented from automatic updates and have locked-down version ranges. Every update is checked with `npm-diff`
-   - Updates themselves are rare, to ensure rogue updates are not catched accidentally
-   - [noble-hashes](https://github.com/paulmillr/noble-hashes) provides hashing functionality
-   - [noble-curves](https://github.com/paulmillr/noble-curves) provides elliptic curve cryptography
-   - [scure-base](https://github.com/paulmillr/scure-base) provides bech32 / base64
-   - [micro-packed](https://github.com/paulmillr/micro-packed) provides binary encoding - it has not been audited
-5. devDependencies are only used if you want to contribute to the repo. They are disabled for end-users:
-   - scure-bip32, micro-packed-debugger and micro-should are developed by the same author and follow identical security practices
-   - prettier (linter), fast-check (property-based testing) and typescript are used for code quality, vector generation and ts compilation. The packages are big, which makes it hard to audit their source code thoroughly and fully
-
-We consider infrastructure attacks like rogue NPM modules very important;
-that's why it's crucial to minimize the amount of 3rd-party dependencies & native bindings.
-If your app uses 500 dependencies, any dep could get hacked and you'll be
-downloading malware with every install. Our goal is to minimize this attack vector.
+- **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
+- **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
 
-If you see anything unusual: investigate and report.
+For this package, there are 4 dependencies; and a few dev dependencies:
+
+- [noble-hashes](https://github.com/paulmillr/noble-hashes) provides cryptographic hashing functionality
+- [noble-curves](https://github.com/paulmillr/noble-curves) provides secp256k1 elliptic curve
+- [scure-base](https://github.com/paulmillr/scure-base) provides base58 and bech32
+- [micro-packed](https://github.com/paulmillr/micro-packed) is responsible for binary encoding
+- 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
 
 ## License
 

package/esm/musig2.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Represents a pair of public and secret nonces used in MuSig2 signing.
+ */
+export type Nonces = {
+    public: Uint8Array;
+    secret: Uint8Array;
+};
+/**
+ * Represents a deterministic nonce, including its public part and the resulting partial signature.
+ */
+export type DetNonce = {
+    publicNonce: Uint8Array;
+    partialSig: Uint8Array;
+};
+/**
+ * Represents an error indicating an invalid contribution from a signer.
+ * This allows pointing out which participant is malicious and what specifically is wrong.
+ */
+export declare class InvalidContributionErr extends Error {
+    readonly idx: number;
+    constructor(idx: number, m: string);
+}
+export declare function IndividualPubkey(seckey: Uint8Array): Uint8Array;
+/**
+ * Lexicographically sorts an array of public keys.
+ * @param publicKeys An array of public keys (Uint8Array).
+ * @returns A new array containing the sorted public keys.
+ * @throws {Error} If the input is not an array or if any element is not a Uint8Array of the correct length.
+ */
+export declare function sortKeys(publicKeys: Uint8Array[]): Uint8Array[];
+/**
+ * Aggregates multiple public keys using the MuSig2 key aggregation algorithm.
+ * @param publicKeys An array of individual public keys (Uint8Array).
+ * @param tweaks An optional array of tweaks (Uint8Array) to apply to the aggregate public key.
+ * @param isXonly An optional array of booleans indicating whether each tweak is an X-only tweak.
+ * @returns An object containing the aggregate public key, accumulated sign, and accumulated tweak.
+ * @throws {Error} If the input is invalid, such as non array publicKeys, tweaks and isXonly array length not matching.
+ * @throws {InvalidContributionErr} If any of the public keys are invalid and cannot be processed.
+ */
+export declare function keyAggregate(publicKeys: Uint8Array[], tweaks?: Uint8Array[], isXonly?: boolean[]): {
+    aggPublicKey: import("@noble/curves/abstract/weierstrass").ProjPointType<bigint>;
+    gAcc: bigint;
+    tweakAcc: bigint;
+};
+/**
+ * Exports the aggregate public key to a byte array.
+ * @param ctx The result of the keyAggregate function.
+ * @returns The aggregate public key as a byte array.
+ */
+export declare function keyAggExport(ctx: ReturnType<typeof keyAggregate>): Uint8Array<ArrayBufferLike>;
+/**
+ * Generates a nonce pair (public and secret) for MuSig2 signing.
+ * @param publicKey The individual public key of the signer (Uint8Array).
+ * @param secretKey The secret key of the signer (Uint8Array). Optional, included to xor randomness
+ * @param aggPublicKey The aggregate public key of all signers (Uint8Array).
+ * @param msg The message to be signed (Uint8Array).
+ * @param extraIn Extra input for nonce generation (Uint8Array).
+ * @param rand Random 32-bytes for generating the nonces (Uint8Array).
+ * @returns An object containing the public and secret nonces.
+ * @throws {Error} If the input is invalid, such as non array publicKey, secretKey, aggPublicKey.
+ */
+export declare function nonceGen(publicKey: Uint8Array, secretKey?: Uint8Array, aggPublicKey?: Uint8Array, msg?: Uint8Array, extraIn?: Uint8Array, rand?: Uint8Array): Nonces;
+/**
+ * Aggregates public nonces from multiple signers into a single aggregate nonce.
+ * @param pubNonces An array of public nonces from each signer (Uint8Array). Each pubnonce is assumed to be 66 bytes (two 33‐byte parts).
+ * @returns The aggregate nonce (Uint8Array).
+ * @throws {Error} If the input is not an array or if any element is not a Uint8Array of the correct length.
+ * @throws {InvalidContributionErr} If any of the public nonces are invalid and cannot be processed.
+ */
+export declare function nonceAggregate(pubNonces: Uint8Array[]): Uint8Array;
+export declare class Session {
+    private publicKeys;
+    private Q;
+    private gAcc;
+    private tweakAcc;
+    private b;
+    private R;
+    private e;
+    private tweaks;
+    private isXonly;
+    private L;
+    private secondKey;
+    /**
+     * Constructor for the Session class.
+     * It precomputes and stores values derived from the aggregate nonce, public keys,
+     * message, and optional tweaks, optimizing the signing process.
+     * @param aggNonce The aggregate nonce (Uint8Array) from all participants combined, must be 66 bytes.
+     * @param publicKeys An array of public keys (Uint8Array) from each participant, must be 33 bytes.
+     * @param msg The message (Uint8Array) to be signed.
+     * @param tweaks Optional array of tweaks (Uint8Array) to be applied to the aggregate public key, each must be 32 bytes. Defaults to [].
+     * @param isXonly Optional array of booleans indicating whether each tweak is an X-only tweak. Defaults to [].
+     * @throws {Error} If the input is invalid, such as wrong array sizes or lengths.
+     */
+    constructor(aggNonce: Uint8Array, publicKeys: Uint8Array[], msg: Uint8Array, tweaks?: Uint8Array[], isXonly?: boolean[]);
+    /**
+     * Calculates the key aggregation coefficient for a given point.
+     * @private
+     * @param P The point to calculate the coefficient for.
+     * @returns The key aggregation coefficient as a bigint.
+     * @throws {Error} If the provided public key is not included in the list of pubkeys.
+     */
+    private getSessionKeyAggCoeff;
+    private partialSigVerifyInternal;
+    /**
+     * Generates a partial signature for a given message, secret nonce, secret key, and session context.
+     * @param secretNonce The secret nonce for this signing session (Uint8Array). MUST be securely erased after use.
+     * @param secret The secret key of the signer (Uint8Array).
+     * @param sessionCtx The session context containing all necessary information for signing.
+     * @param fastSign if set to true, the signature is created without checking validity.
+     * @returns The partial signature (Uint8Array).
+     * @throws {Error} If the input is invalid, such as wrong array sizes, invalid nonce or secret key.
+     */
+    sign(secretNonce: Uint8Array, secret: Uint8Array, fastSign?: boolean): Uint8Array;
+    /**
+     * Verifies a partial signature against the aggregate public key and other session parameters.
+     * @param partialSig The partial signature to verify (Uint8Array).
+     * @param pubNonces An array of public nonces from each signer (Uint8Array).
+     * @param pubKeys An array of public keys from each signer (Uint8Array).
+     * @param tweaks An array of tweaks applied to the aggregate public key.
+     * @param isXonly An array of booleans indicating whether each tweak is an X-only tweak.
+     * @param msg The message that was signed (Uint8Array).
+     * @param i The index of the signer whose partial signature is being verified.
+     * @returns True if the partial signature is valid, false otherwise.
+     * @throws {Error} If the input is invalid, such as non array partialSig, pubNonces, pubKeys, tweaks.
+     */
+    partialSigVerify(partialSig: Uint8Array, pubNonces: Uint8Array[], i: number): boolean;
+    /**
+     * Aggregates partial signatures from multiple signers into a single final signature.
+     * @param partialSigs An array of partial signatures from each signer (Uint8Array).
+     * @param sessionCtx The session context containing all necessary information for signing.
+     * @returns The final aggregate signature (Uint8Array).
+     * @throws {Error} If the input is invalid, such as wrong array sizes, invalid signature.
+     */
+    partialSigAgg(partialSigs: Uint8Array[]): Uint8Array;
+}
+/**
+ * Generates a nonce pair and partial signature deterministically for a single signer.
+ * @param secret The secret key of the signer (Uint8Array).
+ * @param aggOtherNonce The aggregate public nonce of all other signers (Uint8Array).
+ * @param publicKeys An array of all signers' public keys (Uint8Array).
+ * @param tweaks An array of tweaks to apply to the aggregate public key.
+ * @param isXonly An array of booleans indicating whether each tweak is an X-only tweak.
+ * @param msg The message to be signed (Uint8Array).
+ * @param rand Optional extra randomness (Uint8Array).
+ * @returns An object containing the public nonce and partial signature.
+ */
+export declare function deterministicSign(secret: Uint8Array, aggOtherNonce: Uint8Array, publicKeys: Uint8Array[], msg: Uint8Array, tweaks?: Uint8Array[], isXonly?: boolean[], rand?: Uint8Array, fastSign?: boolean): DetNonce;
+//# sourceMappingURL=musig2.d.ts.map

package/esm/musig2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"musig2.d.ts","sourceRoot":"","sources":["../src/musig2.ts"],"names":[],"mappings":"AA0BA;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC;AAChE;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IAAE,WAAW,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAC3E;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;gBACT,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;CAInC;AA8CD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAE/D;AASD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAG/D;AA0BD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EAAE,EACxB,MAAM,GAAE,UAAU,EAAO,EACzB,OAAO,GAAE,OAAO,EAAO;;;;EAgCxB;AACD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,+BAEhE;AA+BD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,UAAU,EACrB,SAAS,CAAC,EAAE,UAAU,EACtB,YAAY,GAAE,UAA8B,EAC5C,GAAG,CAAC,EAAE,UAAU,EAChB,OAAO,GAAE,UAA8B,EACvC,IAAI,GAAE,UAA4B,GACjC,MAAM,CAmBR;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,UAAU,EAAE,GAAG,UAAU,CAgBlE;AAID,qBAAa,OAAO;IAClB,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,CAAC,CAAQ;IACjB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,CAAC,CAAS;IAClB,OAAO,CAAC,CAAC,CAAQ;IACjB,OAAO,CAAC,CAAC,CAAS;IAClB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,CAAC,CAAa;IACtB,OAAO,CAAC,SAAS,CAAa;IAC9B;;;;;;;;;;OAUG;gBAED,QAAQ,EAAE,UAAU,EACpB,UAAU,EAAE,UAAU,EAAE,EACxB,GAAG,EAAE,UAAU,EACf,MAAM,GAAE,UAAU,EAAO,EACzB,OAAO,GAAE,OAAO,EAAO;IAuBzB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,wBAAwB;IAmBhC;;;;;;;;OAQG;IACH,IAAI,CAAC,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,UAAQ,GAAG,UAAU;IAiC/E;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAerF;;;;;;OAMG;IACH,aAAa,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU;CAarD;AAmBD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,UAAU,EACzB,UAAU,EAAE,UAAU,EAAE,EACxB,GAAG,EAAE,UAAU,EACf,MAAM,GAAE,UAAU,EAAO,EACzB,OAAO,GAAE,OAAO,EAAO,EACvB,IAAI,CAAC,EAAE,UAAU,EACjB,QAAQ,UAAQ,GACf,QAAQ,CAmBV"}