@ckb-ccc/core 1.18.2 → 1.19.1

package/dist.commonjs/advanced.d.ts

@@ -1,2 +1,2 @@
-import { A as DEP_TYPES, C as DEFAULT_CONFIRMED_BLOCK_TIME, Cn as ClientCollectableSearchKeyLike, D as filterNumByRange, E as filterData, En as clientSearchKeyRangeFrom, F as NUM_TO_HASH_TYPE, Fr as TransportWebSocket, I as ADDRESS_BECH32_LIMIT, Ir as TransportHttp, L as AddressFormat, Lr as JsonRpcPayload, M as NUM_TO_DEP_TYPE, N as HASH_TYPES, Nr as TransportFallback, O as filterScript, P as HASH_TYPE_TO_NUM, Pr as transportFromUri, R as addressFromPayload, Rr as Transport, S as CellRecord, Sn as ClientCollectableSearchKeyFilterLike, T as filterCell, Tn as DEFAULT_MIN_FEE_RATE, _ as JsonRpcOutPoint, a as JsonRpcBlockHeader, b as TESTNET_SCRIPTS, c as JsonRpcCellInput, d as JsonRpcHashType, f as JsonRpcIndexerFindTransactionsGroupedResponse, g as JsonRpcIndexerSearchKeyTransaction, h as JsonRpcIndexerSearchKeyFilter, i as JsonRpcBlock, j as DEP_TYPE_TO_NUM, k as filterScriptByLenRange, l as JsonRpcCellOutput, m as JsonRpcIndexerSearchKey, n as CKB_BLAKE2B_PERSONAL, o as JsonRpcBlockUncle, p as JsonRpcIndexerFindTransactionsResponse, pa as BytesFromEncoding, r as JsonRpcTransformers, s as JsonRpcCellDep, t as advancedBarrel_d_exports, u as JsonRpcDepType, v as JsonRpcScript, w as MapLru, wn as DEFAULT_MAX_FEE_RATE, x as MAINNET_SCRIPTS, y as JsonRpcTransaction, z as addressPayloadFromString } from "./advancedBarrel-CJAh6sm8.js";
+import { A as DEP_TYPES, C as DEFAULT_CONFIRMED_BLOCK_TIME, Cn as ClientCollectableSearchKeyLike, D as filterNumByRange, E as filterData, En as clientSearchKeyRangeFrom, F as NUM_TO_HASH_TYPE, Fr as TransportWebSocket, I as ADDRESS_BECH32_LIMIT, Ir as TransportHttp, L as AddressFormat, Lr as JsonRpcPayload, M as NUM_TO_DEP_TYPE, N as HASH_TYPES, Nr as TransportFallback, O as filterScript, P as HASH_TYPE_TO_NUM, Pr as transportFromUri, R as addressFromPayload, Rr as Transport, S as CellRecord, Sn as ClientCollectableSearchKeyFilterLike, T as filterCell, Tn as DEFAULT_MIN_FEE_RATE, _ as JsonRpcOutPoint, a as JsonRpcBlockHeader, b as TESTNET_SCRIPTS, c as JsonRpcCellInput, d as JsonRpcHashType, f as JsonRpcIndexerFindTransactionsGroupedResponse, g as JsonRpcIndexerSearchKeyTransaction, h as JsonRpcIndexerSearchKeyFilter, ha as BytesFromEncoding, i as JsonRpcBlock, j as DEP_TYPE_TO_NUM, k as filterScriptByLenRange, l as JsonRpcCellOutput, m as JsonRpcIndexerSearchKey, n as CKB_BLAKE2B_PERSONAL, o as JsonRpcBlockUncle, p as JsonRpcIndexerFindTransactionsResponse, r as JsonRpcTransformers, s as JsonRpcCellDep, t as advancedBarrel_d_exports, u as JsonRpcDepType, v as JsonRpcScript, w as MapLru, wn as DEFAULT_MAX_FEE_RATE, x as MAINNET_SCRIPTS, y as JsonRpcTransaction, z as addressPayloadFromString } from "./advancedBarrel-CSQ2SmeJ.js";
 export { ADDRESS_BECH32_LIMIT, AddressFormat, BytesFromEncoding, CKB_BLAKE2B_PERSONAL, CellRecord, ClientCollectableSearchKeyFilterLike, ClientCollectableSearchKeyLike, DEFAULT_CONFIRMED_BLOCK_TIME, DEFAULT_MAX_FEE_RATE, DEFAULT_MIN_FEE_RATE, DEP_TYPES, DEP_TYPE_TO_NUM, HASH_TYPES, HASH_TYPE_TO_NUM, JsonRpcBlock, JsonRpcBlockHeader, JsonRpcBlockUncle, JsonRpcCellDep, JsonRpcCellInput, JsonRpcCellOutput, JsonRpcDepType, JsonRpcHashType, JsonRpcIndexerFindTransactionsGroupedResponse, JsonRpcIndexerFindTransactionsResponse, JsonRpcIndexerSearchKey, JsonRpcIndexerSearchKeyFilter, JsonRpcIndexerSearchKeyTransaction, JsonRpcOutPoint, JsonRpcPayload, JsonRpcScript, JsonRpcTransaction, JsonRpcTransformers, MAINNET_SCRIPTS, MapLru, NUM_TO_DEP_TYPE, NUM_TO_HASH_TYPE, TESTNET_SCRIPTS, Transport, TransportFallback, TransportHttp, TransportWebSocket, addressFromPayload, addressPayloadFromString, advancedBarrel_d_exports as cccA, clientSearchKeyRangeFrom, filterCell, filterData, filterNumByRange, filterScript, filterScriptByLenRange, transportFromUri };

package/dist.commonjs/advanced.js

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./address.advanced-BAaFklsW.js"),t=require("./advancedBarrel.js");exports.ADDRESS_BECH32_LIMIT=e.t,exports.AddressFormat=e.n,exports.CKB_BLAKE2B_PERSONAL=e.gr,exports.DEFAULT_CONFIRMED_BLOCK_TIME=e.Y,exports.DEFAULT_MAX_FEE_RATE=e.vt,exports.DEFAULT_MIN_FEE_RATE=e.yt,exports.DEP_TYPES=e.O,exports.DEP_TYPE_TO_NUM=e.k,exports.HASH_TYPES=e.R,exports.HASH_TYPE_TO_NUM=e.z,exports.JsonRpcTransformers=e.H,exports.MAINNET_SCRIPTS=e.q,exports.MapLru=e.X,exports.NUM_TO_DEP_TYPE=e.A,exports.NUM_TO_HASH_TYPE=e.B,exports.TESTNET_SCRIPTS=e.V,exports.TransportFallback=e.U,exports.TransportHttp=e.K,exports.TransportWebSocket=e.G,exports.addressFromPayload=e.r,exports.addressPayloadFromString=e.i,Object.defineProperty(exports,"cccA",{enumerable:!0,get:function(){return t.t}}),exports.clientSearchKeyRangeFrom=e.bt,exports.filterCell=e.Z,exports.filterData=e.Q,exports.filterNumByRange=e.$,exports.filterScript=e.et,exports.filterScriptByLenRange=e.tt,exports.transportFromUri=e.W;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./address.advanced-BTrmYDic.js"),t=require("./advancedBarrel.js");exports.ADDRESS_BECH32_LIMIT=e.t,exports.AddressFormat=e.n,exports.CKB_BLAKE2B_PERSONAL=e.gr,exports.DEFAULT_CONFIRMED_BLOCK_TIME=e.Y,exports.DEFAULT_MAX_FEE_RATE=e.vt,exports.DEFAULT_MIN_FEE_RATE=e.yt,exports.DEP_TYPES=e.O,exports.DEP_TYPE_TO_NUM=e.k,exports.HASH_TYPES=e.R,exports.HASH_TYPE_TO_NUM=e.z,exports.JsonRpcTransformers=e.H,exports.MAINNET_SCRIPTS=e.q,exports.MapLru=e.X,exports.NUM_TO_DEP_TYPE=e.A,exports.NUM_TO_HASH_TYPE=e.B,exports.TESTNET_SCRIPTS=e.V,exports.TransportFallback=e.U,exports.TransportHttp=e.K,exports.TransportWebSocket=e.G,exports.addressFromPayload=e.r,exports.addressPayloadFromString=e.i,Object.defineProperty(exports,"cccA",{enumerable:!0,get:function(){return t.t}}),exports.clientSearchKeyRangeFrom=e.bt,exports.filterCell=e.Z,exports.filterData=e.Q,exports.filterNumByRange=e.$,exports.filterScript=e.et,exports.filterScriptByLenRange=e.tt,exports.transportFromUri=e.W;

package/{dist/advancedBarrel-BbbHx4z4.d.mts → dist.commonjs/advancedBarrel-CSQ2SmeJ.d.ts}

@@ -1,3 +1,4 @@
+//#endregion
 //#region src/bytes/advanced.d.ts
 /**
  * Represents the possible encoding formats for converting bytes.
@@ -525,6 +526,54 @@ declare function numLeFromBytes(val: BytesLike): Num;
  */
 declare function numBeFromBytes(val: BytesLike): Num;
 //#endregion
+//#region src/utils/constructor.d.ts
+type Constructor<T, Args extends any[] = any[]> = new (...args: Args) => T;
+type AbstractConstructor<T, Args extends any[] = any[]> = abstract new (...args: Args) => T;
+//#endregion
+//#region src/utils/proxy.d.ts
+/**
+ * Utilities for creating composition wrappers.
+ *
+ * @example
+ * ```ts
+ * class Wrapper extends Proxy.Base(Client) {
+ *   static readonly [Proxy.localKeys] = ["feeRate"];
+ *   public feeRate = 1000;
+ *
+ *   request(): void {
+ *     this[Proxy.inner].request();
+ *   }
+ * }
+ *
+ * const wrapper = new Wrapper(client);
+ * ```
+ *
+ * @public
+ */
+declare namespace Proxy {
+  /** The property key for accessing the immediately wrapped object. */
+  const inner = "@ckb-ccc/core.Proxy.inner";
+  /**
+   * The static metadata key for instance fields that belong to the wrapper.
+   * Every wrapper instance field must be listed here. Prototype members are
+   * detected automatically.
+   */
+  const localKeys: unique symbol;
+  /**
+   * Creates a wrapper base that delegates non-local members to an inner instance.
+   * Its constructor accepts the inner instance and does not invoke `BaseClass`.
+   *
+   * @remarks
+   * Wrapping an abstract class may require suppressing TS2655 because its abstract
+   * members are implemented by runtime delegation.
+   *
+   * @param BaseClass - The class represented by the wrapper.
+   */
+  function Base<BaseClass extends AbstractConstructor<object>>(BaseClass: BaseClass): Omit<BaseClass, "prototype"> & Constructor<InstanceType<BaseClass> & {
+    readonly [inner]: InstanceType<BaseClass>;
+  }, [InstanceType<BaseClass>]>;
+}
+//#endregion
 //#region src/utils/index.d.ts
 /**
  * A type safe way to apply a transformer on a value if it's not empty.
@@ -610,9 +659,6 @@ declare function reduceAsync<T>(values: T[], accumulator: (a: T, b: T) => Promis
  */
 declare function reduceAsync<T, V>(values: V[], accumulator: (a: T, b: V, i: number, values: V[]) => Promise<T | undefined | null | void> | T | undefined | null | void, init: T | Promise<T>): Promise<T>;
 declare function sleep(ms: NumLike): Promise<unknown>;
-type Constructor<T, Args extends any[] = any[]> = {
-  new (...args: Args): T;
-};
 /**
  * @public
  */
@@ -1566,21 +1612,12 @@ declare enum SignerType {
 }
 /**
  * @public
+ * @deprecated Wallet integrations now expose one signer per selectable network.
+ * This compatibility type will be removed in the next major release.
  */
 type NetworkPreference = {
   addressPrefix: string;
   signerType: SignerType;
-  /**
-   * Wallet signers should check if the wallet is using preferred networks.
-   * If not, try to switch to the first preferred network.
-   * If non preferred, let users choose what they want.
-   * BTC: // They made a mess...
-   *   btc
-   *   btcTestnet
-   *   btcTestnet4 // UTXO Global
-   *   btcSignet // OKX & UTXO Global
-   *   fractalBtc // UniSat
-   */
   network: string;
 };
 /**
@@ -1603,6 +1640,9 @@ declare abstract class Signer {
   abstract get type(): SignerType;
   abstract get signType(): SignerSignType;
   get client(): Client;
+  /**
+   * @deprecated Wallet integrations now use fixed-network signers.
+   */
   matchNetworkPreference(preferences: NetworkPreference[], currentNetwork: string | undefined): NetworkPreference | undefined;
   static verifyMessage(message: string | BytesLike, signature: Signature): Promise<boolean>;
   /**
@@ -2935,7 +2975,7 @@ declare function buildNostrEventFromMessage(message: string | BytesLike): NostrE
 declare function nostrEventHash(event: NostrEvent): Bytes$1;
 declare function verifyMessageNostrEvent(message: string | BytesLike, signature: string, address: string): boolean;
 declare namespace barrel_d_exports {
-  export { Address, AddressLike, Bytes$1 as Bytes, BytesLike, Cell, CellAny, CellAnyLike, CellDep, CellDepInfo, CellDepInfoLike, CellDepLike, CellDepVec, CellInput, CellInputLike, CellInputVec, CellLike, CellOutput, CellOutputLike, CellOutputVec, Client, ClientBlock, ClientBlockHeader, ClientBlockHeaderLike, ClientBlockLike, ClientBlockUncle, ClientBlockUncleLike, ClientCache, ClientCacheMemory, ClientFindCellsResponse, ClientFindTransactionsGroupedResponse, ClientFindTransactionsResponse, ClientIndexerSearchKey, ClientIndexerSearchKeyFilter, ClientIndexerSearchKeyFilterLike, ClientIndexerSearchKeyLike, ClientIndexerSearchKeyTransaction, ClientIndexerSearchKeyTransactionLike, ClientJsonRpc, ClientJsonRpcConfig, ClientPublicMainnet, ClientPublicTestnet, ClientTransactionResponse, ClientTransactionResponseLike, Codec, CodecBool, CodecByte, CodecByte16, CodecByte32, CodecByte4, CodecByte8, CodecBytes, CodecLike, CodecRaw, CodecUint128, CodecUint128BE, CodecUint128LE, CodecUint16, CodecUint16BE, CodecUint16LE, CodecUint256, CodecUint256BE, CodecUint256LE, CodecUint32, CodecUint32BE, CodecUint32LE, CodecUint512, CodecUint512BE, CodecUint512LE, CodecUint64, CodecUint64BE, CodecUint64LE, CodecUint8, Constructor, DecodedType, DepType, DepTypeCodec, DepTypeLike, EncodableType, Entity, Epoch, EpochLike, ErrorClientBase, ErrorClientBaseLike, ErrorClientDuplicatedTransaction, ErrorClientMaxFeeRateExceeded, ErrorClientRBFRejected, ErrorClientResolveUnknown, ErrorClientVerification, ErrorClientWaitTransactionTimeout, ErrorTransactionInsufficientCapacity, ErrorTransactionInsufficientCoin, FixedPoint, FixedPointLike, HASH_CKB_LENGTH, HASH_CKB_SHORT_LENGTH, HashType, HashTypeCodec, HashTypeLike, Hasher, HasherCkb, HasherKeecak256, Hex, HexLike, InputToSign, InputToSignLike, KnownScript, LumosTransactionSkeletonType, MultisigCkbWitness, MultisigCkbWitnessLike, NetworkPreference, NostrEvent, Num, NumLike, One, OutPoint, OutPointLike, OutputsValidator, RawTransaction, RequestorJsonRpc, RequestorJsonRpcConfig, SECP256K1_SIGNATURE_LENGTH, Script, ScriptInfo, ScriptInfoLike, ScriptLike, ScriptOpt, ScriptVec, SignPsbtOptions, SignPsbtOptionsLike, Signature, Signer, SignerAlwaysError, SignerBtc, SignerBtcPublicKeyReadonly, SignerCkbAlwaysSuccess, SignerCkbPrivateKey, SignerCkbPublicKey, SignerCkbScriptReadonly, SignerDoge, SignerDogeAddressReadonly, SignerDogePrivateKey, SignerDummy, SignerEvm, SignerEvmAddressReadonly, SignerInfo, SignerMultisig, SignerMultisigCkbPrivateKey, SignerMultisigCkbReadonly, SignerMultisigNotEnoughSignaturesError, SignerNostr, SignerNostrPrivateKey, SignerNostrPublicKeyReadonly, SignerOpenLink, SignerSignType, SignerType, Since, SinceLike, Transaction, TransactionLike, TransactionStatus, Wallet, WitnessArgs, WitnessArgsLike, Zero, apply, btcEcdsaPublicKeyHash, btcP2pkhAddressFromPublicKey, btcPublicKeyFromP2pkhAddress, btcVarLengthBytesFrom, buildNostrEventFromMessage, bytesConcat, bytesConcatTo, bytesEq, bytesFrom, bytesLen, bytesLenUnsafe, bytesTo, calcDaoClaimEpoch, calcDaoProfit, codec, codecPadding, codecUint, codecUintNumber, depTypeFrom, depTypeFromBytes, depTypeToBytes, epochFrom, epochFromHex, epochToHex, fixedPointFrom, fixedPointToString, gcd, hashCkb, hashCkbShort, hashTypeFrom, hashTypeFromBytes, hashTypeId, hashTypeToBytes, hexFrom, isDaoOutputLimitExceeded, isWebview, keystoreDecrypt, keystoreEncrypt, messageHashBtcEcdsa, messageHashCkbSecp256k1, messageHashDogeEcdsa, barrel_d_exports$1 as mol, nostrEventHash, numBeFromBytes, numBeToBytes, numFrom, numFromBytes, numLeFromBytes, numLeToBytes, numMax, numMin, numToBytes, numToHex, recoverMessageSecp256k1, reduceAsync, signMessageSecp256k1, sleep, stringify, udtBalanceFrom, verifyMessageBtcEcdsa, verifyMessageCkbSecp256k1, verifyMessageDogeEcdsa, verifyMessageEvmPersonal, verifyMessageJoyId, verifyMessageNostrEvent, verifyMessageSecp256k1 };
+  export { AbstractConstructor, Address, AddressLike, Bytes$1 as Bytes, BytesLike, Cell, CellAny, CellAnyLike, CellDep, CellDepInfo, CellDepInfoLike, CellDepLike, CellDepVec, CellInput, CellInputLike, CellInputVec, CellLike, CellOutput, CellOutputLike, CellOutputVec, Client, ClientBlock, ClientBlockHeader, ClientBlockHeaderLike, ClientBlockLike, ClientBlockUncle, ClientBlockUncleLike, ClientCache, ClientCacheMemory, ClientFindCellsResponse, ClientFindTransactionsGroupedResponse, ClientFindTransactionsResponse, ClientIndexerSearchKey, ClientIndexerSearchKeyFilter, ClientIndexerSearchKeyFilterLike, ClientIndexerSearchKeyLike, ClientIndexerSearchKeyTransaction, ClientIndexerSearchKeyTransactionLike, ClientJsonRpc, ClientJsonRpcConfig, ClientPublicMainnet, ClientPublicTestnet, ClientTransactionResponse, ClientTransactionResponseLike, Codec, CodecBool, CodecByte, CodecByte16, CodecByte32, CodecByte4, CodecByte8, CodecBytes, CodecLike, CodecRaw, CodecUint128, CodecUint128BE, CodecUint128LE, CodecUint16, CodecUint16BE, CodecUint16LE, CodecUint256, CodecUint256BE, CodecUint256LE, CodecUint32, CodecUint32BE, CodecUint32LE, CodecUint512, CodecUint512BE, CodecUint512LE, CodecUint64, CodecUint64BE, CodecUint64LE, CodecUint8, Constructor, DecodedType, DepType, DepTypeCodec, DepTypeLike, EncodableType, Entity, Epoch, EpochLike, ErrorClientBase, ErrorClientBaseLike, ErrorClientDuplicatedTransaction, ErrorClientMaxFeeRateExceeded, ErrorClientRBFRejected, ErrorClientResolveUnknown, ErrorClientVerification, ErrorClientWaitTransactionTimeout, ErrorTransactionInsufficientCapacity, ErrorTransactionInsufficientCoin, FixedPoint, FixedPointLike, HASH_CKB_LENGTH, HASH_CKB_SHORT_LENGTH, HashType, HashTypeCodec, HashTypeLike, Hasher, HasherCkb, HasherKeecak256, Hex, HexLike, InputToSign, InputToSignLike, KnownScript, LumosTransactionSkeletonType, MultisigCkbWitness, MultisigCkbWitnessLike, NetworkPreference, NostrEvent, Num, NumLike, One, OutPoint, OutPointLike, OutputsValidator, Proxy, RawTransaction, RequestorJsonRpc, RequestorJsonRpcConfig, SECP256K1_SIGNATURE_LENGTH, Script, ScriptInfo, ScriptInfoLike, ScriptLike, ScriptOpt, ScriptVec, SignPsbtOptions, SignPsbtOptionsLike, Signature, Signer, SignerAlwaysError, SignerBtc, SignerBtcPublicKeyReadonly, SignerCkbAlwaysSuccess, SignerCkbPrivateKey, SignerCkbPublicKey, SignerCkbScriptReadonly, SignerDoge, SignerDogeAddressReadonly, SignerDogePrivateKey, SignerDummy, SignerEvm, SignerEvmAddressReadonly, SignerInfo, SignerMultisig, SignerMultisigCkbPrivateKey, SignerMultisigCkbReadonly, SignerMultisigNotEnoughSignaturesError, SignerNostr, SignerNostrPrivateKey, SignerNostrPublicKeyReadonly, SignerOpenLink, SignerSignType, SignerType, Since, SinceLike, Transaction, TransactionLike, TransactionStatus, Wallet, WitnessArgs, WitnessArgsLike, Zero, apply, btcEcdsaPublicKeyHash, btcP2pkhAddressFromPublicKey, btcPublicKeyFromP2pkhAddress, btcVarLengthBytesFrom, buildNostrEventFromMessage, bytesConcat, bytesConcatTo, bytesEq, bytesFrom, bytesLen, bytesLenUnsafe, bytesTo, calcDaoClaimEpoch, calcDaoProfit, codec, codecPadding, codecUint, codecUintNumber, depTypeFrom, depTypeFromBytes, depTypeToBytes, epochFrom, epochFromHex, epochToHex, fixedPointFrom, fixedPointToString, gcd, hashCkb, hashCkbShort, hashTypeFrom, hashTypeFromBytes, hashTypeId, hashTypeToBytes, hexFrom, isDaoOutputLimitExceeded, isWebview, keystoreDecrypt, keystoreEncrypt, messageHashBtcEcdsa, messageHashCkbSecp256k1, messageHashDogeEcdsa, barrel_d_exports$1 as mol, nostrEventHash, numBeFromBytes, numBeToBytes, numFrom, numFromBytes, numLeFromBytes, numLeToBytes, numMax, numMin, numToBytes, numToHex, recoverMessageSecp256k1, reduceAsync, signMessageSecp256k1, sleep, stringify, udtBalanceFrom, verifyMessageBtcEcdsa, verifyMessageCkbSecp256k1, verifyMessageDogeEcdsa, verifyMessageEvmPersonal, verifyMessageJoyId, verifyMessageNostrEvent, verifyMessageSecp256k1 };
 }
 //#endregion
 //#region src/client/clientTypes.advanced.d.ts
@@ -7068,5 +7108,5 @@ declare namespace advancedBarrel_d_exports {
   export { ADDRESS_BECH32_LIMIT, AddressFormat, BytesFromEncoding, CKB_BLAKE2B_PERSONAL, CellRecord, ClientCollectableSearchKeyFilterLike, ClientCollectableSearchKeyLike, DEFAULT_CONFIRMED_BLOCK_TIME, DEFAULT_MAX_FEE_RATE, DEFAULT_MIN_FEE_RATE, DEP_TYPES, DEP_TYPE_TO_NUM, HASH_TYPES, HASH_TYPE_TO_NUM, JsonRpcBlock, JsonRpcBlockHeader, JsonRpcBlockUncle, JsonRpcCellDep, JsonRpcCellInput, JsonRpcCellOutput, JsonRpcDepType, JsonRpcHashType, JsonRpcIndexerFindTransactionsGroupedResponse, JsonRpcIndexerFindTransactionsResponse, JsonRpcIndexerSearchKey, JsonRpcIndexerSearchKeyFilter, JsonRpcIndexerSearchKeyTransaction, JsonRpcOutPoint, JsonRpcPayload, JsonRpcScript, JsonRpcTransaction, JsonRpcTransformers, MAINNET_SCRIPTS, MapLru, NUM_TO_DEP_TYPE, NUM_TO_HASH_TYPE, TESTNET_SCRIPTS, Transport, TransportFallback, TransportHttp, TransportWebSocket, addressFromPayload, addressPayloadFromString, clientSearchKeyRangeFrom, filterCell, filterData, filterNumByRange, filterScript, filterScriptByLenRange, transportFromUri };
 }
 //#endregion
-export { CellDep as $, Address as $i, SignerCkbPublicKey as $n, CodecByte as $r, ClientFindCellsResponse as $t, DEP_TYPES as A, Constructor as Ai, verifyMessageNostrEvent as An, keystoreEncrypt as Ar, HashTypeCodec as At, ClientPublicTestnet as B, numBeToBytes as Bi, SignerDummy as Bn, HASH_CKB_LENGTH as Br, Epoch as Bt, DEFAULT_CONFIRMED_BLOCK_TIME as C, CodecUint64LE as Ci, ClientCollectableSearchKeyLike as Cn, Wallet as Cr, depTypeFrom as Ct, filterNumByRange as D, codecUintNumber as Di, barrel_d_exports as Dn, SignPsbtOptionsLike as Dr, udtBalanceFrom as Dt, filterData as E, codecUint as Ei, clientSearchKeyRangeFrom as En, SignPsbtOptions as Er, isDaoOutputLimitExceeded as Et, NUM_TO_HASH_TYPE as F, sleep as Fi, verifyMessageEvmPersonal as Fn, TransportWebSocket as Fr, ScriptVec as Ft, ClientCacheMemory as G, numMax as Gi, SignerDoge as Gn, Hasher as Gr, CellDepInfo as Gt, ClientJsonRpc as H, numFromBytes as Hi, verifyMessageDogeEcdsa as Hn, HasherCkb as Hr, epochFrom as Ht, ADDRESS_BECH32_LIMIT as I, stringify as Ii, SignerEvmAddressReadonly as In, TransportHttp as Ir, hashTypeFrom as It, ErrorTransactionInsufficientCoin as J, numToHex as Ji, MultisigCkbWitness as Jn, One as Jr, ClientBlockHeader as Jt, ClientCache as K, numMin as Ki, verifyMessageJoyId as Kn, FixedPoint as Kr, CellDepInfoLike as Kt, AddressFormat as L, Num as Li, SignerEvm as Ln, JsonRpcPayload as Lr, hashTypeFromBytes as Lt, NUM_TO_DEP_TYPE as M, gcd as Mi, SignerNostrPublicKeyReadonly as Mn, RequestorJsonRpcConfig as Mr, Script as Mt, HASH_TYPES as N, isWebview as Ni, NostrEvent as Nn, TransportFallback as Nr, ScriptLike as Nt, filterScript as O, Entity as Oi, buildNostrEventFromMessage as On, barrel_d_exports$1 as Or, LumosTransactionSkeletonType as Ot, HASH_TYPE_TO_NUM as P, reduceAsync as Pi, SignerNostr as Pn, transportFromUri as Pr, ScriptOpt as Pt, CellAnyLike as Q, EncodableType as Qi, SignerCkbPrivateKey as Qn, CodecBool as Qr, ClientBlockUncleLike as Qt, addressFromPayload as R, NumLike as Ri, SignerOpenLink as Rn, Transport as Rr, hashTypeToBytes as Rt, CellRecord as S, CodecUint64BE as Si, ClientCollectableSearchKeyFilterLike as Sn, SignerType as Sr, calcDaoProfit as St, filterCell as T, codecPadding as Ti, DEFAULT_MIN_FEE_RATE as Tn, InputToSignLike as Tr, depTypeToBytes as Tt, ClientJsonRpcConfig as U, numLeFromBytes as Ui, SignerDogePrivateKey as Un, hashCkb as Ur, epochFromHex as Ut, ClientPublicMainnet as V, numFrom as Vi, messageHashDogeEcdsa as Vn, HASH_CKB_SHORT_LENGTH as Vr, EpochLike as Vt, Client as W, numLeToBytes as Wi, SignerDogeAddressReadonly as Wn, hashCkbShort as Wr, epochToHex as Wt, Cell as X, CodecLike as Xi, SignerMultisigCkbReadonly as Xn, fixedPointFrom as Xr, ClientBlockLike as Xt, hashTypeId as Y, Codec as Yi, MultisigCkbWitnessLike as Yn, Zero as Yr, ClientBlockHeaderLike as Yt, CellAny as Z, DecodedType as Zi, SignerCkbScriptReadonly as Zn, fixedPointToString as Zr, ClientBlockUncle as Zt, JsonRpcOutPoint as _, CodecUint32LE as _i, ErrorClientWaitTransactionTimeout as _n, Signer as _r, Transaction as _t, JsonRpcBlockHeader as a, hexFrom as aa, CodecRaw as ai, ClientIndexerSearchKeyLike as an, verifyMessageCkbSecp256k1 as ar, CellLike as at, TESTNET_SCRIPTS as b, CodecUint512LE as bi, ScriptInfoLike as bn, SignerMultisigNotEnoughSignaturesError as br, WitnessArgsLike as bt, JsonRpcCellInput as c, bytesConcat as ca, CodecUint128LE as ci, ClientTransactionResponse as cn, btcP2pkhAddressFromPublicKey as cr, CellOutputVec as ct, JsonRpcHashType as d, bytesFrom as da, CodecUint16LE as di, ErrorClientBaseLike as dn, messageHashBtcEcdsa as dr, DepTypeLike as dt, AddressLike as ea, CodecByte16 as ei, ClientFindTransactionsGroupedResponse as en, SignerCkbAlwaysSuccess as er, CellDepLike as et, JsonRpcIndexerFindTransactionsGroupedResponse as f, bytesTo as fa, CodecUint256 as fi, ErrorClientDuplicatedTransaction as fn, verifyMessageBtcEcdsa as fr, OutPoint as ft, JsonRpcIndexerSearchKeyTransaction as g, CodecUint32BE as gi, ErrorClientVerification as gn, Signature as gr, SinceLike as gt, JsonRpcIndexerSearchKeyFilter as h, CodecUint32 as hi, ErrorClientResolveUnknown as hn, NetworkPreference as hr, Since as ht, JsonRpcBlock as i, bytesLenUnsafe as ia, CodecBytes as ii, ClientIndexerSearchKeyFilterLike as in, signMessageSecp256k1 as ir, CellInputVec as it, DEP_TYPE_TO_NUM as j, apply as ji, SignerNostrPrivateKey as jn, RequestorJsonRpc as jr, HashTypeLike as jt, filterScriptByLenRange as k, codec as ki, nostrEventHash as kn, keystoreDecrypt as kr, HashType as kt, JsonRpcCellOutput as l, bytesConcatTo as la, CodecUint16 as li, ClientTransactionResponseLike as ln, btcPublicKeyFromP2pkhAddress as lr, DepType as lt, JsonRpcIndexerSearchKey as m, CodecUint256LE as mi, ErrorClientRBFRejected as mn, SignerBtc as mr, RawTransaction as mt, CKB_BLAKE2B_PERSONAL as n, HexLike as na, CodecByte4 as ni, ClientIndexerSearchKey as nn, messageHashCkbSecp256k1 as nr, CellInput as nt, JsonRpcBlockUncle as o, Bytes$1 as oa, CodecUint128 as oi, ClientIndexerSearchKeyTransaction as on, verifyMessageSecp256k1 as or, CellOutput as ot, JsonRpcIndexerFindTransactionsResponse as p, BytesFromEncoding as pa, CodecUint256BE as pi, ErrorClientMaxFeeRateExceeded as pn, SignerBtcPublicKeyReadonly as pr, OutPointLike as pt, ErrorTransactionInsufficientCapacity as q, numToBytes as qi, SignerMultisigCkbPrivateKey as qn, FixedPointLike as qr, ClientBlock as qt, JsonRpcTransformers as r, bytesLen as ra, CodecByte8 as ri, ClientIndexerSearchKeyFilter as rn, recoverMessageSecp256k1 as rr, CellInputLike as rt, JsonRpcCellDep as s, BytesLike as sa, CodecUint128BE as si, ClientIndexerSearchKeyTransactionLike as sn, btcEcdsaPublicKeyHash as sr, CellOutputLike as st, advancedBarrel_d_exports as t, Hex as ta, CodecByte32 as ti, ClientFindTransactionsResponse as tn, SECP256K1_SIGNATURE_LENGTH as tr, CellDepVec as tt, JsonRpcDepType as u, bytesEq as ua, CodecUint16BE as ui, ErrorClientBase as un, btcVarLengthBytesFrom as ur, DepTypeCodec as ut, JsonRpcScript as v, CodecUint512 as vi, OutputsValidator as vn, SignerInfo as vr, TransactionLike as vt, MapLru as w, CodecUint8 as wi, DEFAULT_MAX_FEE_RATE as wn, InputToSign as wr, depTypeFromBytes as wt, MAINNET_SCRIPTS as x, CodecUint64 as xi, TransactionStatus as xn, SignerSignType as xr, calcDaoClaimEpoch as xt, JsonRpcTransaction as y, CodecUint512BE as yi, ScriptInfo as yn, SignerMultisig as yr, WitnessArgs as yt, addressPayloadFromString as z, numBeFromBytes as zi, SignerAlwaysError as zn, HasherKeecak256 as zr, KnownScript as zt };
-//# sourceMappingURL=advancedBarrel-BbbHx4z4.d.mts.map
+export { CellDep as $, DecodedType as $i, SignerCkbPublicKey as $n, CodecByte as $r, ClientFindCellsResponse as $t, DEP_TYPES as A, apply as Ai, verifyMessageNostrEvent as An, keystoreEncrypt as Ar, HashTypeCodec as At, ClientPublicTestnet as B, NumLike as Bi, SignerDummy as Bn, HASH_CKB_LENGTH as Br, Epoch as Bt, DEFAULT_CONFIRMED_BLOCK_TIME as C, CodecUint64LE as Ci, ClientCollectableSearchKeyLike as Cn, Wallet as Cr, depTypeFrom as Ct, filterNumByRange as D, codecUintNumber as Di, barrel_d_exports as Dn, SignPsbtOptionsLike as Dr, udtBalanceFrom as Dt, filterData as E, codecUint as Ei, clientSearchKeyRangeFrom as En, SignPsbtOptions as Er, isDaoOutputLimitExceeded as Et, NUM_TO_HASH_TYPE as F, stringify as Fi, verifyMessageEvmPersonal as Fn, TransportWebSocket as Fr, ScriptVec as Ft, ClientCacheMemory as G, numLeFromBytes as Gi, SignerDoge as Gn, Hasher as Gr, CellDepInfo as Gt, ClientJsonRpc as H, numBeToBytes as Hi, verifyMessageDogeEcdsa as Hn, HasherCkb as Hr, epochFrom as Ht, ADDRESS_BECH32_LIMIT as I, Proxy as Ii, SignerEvmAddressReadonly as In, TransportHttp as Ir, hashTypeFrom as It, ErrorTransactionInsufficientCoin as J, numMin as Ji, MultisigCkbWitness as Jn, One as Jr, ClientBlockHeader as Jt, ClientCache as K, numLeToBytes as Ki, verifyMessageJoyId as Kn, FixedPoint as Kr, CellDepInfoLike as Kt, AddressFormat as L, AbstractConstructor as Li, SignerEvm as Ln, JsonRpcPayload as Lr, hashTypeFromBytes as Lt, NUM_TO_DEP_TYPE as M, isWebview as Mi, SignerNostrPublicKeyReadonly as Mn, RequestorJsonRpcConfig as Mr, Script as Mt, HASH_TYPES as N, reduceAsync as Ni, NostrEvent as Nn, TransportFallback as Nr, ScriptLike as Nt, filterScript as O, Entity as Oi, buildNostrEventFromMessage as On, barrel_d_exports$1 as Or, LumosTransactionSkeletonType as Ot, HASH_TYPE_TO_NUM as P, sleep as Pi, SignerNostr as Pn, transportFromUri as Pr, ScriptOpt as Pt, CellAnyLike as Q, CodecLike as Qi, SignerCkbPrivateKey as Qn, CodecBool as Qr, ClientBlockUncleLike as Qt, addressFromPayload as R, Constructor as Ri, SignerOpenLink as Rn, Transport as Rr, hashTypeToBytes as Rt, CellRecord as S, CodecUint64BE as Si, ClientCollectableSearchKeyFilterLike as Sn, SignerType as Sr, calcDaoProfit as St, filterCell as T, codecPadding as Ti, DEFAULT_MIN_FEE_RATE as Tn, InputToSignLike as Tr, depTypeToBytes as Tt, ClientJsonRpcConfig as U, numFrom as Ui, SignerDogePrivateKey as Un, hashCkb as Ur, epochFromHex as Ut, ClientPublicMainnet as V, numBeFromBytes as Vi, messageHashDogeEcdsa as Vn, HASH_CKB_SHORT_LENGTH as Vr, EpochLike as Vt, Client as W, numFromBytes as Wi, SignerDogeAddressReadonly as Wn, hashCkbShort as Wr, epochToHex as Wt, Cell as X, numToHex as Xi, SignerMultisigCkbReadonly as Xn, fixedPointFrom as Xr, ClientBlockLike as Xt, hashTypeId as Y, numToBytes as Yi, MultisigCkbWitnessLike as Yn, Zero as Yr, ClientBlockHeaderLike as Yt, CellAny as Z, Codec as Zi, SignerCkbScriptReadonly as Zn, fixedPointToString as Zr, ClientBlockUncle as Zt, JsonRpcOutPoint as _, CodecUint32LE as _i, ErrorClientWaitTransactionTimeout as _n, Signer as _r, Transaction as _t, JsonRpcBlockHeader as a, bytesLen as aa, CodecRaw as ai, ClientIndexerSearchKeyLike as an, verifyMessageCkbSecp256k1 as ar, CellLike as at, TESTNET_SCRIPTS as b, CodecUint512LE as bi, ScriptInfoLike as bn, SignerMultisigNotEnoughSignaturesError as br, WitnessArgsLike as bt, JsonRpcCellInput as c, Bytes$1 as ca, CodecUint128LE as ci, ClientTransactionResponse as cn, btcP2pkhAddressFromPublicKey as cr, CellOutputVec as ct, JsonRpcHashType as d, bytesConcatTo as da, CodecUint16LE as di, ErrorClientBaseLike as dn, messageHashBtcEcdsa as dr, DepTypeLike as dt, EncodableType as ea, CodecByte16 as ei, ClientFindTransactionsGroupedResponse as en, SignerCkbAlwaysSuccess as er, CellDepLike as et, JsonRpcIndexerFindTransactionsGroupedResponse as f, bytesEq as fa, CodecUint256 as fi, ErrorClientDuplicatedTransaction as fn, verifyMessageBtcEcdsa as fr, OutPoint as ft, JsonRpcIndexerSearchKeyTransaction as g, CodecUint32BE as gi, ErrorClientVerification as gn, Signature as gr, SinceLike as gt, JsonRpcIndexerSearchKeyFilter as h, BytesFromEncoding as ha, CodecUint32 as hi, ErrorClientResolveUnknown as hn, NetworkPreference as hr, Since as ht, JsonRpcBlock as i, HexLike as ia, CodecBytes as ii, ClientIndexerSearchKeyFilterLike as in, signMessageSecp256k1 as ir, CellInputVec as it, DEP_TYPE_TO_NUM as j, gcd as ji, SignerNostrPrivateKey as jn, RequestorJsonRpc as jr, HashTypeLike as jt, filterScriptByLenRange as k, codec as ki, nostrEventHash as kn, keystoreDecrypt as kr, HashType as kt, JsonRpcCellOutput as l, BytesLike as la, CodecUint16 as li, ClientTransactionResponseLike as ln, btcPublicKeyFromP2pkhAddress as lr, DepType as lt, JsonRpcIndexerSearchKey as m, bytesTo as ma, CodecUint256LE as mi, ErrorClientRBFRejected as mn, SignerBtc as mr, RawTransaction as mt, CKB_BLAKE2B_PERSONAL as n, AddressLike as na, CodecByte4 as ni, ClientIndexerSearchKey as nn, messageHashCkbSecp256k1 as nr, CellInput as nt, JsonRpcBlockUncle as o, bytesLenUnsafe as oa, CodecUint128 as oi, ClientIndexerSearchKeyTransaction as on, verifyMessageSecp256k1 as or, CellOutput as ot, JsonRpcIndexerFindTransactionsResponse as p, bytesFrom as pa, CodecUint256BE as pi, ErrorClientMaxFeeRateExceeded as pn, SignerBtcPublicKeyReadonly as pr, OutPointLike as pt, ErrorTransactionInsufficientCapacity as q, numMax as qi, SignerMultisigCkbPrivateKey as qn, FixedPointLike as qr, ClientBlock as qt, JsonRpcTransformers as r, Hex as ra, CodecByte8 as ri, ClientIndexerSearchKeyFilter as rn, recoverMessageSecp256k1 as rr, CellInputLike as rt, JsonRpcCellDep as s, hexFrom as sa, CodecUint128BE as si, ClientIndexerSearchKeyTransactionLike as sn, btcEcdsaPublicKeyHash as sr, CellOutputLike as st, advancedBarrel_d_exports as t, Address as ta, CodecByte32 as ti, ClientFindTransactionsResponse as tn, SECP256K1_SIGNATURE_LENGTH as tr, CellDepVec as tt, JsonRpcDepType as u, bytesConcat as ua, CodecUint16BE as ui, ErrorClientBase as un, btcVarLengthBytesFrom as ur, DepTypeCodec as ut, JsonRpcScript as v, CodecUint512 as vi, OutputsValidator as vn, SignerInfo as vr, TransactionLike as vt, MapLru as w, CodecUint8 as wi, DEFAULT_MAX_FEE_RATE as wn, InputToSign as wr, depTypeFromBytes as wt, MAINNET_SCRIPTS as x, CodecUint64 as xi, TransactionStatus as xn, SignerSignType as xr, calcDaoClaimEpoch as xt, JsonRpcTransaction as y, CodecUint512BE as yi, ScriptInfo as yn, SignerMultisig as yr, WitnessArgs as yt, addressPayloadFromString as z, Num as zi, SignerAlwaysError as zn, HasherKeecak256 as zr, KnownScript as zt };
+//# sourceMappingURL=advancedBarrel-CSQ2SmeJ.d.ts.map

package/dist.commonjs/advancedBarrel-CSQ2SmeJ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advancedBarrel-CSQ2SmeJ.d.ts","names":[],"sources":["../src/bytes/advanced.ts","../src/bytes/index.ts","../src/hex/index.ts","../src/address/index.ts","../src/codec/codec.ts","../src/molecule/codec.ts","../src/num/index.ts","../src/utils/constructor.ts","../src/utils/proxy.ts","../src/utils/index.ts","../src/codec/entity.ts","../src/codec/predefined.ts","../src/fixedPoint/index.ts","../src/hasher/hasher.ts","../src/hasher/hasherCkb.ts","../src/hasher/hasherKeecak256.ts","../src/jsonRpc/transports/transport.ts","../src/jsonRpc/transports/http.ts","../src/jsonRpc/transports/webSocket.ts","../src/jsonRpc/transports/factory.ts","../src/jsonRpc/transports/fallback.ts","../src/jsonRpc/requestor.ts","../src/keystore/index.ts","../src/molecule/predefined.ts","../src/molecule/barrel.ts","../src/signer/btc/psbt.ts","../src/signer/signer/index.ts","../src/signer/btc/signerBtc.ts","../src/signer/btc/signerBtcPublicKeyReadonly.ts","../src/signer/btc/verify.ts","../src/signer/ckb/secp256k1Signing.ts","../src/signer/ckb/signerCkbAlwaysSuccess.ts","../src/signer/ckb/signerCkbPublicKey.ts","../src/signer/ckb/signerCkbPrivateKey.ts","../src/signer/ckb/signerCkbScriptReadonly.ts","../src/signer/ckb/signerMultisigCkbReadonly.ts","../src/signer/ckb/signerMultisigCkbPrivateKey.ts","../src/signer/ckb/verifyJoyId.ts","../src/signer/doge/signerDoge.ts","../src/signer/doge/signerDogeAddressReadonly.ts","../src/signer/doge/signerDogePrivateKey.ts","../src/signer/doge/verify.ts","../src/signer/dummy/dummy.ts","../src/signer/dummy/alwaysError.ts","../src/signer/dummy/openLink.ts","../src/signer/evm/signerEvm.ts","../src/signer/evm/signerEvmAddressReadonly.ts","../src/signer/evm/verify.ts","../src/signer/nostr/signerNostr.ts","../src/signer/nostr/signerNostrPublicKeyReadonly.ts","../src/signer/nostr/signerNostrPrivateKey.ts","../src/signer/nostr/verify.ts","../src/barrel.ts","../src/client/clientTypes.advanced.ts","../src/client/clientTypes.ts","../src/ckb/epoch.ts","../src/client/knownScript.ts","../src/ckb/script.ts","../src/ckb/transactionLumos.ts","../src/ckb/transaction.ts","../src/ckb/hash.ts","../src/ckb/transactionErrors.ts","../src/client/cache/cache.ts","../src/client/cache/memory.ts","../src/client/client.ts","../src/client/jsonRpc/client.ts","../src/client/clientPublicMainnet.ts","../src/client/clientPublicTestnet.ts","../src/address/address.advanced.ts","../src/ckb/script.advanced.ts","../src/ckb/transaction.advanced.ts","../src/client/cache/memory.advanced.ts","../src/client/clientPublicMainnet.advanced.ts","../src/client/clientPublicTestnet.advanced.ts","../src/client/jsonRpc/types.ts","../src/client/jsonRpc/transformers.ts","../src/hasher/advanced.ts","../src/advancedBarrel.ts"],"mappings":"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"}

package/dist.commonjs/advancedBarrel.d.ts

@@ -1,2 +1,2 @@
-import { A as DEP_TYPES, C as DEFAULT_CONFIRMED_BLOCK_TIME, Cn as ClientCollectableSearchKeyLike, D as filterNumByRange, E as filterData, En as clientSearchKeyRangeFrom, F as NUM_TO_HASH_TYPE, Fr as TransportWebSocket, I as ADDRESS_BECH32_LIMIT, Ir as TransportHttp, L as AddressFormat, Lr as JsonRpcPayload, M as NUM_TO_DEP_TYPE, N as HASH_TYPES, Nr as TransportFallback, O as filterScript, P as HASH_TYPE_TO_NUM, Pr as transportFromUri, R as addressFromPayload, Rr as Transport, S as CellRecord, Sn as ClientCollectableSearchKeyFilterLike, T as filterCell, Tn as DEFAULT_MIN_FEE_RATE, _ as JsonRpcOutPoint, a as JsonRpcBlockHeader, b as TESTNET_SCRIPTS, c as JsonRpcCellInput, d as JsonRpcHashType, f as JsonRpcIndexerFindTransactionsGroupedResponse, g as JsonRpcIndexerSearchKeyTransaction, h as JsonRpcIndexerSearchKeyFilter, i as JsonRpcBlock, j as DEP_TYPE_TO_NUM, k as filterScriptByLenRange, l as JsonRpcCellOutput, m as JsonRpcIndexerSearchKey, n as CKB_BLAKE2B_PERSONAL, o as JsonRpcBlockUncle, p as JsonRpcIndexerFindTransactionsResponse, pa as BytesFromEncoding, r as JsonRpcTransformers, s as JsonRpcCellDep, u as JsonRpcDepType, v as JsonRpcScript, w as MapLru, wn as DEFAULT_MAX_FEE_RATE, x as MAINNET_SCRIPTS, y as JsonRpcTransaction, z as addressPayloadFromString } from "./advancedBarrel-CJAh6sm8.js";
+import { A as DEP_TYPES, C as DEFAULT_CONFIRMED_BLOCK_TIME, Cn as ClientCollectableSearchKeyLike, D as filterNumByRange, E as filterData, En as clientSearchKeyRangeFrom, F as NUM_TO_HASH_TYPE, Fr as TransportWebSocket, I as ADDRESS_BECH32_LIMIT, Ir as TransportHttp, L as AddressFormat, Lr as JsonRpcPayload, M as NUM_TO_DEP_TYPE, N as HASH_TYPES, Nr as TransportFallback, O as filterScript, P as HASH_TYPE_TO_NUM, Pr as transportFromUri, R as addressFromPayload, Rr as Transport, S as CellRecord, Sn as ClientCollectableSearchKeyFilterLike, T as filterCell, Tn as DEFAULT_MIN_FEE_RATE, _ as JsonRpcOutPoint, a as JsonRpcBlockHeader, b as TESTNET_SCRIPTS, c as JsonRpcCellInput, d as JsonRpcHashType, f as JsonRpcIndexerFindTransactionsGroupedResponse, g as JsonRpcIndexerSearchKeyTransaction, h as JsonRpcIndexerSearchKeyFilter, ha as BytesFromEncoding, i as JsonRpcBlock, j as DEP_TYPE_TO_NUM, k as filterScriptByLenRange, l as JsonRpcCellOutput, m as JsonRpcIndexerSearchKey, n as CKB_BLAKE2B_PERSONAL, o as JsonRpcBlockUncle, p as JsonRpcIndexerFindTransactionsResponse, r as JsonRpcTransformers, s as JsonRpcCellDep, u as JsonRpcDepType, v as JsonRpcScript, w as MapLru, wn as DEFAULT_MAX_FEE_RATE, x as MAINNET_SCRIPTS, y as JsonRpcTransaction, z as addressPayloadFromString } from "./advancedBarrel-CSQ2SmeJ.js";
 export { ADDRESS_BECH32_LIMIT, AddressFormat, BytesFromEncoding, CKB_BLAKE2B_PERSONAL, CellRecord, ClientCollectableSearchKeyFilterLike, ClientCollectableSearchKeyLike, DEFAULT_CONFIRMED_BLOCK_TIME, DEFAULT_MAX_FEE_RATE, DEFAULT_MIN_FEE_RATE, DEP_TYPES, DEP_TYPE_TO_NUM, HASH_TYPES, HASH_TYPE_TO_NUM, JsonRpcBlock, JsonRpcBlockHeader, JsonRpcBlockUncle, JsonRpcCellDep, JsonRpcCellInput, JsonRpcCellOutput, JsonRpcDepType, JsonRpcHashType, JsonRpcIndexerFindTransactionsGroupedResponse, JsonRpcIndexerFindTransactionsResponse, JsonRpcIndexerSearchKey, JsonRpcIndexerSearchKeyFilter, JsonRpcIndexerSearchKeyTransaction, JsonRpcOutPoint, JsonRpcPayload, JsonRpcScript, JsonRpcTransaction, JsonRpcTransformers, MAINNET_SCRIPTS, MapLru, NUM_TO_DEP_TYPE, NUM_TO_HASH_TYPE, TESTNET_SCRIPTS, Transport, TransportFallback, TransportHttp, TransportWebSocket, addressFromPayload, addressPayloadFromString, clientSearchKeyRangeFrom, filterCell, filterData, filterNumByRange, filterScript, filterScriptByLenRange, transportFromUri };

package/dist.commonjs/advancedBarrel.js

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime-DWNI8pZO.js"),t=require("./address.advanced-BAaFklsW.js");var n=e.t({ADDRESS_BECH32_LIMIT:()=>t.t,AddressFormat:()=>t.n,CKB_BLAKE2B_PERSONAL:()=>t.gr,DEFAULT_CONFIRMED_BLOCK_TIME:()=>t.Y,DEFAULT_MAX_FEE_RATE:()=>t.vt,DEFAULT_MIN_FEE_RATE:()=>t.yt,DEP_TYPES:()=>t.O,DEP_TYPE_TO_NUM:()=>t.k,HASH_TYPES:()=>t.R,HASH_TYPE_TO_NUM:()=>t.z,JsonRpcTransformers:()=>t.H,MAINNET_SCRIPTS:()=>t.q,MapLru:()=>t.X,NUM_TO_DEP_TYPE:()=>t.A,NUM_TO_HASH_TYPE:()=>t.B,TESTNET_SCRIPTS:()=>t.V,TransportFallback:()=>t.U,TransportHttp:()=>t.K,TransportWebSocket:()=>t.G,addressFromPayload:()=>t.r,addressPayloadFromString:()=>t.i,clientSearchKeyRangeFrom:()=>t.bt,filterCell:()=>t.Z,filterData:()=>t.Q,filterNumByRange:()=>t.$,filterScript:()=>t.et,filterScriptByLenRange:()=>t.tt,transportFromUri:()=>t.W});exports.ADDRESS_BECH32_LIMIT=t.t,exports.AddressFormat=t.n,exports.CKB_BLAKE2B_PERSONAL=t.gr,exports.DEFAULT_CONFIRMED_BLOCK_TIME=t.Y,exports.DEFAULT_MAX_FEE_RATE=t.vt,exports.DEFAULT_MIN_FEE_RATE=t.yt,exports.DEP_TYPES=t.O,exports.DEP_TYPE_TO_NUM=t.k,exports.HASH_TYPES=t.R,exports.HASH_TYPE_TO_NUM=t.z,exports.JsonRpcTransformers=t.H,exports.MAINNET_SCRIPTS=t.q,exports.MapLru=t.X,exports.NUM_TO_DEP_TYPE=t.A,exports.NUM_TO_HASH_TYPE=t.B,exports.TESTNET_SCRIPTS=t.V,exports.TransportFallback=t.U,exports.TransportHttp=t.K,exports.TransportWebSocket=t.G,exports.addressFromPayload=t.r,exports.addressPayloadFromString=t.i,exports.clientSearchKeyRangeFrom=t.bt,exports.filterCell=t.Z,exports.filterData=t.Q,exports.filterNumByRange=t.$,exports.filterScript=t.et,exports.filterScriptByLenRange=t.tt,Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return n}}),exports.transportFromUri=t.W;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime-DWNI8pZO.js"),t=require("./address.advanced-BTrmYDic.js");var n=e.t({ADDRESS_BECH32_LIMIT:()=>t.t,AddressFormat:()=>t.n,CKB_BLAKE2B_PERSONAL:()=>t.gr,DEFAULT_CONFIRMED_BLOCK_TIME:()=>t.Y,DEFAULT_MAX_FEE_RATE:()=>t.vt,DEFAULT_MIN_FEE_RATE:()=>t.yt,DEP_TYPES:()=>t.O,DEP_TYPE_TO_NUM:()=>t.k,HASH_TYPES:()=>t.R,HASH_TYPE_TO_NUM:()=>t.z,JsonRpcTransformers:()=>t.H,MAINNET_SCRIPTS:()=>t.q,MapLru:()=>t.X,NUM_TO_DEP_TYPE:()=>t.A,NUM_TO_HASH_TYPE:()=>t.B,TESTNET_SCRIPTS:()=>t.V,TransportFallback:()=>t.U,TransportHttp:()=>t.K,TransportWebSocket:()=>t.G,addressFromPayload:()=>t.r,addressPayloadFromString:()=>t.i,clientSearchKeyRangeFrom:()=>t.bt,filterCell:()=>t.Z,filterData:()=>t.Q,filterNumByRange:()=>t.$,filterScript:()=>t.et,filterScriptByLenRange:()=>t.tt,transportFromUri:()=>t.W});exports.ADDRESS_BECH32_LIMIT=t.t,exports.AddressFormat=t.n,exports.CKB_BLAKE2B_PERSONAL=t.gr,exports.DEFAULT_CONFIRMED_BLOCK_TIME=t.Y,exports.DEFAULT_MAX_FEE_RATE=t.vt,exports.DEFAULT_MIN_FEE_RATE=t.yt,exports.DEP_TYPES=t.O,exports.DEP_TYPE_TO_NUM=t.k,exports.HASH_TYPES=t.R,exports.HASH_TYPE_TO_NUM=t.z,exports.JsonRpcTransformers=t.H,exports.MAINNET_SCRIPTS=t.q,exports.MapLru=t.X,exports.NUM_TO_DEP_TYPE=t.A,exports.NUM_TO_HASH_TYPE=t.B,exports.TESTNET_SCRIPTS=t.V,exports.TransportFallback=t.U,exports.TransportHttp=t.K,exports.TransportWebSocket=t.G,exports.addressFromPayload=t.r,exports.addressPayloadFromString=t.i,exports.clientSearchKeyRangeFrom=t.bt,exports.filterCell=t.Z,exports.filterData=t.Q,exports.filterNumByRange=t.$,exports.filterScript=t.et,exports.filterScriptByLenRange=t.tt,Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return n}}),exports.transportFromUri=t.W;
 //# sourceMappingURL=advancedBarrel.js.map

package/dist.commonjs/barrel-D8_wJLfr.js

@@ -0,0 +1,23 @@
+const e=require("./rolldown-runtime-DWNI8pZO.js"),t=require("./address.advanced-BTrmYDic.js");let n=require("bech32"),r=require("isomorphic-ws");r=e.n(r);let i=require("@joyid/ckb"),a=require("ethers");function o(e,t,n){return e&t^~e&n}function s(e,t,n){return e&t^e&n^t&n}var c=class{blockLen;outputLen;canXOF=!1;padOffset;isLE;buffer;view;finished=!1;length=0;pos=0;destroyed=!1;constructor(e,n,r,i){this.blockLen=e,this.outputLen=n,this.padOffset=r,this.isLE=i,this.buffer=new Uint8Array(e),this.view=t.Pr(this.buffer)}update(e){t.wr(this),t.Cr(e);let{view:n,buffer:r,blockLen:i}=this,a=e.length,o=!1;for(let s=0;s<a;){let c=Math.min(i-this.pos,a-s);if(c===i){let n=t.Pr(e);for(;i<=a-s;s+=i)this.process(n,s);o=!0;continue}r.set(s===0&&c===a?e:e.subarray(s,s+c),this.pos),this.pos+=c,s+=c,this.pos===i&&(this.process(n,0),this.pos=0,o=!0)}return this.length+=e.length,o&&this.roundClean(),this}digestInto(e){t.wr(this),t.Dr(e,this),this.finished=!0;let{buffer:n,view:r,blockLen:i,isLE:a}=this,{pos:o}=this;n[o++]=128,n.fill(0,o),this.padOffset>i-o&&(this.process(r,0),n.fill(0)),t.br(r,i-8,this.length*8,a),this.process(r,0),this.roundClean();let s=e===n?r:t.Pr(e),c=this.outputLen,l=c/4,u=this.get();if(c%4||l>u.length)throw Error(`invalid outputLen`);for(let e=0;e<l;e++)s.setUint32(4*e,u[e],a)}digest(){let{buffer:e,outputLen:t}=this;this.digestInto(e);let n=e.slice(0,t);return this.destroy(),n}_cloneIntoMeta(e){let{buffer:t,length:n,finished:r,destroyed:i,pos:a}=this;return e.destroyed=i,e.finished=r,e.length=n,e.pos=a,a&&e.buffer.set(t),e}clone(){return this._cloneInto()}};const l=Uint32Array.from([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),u=BigInt(0),d=BigInt(1),f=BigInt(2),p=BigInt(7),m=BigInt(256),h=BigInt(113),g=[],_=[],v=[];for(let e=0,t=d,n=1,r=0;e<24;e++){[n,r]=[r,(2*n+3*r)%5],g.push(2*(5*r+n)),_.push((e+1)*(e+2)/2%64);let i=u;for(let e=0;e<7;e++)t=(t<<d^(t>>p)*h)%m,t&f&&(i^=d<<(d<<BigInt(e))-d);v.push(i)}const y=t.xr(v,!0),b=y[0],ee=y[1],te=(e,t,n)=>e<<n|t>>>32-n,x=(e,t,n)=>t<<n|e>>>32-n,S=(e,t,n)=>t<<n-32|e>>>64-n,C=(e,t,n)=>e<<n-32|t>>>64-n,w=(e,t,n)=>n>32?S(e,t,n):te(e,t,n),T=(e,t,n)=>n>32?C(e,t,n):x(e,t,n),E=new Uint32Array(10);function D(e,n=24){if(!(e instanceof Uint32Array))throw TypeError(`"s" expected Uint32Array(50), got type=`+typeof e);if(e.length!==50)throw RangeError(`"s" expected Uint32Array(50), got length=`+e.length);if(t.Er(n,`rounds`),n<1||n>24)throw Error(`"rounds" expected integer 1..24`);for(let t=24-n;t<24;t++){for(let t=0;t<10;t++)E[t]=e[t]^e[t+10]^e[t+20]^e[t+30]^e[t+40];for(let t=0;t<10;t+=2){let n=(t+8)%10,r=(t+2)%10,i=E[r],a=E[r+1],o=w(i,a,1)^E[n],s=T(i,a,1)^E[n+1];for(let n=0;n<50;n+=10)e[t+n]^=o,e[t+n+1]^=s}let n=e[2],r=e[3];for(let t=0;t<24;t++){let i=_[t],a=w(n,r,i),o=T(n,r,i),s=g[t];n=e[s],r=e[s+1],e[s]=a,e[s+1]=o}for(let t=0;t<50;t+=10){let n=e[t],r=e[t+1],i=e[t+2],a=e[t+3];e[t]^=~e[t+2]&e[t+4],e[t+1]^=~e[t+3]&e[t+5],e[t+2]^=~e[t+4]&e[t+6],e[t+3]^=~e[t+5]&e[t+7],e[t+4]^=~e[t+6]&e[t+8],e[t+5]^=~e[t+7]&e[t+9],e[t+6]^=~e[t+8]&n,e[t+7]^=~e[t+9]&r,e[t+8]^=~n&i,e[t+9]^=~r&a}e[0]^=b[t],e[1]^=ee[t]}t.jr(E)}var O=class e{state;pos=0;posOut=0;finished=!1;state32;destroyed=!1;blockLen;suffix;outputLen;canXOF;enableXOF=!1;rounds;constructor(e,n,r,i=!1,a=24){if(t.Er(e,`blockLen`),t.Er(n,`suffix`),t.Er(a,`rounds`),t.Sr(i,`enableXOF`),this.blockLen=e,this.suffix=n,this.outputLen=r,this.enableXOF=i,this.canXOF=i,this.rounds=a,t.Er(r,`outputLen`),!(0<e&&e<200))throw Error(`"blockLen" must be 1..199`);this.state=new Uint8Array(200),this.state32=t.Ur(this.state)}clone(){return this._cloneInto()}keccak(){t.Hr(this.state32),D(this.state32,this.rounds),t.Hr(this.state32),this.posOut=0,this.pos=0}update(e){t.wr(this),t.Cr(e);let{blockLen:n,state:r,state32:i}=this,a=e.length,o=n%4==0&&e.byteOffset%4==0,s=n/4,c=o&&a>=n?t.Ur(e):void 0;for(let t=0;t<a;){if(c!==void 0&&this.pos===0&&t%4==0&&a-t>=n){for(let e=0,n=t/4;e<s;e++)i[e]^=c[n+e];t+=n,this.pos=n,this.keccak();continue}let o=Math.min(n-this.pos,a-t);for(let n=0;n<o;n++)r[this.pos++]^=e[t++];this.pos===n&&this.keccak()}return this}finish(){if(this.finished)return;this.finished=!0;let{state:e,suffix:t,pos:n,blockLen:r}=this;e[n]^=t,t&128&&n===r-1&&this.keccak(),e[r-1]^=128,this.keccak()}writeInto(e){t.wr(this,!1),t.Cr(e),this.finish();let n=this.state,{blockLen:r}=this;for(let t=0,i=e.length;t<i;){this.posOut>=r&&this.keccak();let a=Math.min(r-this.posOut,i-t);e.set(n.subarray(this.posOut,this.posOut+a),t),this.posOut+=a,t+=a}return e}xofInto(e){if(!this.enableXOF)throw Error(`XOF is not enabled`);return this.writeInto(e)}xof(e){return t.Er(e),this.xofInto(new Uint8Array(e))}digestInto(e){if(t.Dr(e,this),this.finished)throw Error(`digest() was already called`);this.writeInto(e.length===this.outputLen?e:e.subarray(0,this.outputLen)),this.destroy()}digest(){let e=new Uint8Array(this.outputLen);return this.digestInto(e),e}destroy(){this.destroyed=!0,t.jr(this.state)}_cloneInto(t){let{blockLen:n,suffix:r,outputLen:i,rounds:a,enableXOF:o}=this;return t||=new e(n,r,i,o,a),t.blockLen=n,t.state32.set(this.state32),t.pos=this.pos,t.posOut=this.posOut,t.finished=this.finished,t.rounds=a,t.suffix=r,t.outputLen=i,t.enableXOF=o,t.canXOF=this.canXOF,t.destroyed=this.destroyed,t}};const k=((e,n,r,i={})=>t.Nr(()=>new O(n,e,r),i))(1,136,32);var A=class{constructor(){this.hasher=k.create()}update(e){return this.hasher.update(t.Yr(e)),this}digest(){return t.yr(this.hasher.digest())}},j=e.t({Bool:()=>t.yn,BoolOpt:()=>t.Mt,BoolVec:()=>t.Nt,Byte:()=>t.bn,Byte16:()=>t.xn,Byte16Opt:()=>t.Pt,Byte16Vec:()=>t.Ft,Byte32:()=>t.Sn,Byte32Opt:()=>t.It,Byte32Vec:()=>t.Lt,Byte4:()=>t.Cn,Byte4Opt:()=>t.Rt,Byte4Vec:()=>t.zt,Byte8:()=>t.wn,Byte8Opt:()=>t.Bt,Byte8Vec:()=>t.Vt,ByteOpt:()=>t.Ht,ByteVec:()=>t.Ut,Bytes:()=>t.Wt,BytesOpt:()=>t.Gt,BytesVec:()=>t.Kt,Codec:()=>t.Wr,Entity:()=>t.lr,String:()=>t.qt,StringOpt:()=>t.Jt,StringVec:()=>t.Yt,Uint128:()=>t.Dn,Uint128BE:()=>t.On,Uint128LE:()=>t.kn,Uint128Opt:()=>t.Xt,Uint128Vec:()=>t.Zt,Uint16:()=>t.An,Uint16BE:()=>t.jn,Uint16LE:()=>t.Mn,Uint16Opt:()=>t.Qt,Uint16Vec:()=>t.$t,Uint256:()=>t.Nn,Uint256BE:()=>t.Pn,Uint256LE:()=>t.Fn,Uint256Opt:()=>t.en,Uint256Vec:()=>t.tn,Uint32:()=>t.In,Uint32BE:()=>t.Ln,Uint32LE:()=>t.Rn,Uint32Opt:()=>t.nn,Uint32Vec:()=>t.rn,Uint512:()=>t.zn,Uint512BE:()=>t.Bn,Uint512LE:()=>t.Vn,Uint512Opt:()=>t.in,Uint512Vec:()=>t.an,Uint64:()=>t.Hn,Uint64BE:()=>t.Un,Uint64LE:()=>t.Wn,Uint64Opt:()=>t.on,Uint64Vec:()=>t.sn,Uint8:()=>t.Gn,Uint8Opt:()=>t.cn,Uint8Vec:()=>t.ln,array:()=>t.un,byteVec:()=>t.dn,codec:()=>t.ur,dynItemVec:()=>t.fn,fixedItemVec:()=>t.pn,option:()=>t.mn,struct:()=>t.hn,table:()=>t.gn,uint:()=>t.qn,uintNumber:()=>t.Jn,union:()=>t._n,vector:()=>t.vn});let M;(function(e){let t=e.inner=`@ckb-ccc/core.Proxy.inner`,n=e.localKeys=Symbol.for(`@ckb-ccc/core.Proxy.localKeys`);function r(e){class r{constructor(e){this[t]=e;let i=new Set([t]),a=new Map;for(let e=new.target.prototype;e!==null&&e!==r.prototype;e=Reflect.getPrototypeOf(e)){for(let t of Reflect.ownKeys(e))i.add(t);let t=Object.getOwnPropertyDescriptor(e,`constructor`)?.value;try{let e=Object.getOwnPropertyDescriptor(t,n)?.value;for(let t of e??[])i.add(t)}catch{}}let o=(e,t)=>i.has(t)||Reflect.getOwnPropertyDescriptor(e,t)!==void 0;return new globalThis.Proxy(this,{deleteProperty:(t,n)=>Reflect.deleteProperty(o(t,n)?t:e,n),get:(t,n,r)=>{let i=o(t,n),s=Reflect.get(i?t:e,n,i?r:e);if(i||typeof s!=`function`)return s;let c=a.get(n);return c?.value!==s&&(c={value:s,wrapper:(...t)=>Reflect.apply(s,e,t)},a.set(n,c)),c.wrapper},has:(t,n)=>Reflect.has(o(t,n)?t:e,n),set:(t,n,r,i)=>{let a=o(t,n);return Reflect.set(a?t:e,n,r,a?i:e)}})}}let i=e.prototype;return Object.setPrototypeOf(r.prototype,i),Object.setPrototypeOf(r,e),r}e.Base=r})(M||={});var N=class{async markUsable(...e){return await this.recordCells(...e),this.markUsableNoCache(...e)}async markTransactions(...e){await Promise.all([this.recordTransactionResponses(e.flat().map(e=>({transaction:e,status:`sent`}))),...e.flat().map(e=>{let n=t._.from(e),r=n.hash();return Promise.all([...n.inputs.map(e=>this.markUnusable(e.previousOutput)),...n.outputs.map((e,t)=>this.markUsable({cellOutput:e,outputData:n.outputsData[t],outPoint:{txHash:r,index:t}}))])})])}async recordCells(...e){}async getCell(e){}async recordTransactionResponses(...e){}async getTransactionResponse(e){}async recordTransactions(...e){return this.recordTransactionResponses(e.flat().map(e=>({transaction:e,status:`unknown`})))}async getTransaction(e){return(await this.getTransactionResponse(e))?.transaction}async recordHeaders(...e){}async getHeaderByHash(e){}async getHeaderByNumber(e){}async recordBlocks(...e){}async getBlockByHash(e){}async getBlockByNumber(e){}hasHeaderConfirmed(e){return t.Zn(Date.now())-e.timestamp>=t.Y}},P=class extends N{constructor(e=512,n=256,r=128,i=t.Y){super(),this.maxCells=e,this.maxTxs=n,this.maxBlocks=r,this.cells=new t.X(this.maxCells),this.knownTransactions=new t.X(this.maxTxs),this.knownBlockHashes=new t.X(this.maxBlocks),this.knownBlocks=new t.X(this.maxBlocks),this.confirmedBlockTime=t.Zn(i)}async markUsableNoCache(...e){e.flat().forEach(e=>{let n=t.a.from(e).clone(),r=t.yr(n.outPoint.toBytes());this.cells.set(r,[!0,n])})}async markUnusable(...e){e.flat().forEach(e=>{let n=t.m.from(e),r=t.yr(n.toBytes()),i=this.cells.get(r);if(i){i[0]=!1;return}this.cells.set(r,[!1,{outPoint:n}])})}async clear(){this.cells.clear(),this.knownTransactions.clear()}async*findCells(e){for(let[n,[r,i]]of this.cells.entries())r&&t.Z(e,i)&&(this.cells.get(n),yield i.clone())}async isUnusable(e){let n=t.m.from(e);return!(this.cells.get(t.yr(n.toBytes()))?.[0]??!0)}async recordCells(...e){e.flat().map(e=>{let n=t.a.from(e),r=t.yr(n.outPoint.toBytes());this.cells.get(r)||this.cells.set(r,[void 0,n])})}async getCell(e){let n=t.m.from(e),r=this.cells.get(t.yr(n.toBytes()))?.[1];if(r&&r.cellOutput&&r.outputData)return t.a.from(r.clone())}async recordTransactionResponses(...e){e.flat().map(e=>{let n=t.lt.from(e);this.knownTransactions.set(n.transaction.hash(),n)})}async getTransactionResponse(e){let n=t.yr(e);return this.knownTransactions.get(n)?.clone()}async recordHeaders(...e){e.flat().map(e=>{let n=t.it.from(e);this.knownBlockHashes.set(n.number,n.hash),!this.knownBlocks.get(n.hash)&&this.knownBlocks.set(n.hash,{header:n})})}async getHeaderByHash(e){let n=t.yr(e),r=this.knownBlocks.get(n);return r&&this.knownBlockHashes.get(r.header.number),r?.header}async getHeaderByNumber(e){let n=t.Zn(e),r=this.knownBlockHashes.get(n);if(r)return this.getHeaderByHash(r)}async recordBlocks(...e){e.flat().map(e=>{let n=t.rt.from(e);this.knownBlockHashes.set(n.header.number,n.header.hash),this.knownBlocks.set(n.header.hash,n)})}async getBlockByHash(e){let n=t.yr(e),r=this.knownBlocks.get(n);if(r&&(this.knownBlockHashes.get(r.header.number),`transactions`in r))return r}async getBlockByNumber(e){let n=t.Zn(e),r=this.knownBlockHashes.get(n);if(r)return this.getBlockByHash(r)}hasHeaderConfirmed(e){return t.Zn(Date.now())-e.timestamp>=this.confirmedBlockTime}},F=class{constructor(e){this.cache=e?.cache??new P}async getFeeRate(e,n){let r=t.tr((await this.getFeeRateStatistics(e)).median,t.yt),i=t.Zn(n?.maxFeeRate??t.vt);return i===0n?r:t.nr(r,i)}async getBlockByNumber(e,t,n){let r=await this.cache.getBlockByNumber(e);if(r)return r;let i=await this.getBlockByNumberNoCache(e,t,n);return i&&this.cache.hasHeaderConfirmed(i.header)&&await this.cache.recordBlocks(i),i}async getBlockByHash(e,t,n){let r=await this.cache.getBlockByHash(e);if(r)return r;let i=await this.getBlockByHashNoCache(e,t,n);return i&&this.cache.hasHeaderConfirmed(i.header)&&await this.cache.recordBlocks(i),i}async getHeaderByNumber(e,t){let n=await this.cache.getHeaderByNumber(e);if(n)return n;let r=await this.getHeaderByNumberNoCache(e,t);return r&&this.cache.hasHeaderConfirmed(r)&&await this.cache.recordHeaders(r),r}async getHeaderByHash(e,t){let n=await this.cache.getHeaderByHash(e);if(n)return n;let r=await this.getHeaderByHashNoCache(e,t);return r&&this.cache.hasHeaderConfirmed(r)&&await this.cache.recordHeaders(r),r}async getCell(e){let n=t.m.from(e),r=await this.cache.getCell(n);if(r)return r;let i=await this.getTransaction(n.txHash);if(!i)return;let a=i.transaction.getOutput(n.index);if(!a)return;let o=t.a.from({...a,outPoint:n});return await this.cache.recordCells(o),o}async getCellWithHeader(e){let n=t.m.from(e),r=await this.getTransactionWithHeader(n.txHash);if(!r)return;let{transaction:i,header:a}=r,o=i.transaction.getOutput(n.index);if(!o)return;let s=t.a.from({...o,outPoint:n});return await this.cache.recordCells(s),{cell:s,header:a}}async getCellLive(e,t,n){let r=await this.getCellLiveNoCache(e,t,n);return t&&r&&await this.cache.recordCells(r),r}async findCellsPaged(e,t,n,r){let i=await this.findCellsPagedNoCache(e,t,n,r);return await this.cache.recordCells(i.cells),i}async*findCellsOnChain(e,t,n=10){let r;for(;;){let{cells:i,lastCursor:a}=await this.findCellsPaged(e,t,n,r);for(let e of i)yield e;if(i.length===0||i.length<n)return;r=a}}async*findCells(e,n,r=10){let i=t.ot.from(e),a=[];for await(let e of this.cache.findCells(i))a.push(e.outPoint),yield e;for await(let e of this.findCellsOnChain(i,n,r))await this.cache.isUnusable(e.outPoint)||a.some(t=>t.eq(e.outPoint))||(yield e)}findCellsByLock(e,t,n=!0,r,i=10){return this.findCells({script:e,scriptType:`lock`,scriptSearchMode:`exact`,filter:{script:t},withData:n},r,i)}findCellsByType(e,t=!0,n,r=10){return this.findCells({script:e,scriptType:`type`,scriptSearchMode:`exact`,withData:t},n,r)}async findSingletonCellByType(e,t=!0){for await(let n of this.findCellsByType(e,t,void 0,1))return n}async getCellDeps(...e){return Promise.all(e.flat().map(async e=>{let{cellDep:n,type:r}=t.nt.from(e);if(r===void 0)return n;let i=await this.findSingletonCellByType(r);return i?t.s.from({outPoint:i.outPoint,depType:n.depType}):n}))}async*findTransactions(e,t,n=10){let r;for(;;){let{transactions:i,lastCursor:a}=await this.findTransactionsPaged(e,t,n,r);for(let e of i)yield e;if(i.length===0||i.length<n)return;r=a}}findTransactionsByLock(e,t,n,r,i=10){return this.findTransactions({script:e,scriptType:`lock`,scriptSearchMode:`exact`,filter:{script:t},groupByTransaction:n},r,i)}findTransactionsByType(e,t,n,r=10){return this.findTransactions({script:e,scriptType:`type`,scriptSearchMode:`exact`,groupByTransaction:t},n,r)}async getBalanceSingle(e){return this.getCellsCapacity({script:e,scriptType:`lock`,scriptSearchMode:`exact`,filter:{scriptLenRange:[0,1],outputDataLenRange:[0,1]}})}async getBalance(e){return t.kt(e,async(e,t)=>e+await this.getBalanceSingle(t),t.or)}async sendTransaction(e,n,r){let i=t._.from(e),a=t.Zn(r?.maxFeeRate??t.vt),o=await i.getFeeRate(this);if(a>0n&&o>a)throw new t.ft(a,o);let s=await this.sendTransactionNoCache(i,n);return await this.cache.markTransactions(i),s}async getTransaction(e){let n=t.yr(e),r=await this.getTransactionNoCache(n);return r?(await this.cache.recordTransactionResponses(r),r):this.cache.getTransactionResponse(n)}async getTransactionWithHeader(e){let n=t.yr(e),r=await this.cache.getTransactionResponse(n);if(r?.blockHash){let e=await this.getHeaderByHash(r.blockHash);if(e&&this.cache.hasHeaderConfirmed(e))return{transaction:r,header:e}}let i=await this.getTransactionNoCache(n);if(i)return await this.cache.recordTransactionResponses(i),{transaction:i,header:i.blockHash?await this.getHeaderByHash(i.blockHash):void 0}}async waitTransaction(e,n=0,r=6e4,i=2e3){let a=Date.now(),o,s=async()=>{let t=await this.getTransaction(e);if(!(!t||t.blockNumber==null||[`sent`,`pending`,`proposed`].includes(t.status)))return o=t,t};for(;;){if(!o){if(await s())continue}else if(n===0)return o;else if((await this.getTipHeader()).number-o.blockNumber>=n)return o;if(Date.now()-a+i>=r)throw new t.gt(r);await t.At(i)}}};function I(e,t){return t?t(e):e}var ne=class{constructor(e,n,r){this.url_=e,this.onError=r,this.concurrent=0,this.pending=[],this.id=0,this.maxConcurrent=n?.maxConcurrent,this.transport=n?.transport??new t.U(Array.from(new Set([e,...n?.fallbacks??[]]).values(),e=>t.W(e,n)))}get url(){return this.url_}async request(e,t,n,r){let i=this.buildPayload(e,n?await Promise.all(t.concat(Array.from(Array(Math.max(n.length-t.length,0)))).map((e,t)=>I(e,n[t]))):t);try{return await I(await this.requestPayload(i),r)}catch(e){if(!this.onError)throw e;await this.onError(e)}}async requestPayload(e){this.maxConcurrent!==void 0&&this.concurrent>=this.maxConcurrent&&await new Promise(e=>this.pending.push(e));let t=await(async()=>{this.concurrent+=1;try{return await this.transport.request(e)}finally{--this.concurrent,this.pending.shift()?.()}})();if(t.id!==e.id)throw Error(`Id mismatched, got ${t.id}, expected ${e.id}`);if(t.error!=null)throw t.error;return t.result}buildPayload(e,t){return{id:this.id++,method:e,params:t,jsonrpc:`2.0`}}};const re=[[`Resolve\\(Unknown\\(OutPoint\\((0x.*)\\)\\)\\)`,(e,n)=>new t.mt(e,t.m.fromBytes(n[1]))],[`Verification\\(Error { kind: Script, inner: TransactionScriptError { source: (Inputs|Outputs)\\[([0-9]*)\\].(Lock|Type), cause: ValidationFailure: see error code (-?[0-9]+) on page https://nervosnetwork\\.github\\.io/ckb-script-error-codes/by-(type|data)-hash/(.*)\\.html`,(e,n)=>new t.ht(e,n[3]===`Lock`?`lock`:n[1]===`Inputs`?`inputType`:`outputType`,n[2],Number(n[4]),n[5]===`data`?`data`:`type`,n[6])],[`Duplicated\\(Byte32\\((0x.*)\\)\\)`,(e,n)=>new t.dt(e,n[1])],[`RBFRejected\\("Tx's current fee is ([0-9]*), expect it to >= ([0-9]*) to replace old txs"\\)`,(e,n)=>new t.pt(e,n[1],n[2])]];var ie=class extends F{constructor(e,n){super(n),this.getFeeRateStatistics=this.buildSender(`get_fee_rate_statistics`,[e=>t.Et(t.Zn,e)],e=>({mean:t.Zn(e?.mean??t.yt),median:t.Zn(e?.median??t.yt)})),this.getTip=this.buildSender(`get_tip_block_number`,[],t.Zn),this.getTipHeader=this.buildSender(`get_tip_header`,[],e=>t.Et(t.H.blockHeaderTo,e)),this.getBlockByNumberNoCache=this.buildSender(`get_block_by_number`,[e=>t.ir(t.Zn(e))],e=>t.Et(t.H.blockTo,e)),this.getBlockByHashNoCache=this.buildSender(`get_block`,[t.yr],e=>t.Et(t.H.blockTo,e)),this.getHeaderByNumberNoCache=this.buildSender(`get_header_by_number`,[e=>t.ir(t.Zn(e))],e=>t.Et(t.H.blockHeaderTo,e)),this.getHeaderByHashNoCache=this.buildSender(`get_header`,[t.yr],e=>t.Et(t.H.blockHeaderTo,e)),this.estimateCycles=this.buildSender(`estimate_cycles`,[t.H.transactionFrom],({cycles:e})=>t.Zn(e)),this.sendTransactionDry=this.buildSender(`test_tx_pool_accept`,[t.H.transactionFrom],({cycles:e})=>t.Zn(e)),this.sendTransactionNoCache=this.buildSender(`send_transaction`,[t.H.transactionFrom,e=>e??void 0],t.yr),this.getTransactionNoCache=this.buildSender(`get_transaction`,[t.yr],t.H.transactionResponseTo),this.findCellsPagedNoCache=this.buildSender(`get_cells`,[t.H.indexerSearchKeyFrom,e=>e??`asc`,e=>t.ir(e??10)],t.H.findCellsResponseTo),this.findTransactionsPaged=this.buildSender(`get_transactions`,[t.H.indexerSearchKeyTransactionFrom,e=>e??`asc`,e=>t.ir(e??10)],t.H.findTransactionsResponseTo),this.getCellsCapacity=this.buildSender(`get_cells_capacity`,[t.H.indexerSearchKeyFrom],({capacity:e})=>t.Zn(e)),this.requestor=n?.requestor??new ne(e,n,e=>{if(typeof e!=`object`||!e||!(`data`in e)||typeof e.data!=`string`)throw e;let n=e;for(let[e,t]of re){let r=n.data.match(e);if(r)throw t(n,r)}throw new t.ut(n)})}get url(){return this.requestor.url}getCellLiveNoCache(e,n,r){return this.buildSender(`get_live_cell`,[t.H.outPointFrom],({cell:n})=>t.Et(({output:n,data:r})=>t.a.from({cellOutput:t.H.cellOutputTo(n),outputData:r?.content??`0x`,outPoint:e}),n))(e,n??!0,r)}buildSender(e,t,n){return async(...r)=>this.requestor.request(e,r,t,n)}},ae=class extends ie{constructor(e){let t=r.default!==void 0;super(e?.url??(t?`wss://mainnet.ckb.dev/ws`:`https://mainnet.ckb.dev/`),{...e,fallbacks:e?.fallbacks??(t?[`wss://mainnet.ckb.dev/ws`,`https://mainnet.ckb.dev/`,`https://mainnet.ckbapp.dev/`]:[`https://mainnet.ckb.dev/`,`https://mainnet.ckbapp.dev/`])}),this.config=e}get scripts(){return this.config?.scripts??t.q}get addressPrefix(){return`ckb`}async getKnownScript(e){let n=this.scripts[e];if(!n)throw Error(`No script information was found for ${e} on ${this.addressPrefix}`);return t._t.from(n)}},oe=class extends ie{constructor(e){let t=r.default!==void 0;super(e?.url??(t?`wss://testnet.ckb.dev/ws`:`https://testnet.ckb.dev/`),{...e,fallbacks:e?.fallbacks??(t?[`wss://testnet.ckb.dev/ws`,`https://testnet.ckb.dev/`,`https://testnet.ckbapp.dev/`]:[`https://testnet.ckb.dev/`,`https://testnet.ckbapp.dev/`])}),this.config=e}get scripts(){return this.config?.scripts??t.V}get addressPrefix(){return`ckt`}async getKnownScript(e){let n=this.scripts[e];if(!n)throw Error(`No script information was found for ${e} on ${this.addressPrefix}`);return t._t.from(n)}};function se(e,n){return t.mr(t.l.from(e).toBytes(),t.er(n,8))}var L=class e{constructor(e,t){this.script=e,this.prefix=t}static from(n){return n instanceof e?n:new e(t.M.from(n.script),n.prefix)}static async fromString(n,r){let{prefix:i,format:a,payload:o}=t.i(n),s=r[i]??r;if(!s)throw Error(`Unknown address prefix ${i}`);let c=s.addressPrefix;if(c!==i)throw Error(`Unknown address prefix ${i}, expected ${c}`);return e.from(await t.r(i,a,o,s))}static fromScript(t,n){return e.from({script:t,prefix:n.addressPrefix})}static async fromKnownScript(n,r,i){return e.from({script:await t.M.fromKnownScript(n,r,i),prefix:n.addressPrefix})}toString(){let e=t.Kr([0],t.Yr(this.script.codeHash),t.L(this.script.hashType),t.Yr(this.script.args));return n.bech32m.encode(this.prefix,n.bech32m.toWords(e),t.t)}};
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+function ce(e){return e instanceof Uint8Array||ArrayBuffer.isView(e)&&e.constructor.name===`Uint8Array`&&`BYTES_PER_ELEMENT`in e&&e.BYTES_PER_ELEMENT===1}const le=e=>e?`"${e}" `:``;function ue(e,t=``){if(typeof e!=`number`)throw TypeError(le(t)+`expected number, got `+typeof e);if(!Number.isSafeInteger(e)||e<0)throw RangeError(le(t)+`expected integer >= 0, got `+e);return e}function R(e,t,n=``){if(ce(e)&&(t===void 0||e.length===t))return e;t!==void 0&&ue(t,`length`);let r=ce(e),i=t===void 0?``:` of length ${t}`,a=r?`length=${e.length}`:`type=${typeof e}`,o=le(n)+`expected Uint8Array`+i+`, got `+a;throw r?RangeError(o):TypeError(o)}function de(e){return new Uint8Array(e.buffer,e.byteOffset,e.byteLength)}function fe(e){return new Uint32Array(e.buffer,e.byteOffset,Math.floor(e.byteLength/4))}function pe(...e){for(let t=0;t<e.length;t++)e[t].fill(0)}const me=new Uint8Array(new Uint32Array([287454020]).buffer)[0]===68;function he(e){return e<<24&4278190080|e<<8&16711680|e>>>8&65280|e>>>24&255}const z=me?e=>e:e=>he(e)>>>0;function ge(e){for(let t=0;t<e.length;t++)e[t]=he(e[t]);return e}const _e=me?e=>e:ge;function ve(e,t){return!e.byteLength||!t.byteLength?!1:e.buffer===t.buffer&&e.byteOffset<t.byteOffset+t.byteLength&&t.byteOffset<e.byteOffset+e.byteLength}function ye(e,t){if(ve(e,t)&&e.byteOffset<t.byteOffset)throw Error(`complex overlap of input and output is not supported`)}const be=(e,t)=>{function n(n,...r){if(R(n,void 0,`key`),e.nonceLength!==void 0){let t=r[0];R(t,e.varSizeNonce?void 0:e.nonceLength,`nonce`)}let i=e.tagLength,a=e.nonceLength===void 0?0:1;if(!e.withAAD){for(let e=a;e<r.length;e++)if(ce(r[e]))throw Error(`AAD not supported`)}e.withAAD&&r[a]!==void 0&&R(r[a],void 0,`AAD`);let o=t(n,...r),s=(e,t)=>{if(t!==void 0){if(e!==2)throw Error(`cipher output not supported`);R(t,void 0,`output`)}},c=!1;return{encrypt(e,t){if(c)throw Error(`cannot encrypt() twice with same key + nonce`);return c=!0,R(e,void 0,`data`),s(o.encrypt.length,t),o.encrypt(e,t)},decrypt(e,t){if(R(e,void 0,`data`),i&&e.length<i)throw Error(`"ciphertext" expected length >= tagLength=`+i);return s(o.decrypt.length,t),o.decrypt(e,t)}}}return Object.assign(n,e),n};function xe(e,t,n=!0){if(t===void 0)return new Uint8Array(e);if(R(t,e,`output`),n&&!Se(t))throw Error(`invalid output, must be aligned`);return t}function Se(e){return e.byteOffset%4==0}function Ce(e){return Uint8Array.from(R(e))}function we(e){if(![16,24,32].includes(e.length))throw Error(`"aes key" expected Uint8Array of length 16/24/32, got length=`+e.length)}function Te(e){return e<<1^283&-(e>>7)}function Ee(e,t){let n=0;for(;t>0;t>>=1)n^=e&-(t&1),e=Te(e);return n}const De=(()=>{let e=new Uint8Array(256);for(let t=0,n=1;t<256;t++,n^=Te(n))e[t]=n;let t=new Uint8Array(256);t[0]=99;for(let n=0;n<255;n++){let r=e[255-n];r|=r<<8,t[e[n]]=(r^r>>4^r>>5^r>>6^r>>7^99)&255}return pe(e),t})(),Oe=e=>e<<24|e>>>8,ke=e=>e<<8|e>>>24;function Ae(e,t){if(e.length!==256)throw Error(`wrong sbox length`);let n=new Uint32Array(256).map((n,r)=>t(e[r])),r=n.map(ke),i=r.map(ke),a=i.map(ke),o=new Uint32Array(256*256),s=new Uint32Array(256*256),c=new Uint16Array(256*256);for(let t=0;t<256;t++)for(let l=0;l<256;l++){let u=t*256+l;o[u]=n[t]^r[l],s[u]=i[t]^a[l],c[u]=e[t]<<8|e[l]}return{sbox:e,sbox2:c,T0:n,T1:r,T2:i,T3:a,T01:o,T23:s}}const je=Ae(De,e=>Ee(e,3)<<24|e<<16|e<<8|Ee(e,2)),Me=(()=>{let e=new Uint8Array(16);for(let t=0,n=1;t<16;t++,n=Te(n))e[t]=n;return e})();function Ne(e){R(e);let t=e.length;we(e);let{sbox2:n}=je,r=[];(!me||!Se(e))&&r.push(e=Ce(e));let i=_e(fe(e)),a=i.length,o=e=>Fe(n,e,e,e,e),s=new Uint32Array(t+28);s.set(i);for(let e=a;e<s.length;e++){let t=s[e-1];e%a===0?t=o(Oe(t))^Me[e/a-1]:a>6&&e%a===4&&(t=o(t)),s[e]=s[e-a]^t}return pe(...r),s}function Pe(e,t,n,r,i,a){return e[n<<8&65280|r>>>8&255]^t[i>>>8&65280|a>>>24&255]}function Fe(e,t,n,r,i){return e[t&255|n&65280]|e[r>>>16&255|i>>>16&65280]<<16}function Ie(e,t,n,r,i){let{sbox2:a,T01:o,T23:s}=je,c=0;t^=e[c++],n^=e[c++],r^=e[c++],i^=e[c++];let l=e.length/4-2;for(let a=0;a<l;a++){let a=e[c++]^Pe(o,s,t,n,r,i),l=e[c++]^Pe(o,s,n,r,i,t),u=e[c++]^Pe(o,s,r,i,t,n),d=e[c++]^Pe(o,s,i,t,n,r);t=a,n=l,r=u,i=d}return{s0:e[c++]^Fe(a,t,n,r,i),s1:e[c++]^Fe(a,n,r,i,t),s2:e[c++]^Fe(a,r,i,t,n),s3:e[c++]^Fe(a,i,t,n,r)}}function Le(e,t,n,r){R(t,16,`nonce`),R(n);let i=n.length;r=xe(i,r),ye(n,r);let a=t,o=fe(a),s=fe(n),c=fe(r);for(let t=0;t+4<=s.length;t+=4){let{s0:n,s1:r,s2:i,s3:l}=Ie(e,z(o[0]),z(o[1]),z(o[2]),z(o[3]));c[t+0]=s[t+0]^z(n),c[t+1]=s[t+1]^z(r),c[t+2]=s[t+2]^z(i),c[t+3]=s[t+3]^z(l);for(let e=15,t=1;e>=0;e--)t=t+a[e]|0,a[e]=t&255,t>>>=8}let l=16*Math.floor(s.length/4);if(l<i){let{s0:t,s1:a,s2:s,s3:c}=Ie(e,z(o[0]),z(o[1]),z(o[2]),z(o[3])),u=new Uint32Array([t,a,s,c]);_e(u);let d=de(u);for(let e=l,t=0;e<i;e++,t++)r[e]=n[e]^d[t];pe(u)}return r}const Re=be({blockSize:16,nonceLength:16},function(e,t){function n(n,r){if(R(n),r!==void 0&&(R(r),!Se(r)))throw Error(`unaligned destination`);let i=Ne(e),a=Ce(t),o=[i,a];Se(n)||o.push(n=Ce(n));let s=Le(i,a,n,r);return pe(...o),s}return{encrypt:(e,t)=>n(e,t),decrypt:(e,t)=>n(e,t)}});var ze=class{oHash;iHash;blockLen;outputLen;canXOF=!1;finished=!1;destroyed=!1;constructor(e,n){if(t.Tr(e),t.Cr(n,void 0,`key`),this.iHash=e.create(),typeof this.iHash.update!=`function`)throw Error(`expected Hash instance`);this.blockLen=this.iHash.blockLen,this.outputLen=this.iHash.outputLen;let r=this.blockLen,i=new Uint8Array(r);i.set(n.length>r?e.create().update(n).digest():n);for(let e=0;e<i.length;e++)i[e]^=54;this.iHash.update(i),this.oHash=e.create();for(let e=0;e<i.length;e++)i[e]^=106;this.oHash.update(i),t.jr(i)}update(e){return t.wr(this),this.iHash.update(e),this}digestInto(e){t.wr(this),t.Dr(e,this),this.finished=!0;let n=e.subarray(0,this.outputLen);this.iHash.digestInto(n),this.oHash.update(n),this.oHash.digestInto(n),this.destroy()}digest(){let e=new Uint8Array(this.oHash.outputLen);return this.digestInto(e),e}_cloneInto(e){e||=Object.create(Object.getPrototypeOf(this),{});let{oHash:t,iHash:n,finished:r,destroyed:i,blockLen:a,outputLen:o,canXOF:s}=this;return e=e,e.finished=r,e.destroyed=i,e.blockLen=a,e.outputLen=o,e.canXOF=s,e.oHash=t._cloneInto(e.oHash),e.iHash=n._cloneInto(e.iHash),e}clone(){return this._cloneInto()}destroy(){this.destroyed=!0,this.oHash.destroy(),this.iHash.destroy()}};const Be=(()=>{let e=((e,t,n)=>new ze(e,t).update(n).digest());return e.create=(e,t)=>new ze(e,t),e})();function Ve(e,n,r,i){t.Tr(e);let{c:a,dkLen:o,asyncTick:s}=t.Ar({dkLen:32,asyncTick:10},i);if(t.Er(a,`c`),t.Er(o,`dkLen`),t.Er(s,`asyncTick`),a<1)throw Error(`"c" (iterations) must be >= 1`);if(o<1)throw Error(`"dkLen" must be >= 1`);if(o>(2**32-1)*e.outputLen)throw Error(`derived key too long`);let c=t.Lr(n,`password`),l=t.Lr(r,`salt`),u=new Uint8Array(o),{iHash:d,oHash:f,outputLen:p}=Be.create(e,c);return{c:a,dkLen:o,asyncTick:s,DK:u,outputLen:p,eng:He(d,f,l,new Uint8Array(p))}}function He(e,n,r,i){let a=new Uint8Array(4),o=t.Pr(a),s=e._cloneInto().update(r),c=n._cloneInto(),l=e._cloneInto,u=n._cloneInto;return{u1:(e,t)=>{o.setInt32(0,e,!1),s._cloneInto(c).update(a).digestInto(i),n._cloneInto(c).update(i).digestInto(i),t.set(i.subarray(0,t.length))},rounds:(t,r)=>{for(let a=1;a<t;a++){l.call(e,c).update(i).digestInto(i),u.call(n,c).update(i).digestInto(i);for(let e=0;e<r.length;e++)r[e]^=i[e]}},output:r=>(e.destroy(),n.destroy(),s.destroy(),c.destroy(),t.jr(i),r)}}function Ue(e,t,n,r){let{c:i,dkLen:a,DK:o,outputLen:s,eng:c}=Ve(e,t,n,r);for(let e=1,t=0;t<a;e++,t+=s){let n=o.subarray(t,t+s);c.u1(e,n),c.rounds(i,n)}return c.output(o)}const We=Uint32Array.from([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),B=new Uint32Array(64);var Ge=class extends c{A=0;B=0;C=0;D=0;E=0;F=0;G=0;H=0;constructor(e,t){super(64,e,8,!1),this.A=t[0]|0,this.B=t[1]|0,this.C=t[2]|0,this.D=t[3]|0,this.E=t[4]|0,this.F=t[5]|0,this.G=t[6]|0,this.H=t[7]|0}get(){let{A:e,B:t,C:n,D:r,E:i,F:a,G:o,H:s}=this;return[e,t,n,r,i,a,o,s]}set(e,t,n,r,i,a,o,s){this.A=e|0,this.B=t|0,this.C=n|0,this.D=r|0,this.E=i|0,this.F=a|0,this.G=o|0,this.H=s|0}_cloneInto(e){return(e||=new this.constructor).set(...this.get()),this._cloneIntoMeta(e)}process(e,n){for(let t=0;t<16;t++,n+=4)B[t]=e.getUint32(n,!1);for(let e=16;e<64;e++){let n=B[e-15],r=B[e-2],i=t.Vr(n,7)^t.Vr(n,18)^n>>>3,a=t.Vr(r,17)^t.Vr(r,19)^r>>>10;B[e]=a+B[e-7]+i+B[e-16]|0}let{A:r,B:i,C:a,D:c,E:l,F:u,G:d,H:f}=this;for(let e=0;e<64;e++){let n=t.Vr(l,6)^t.Vr(l,11)^t.Vr(l,25),p=f+n+o(l,u,d)+We[e]+B[e]|0,m=(t.Vr(r,2)^t.Vr(r,13)^t.Vr(r,22))+s(r,i,a)|0;f=d,d=u,u=l,l=c+p|0,c=a,a=i,i=r,r=p+m|0}r=r+this.A|0,i=i+this.B|0,a=a+this.C|0,c=c+this.D|0,l=l+this.E|0,u=u+this.F|0,d=d+this.G|0,f=f+this.H|0,this.set(r,i,a,c,l,u,d,f)}roundClean(){t.jr(B)}destroy(){this.destroyed=!0,this.set(0,0,0,0,0,0,0,0),t.jr(this.buffer)}},Ke=class extends Ge{constructor(){super(32,l)}};const V=t.Nr(()=>new Ke,t.Rr(1));function qe(e,n,r,i,a,o){let s=e[n++]^r[i++],c=e[n++]^r[i++],l=e[n++]^r[i++],u=e[n++]^r[i++],d=e[n++]^r[i++],f=e[n++]^r[i++],p=e[n++]^r[i++],m=e[n++]^r[i++],h=e[n++]^r[i++],g=e[n++]^r[i++],_=e[n++]^r[i++],v=e[n++]^r[i++],y=e[n++]^r[i++],b=e[n++]^r[i++],ee=e[n++]^r[i++],te=e[n++]^r[i++],x=s,S=c,C=l,w=u,T=d,E=f,D=p,O=m,k=h,A=g,j=_,M=v,N=y,P=b,F=ee,I=te;for(let e=0;e<8;e+=2)T^=t.Br(x+N|0,7),k^=t.Br(T+x|0,9),N^=t.Br(k+T|0,13),x^=t.Br(N+k|0,18),A^=t.Br(E+S|0,7),P^=t.Br(A+E|0,9),S^=t.Br(P+A|0,13),E^=t.Br(S+P|0,18),F^=t.Br(j+D|0,7),C^=t.Br(F+j|0,9),D^=t.Br(C+F|0,13),j^=t.Br(D+C|0,18),w^=t.Br(I+M|0,7),O^=t.Br(w+I|0,9),M^=t.Br(O+w|0,13),I^=t.Br(M+O|0,18),S^=t.Br(x+w|0,7),C^=t.Br(S+x|0,9),w^=t.Br(C+S|0,13),x^=t.Br(w+C|0,18),D^=t.Br(E+T|0,7),O^=t.Br(D+E|0,9),T^=t.Br(O+D|0,13),E^=t.Br(T+O|0,18),M^=t.Br(j+A|0,7),k^=t.Br(M+j|0,9),A^=t.Br(k+M|0,13),j^=t.Br(A+k|0,18),N^=t.Br(I+F|0,7),P^=t.Br(N+I|0,9),F^=t.Br(P+N|0,13),I^=t.Br(F+P|0,18);a[o++]=s+x|0,a[o++]=c+S|0,a[o++]=l+C|0,a[o++]=u+w|0,a[o++]=d+T|0,a[o++]=f+E|0,a[o++]=p+D|0,a[o++]=m+O|0,a[o++]=h+k|0,a[o++]=g+A|0,a[o++]=_+j|0,a[o++]=v+M|0,a[o++]=y+N|0,a[o++]=b+P|0,a[o++]=ee+F|0,a[o++]=te+I|0}function Je(e,t,n,r,i){let a=r+0,o=r+16*i;for(let r=0;r<16;r++)n[o+r]=e[t+(2*i-1)*16+r];for(let r=0;r<i;r++,a+=16,t+=16)qe(n,o,e,t,n,a),r>0&&(o+=16),qe(n,a,e,t+=16,n,o)}function Ye(e,n,r){let{N:i,r:a,p:o,dkLen:s,asyncTick:c,maxmem:l,onProgress:u}=t.Ar({dkLen:32,asyncTick:10,maxmem:1024**3+1024},r);if(t.Er(i,`N`),t.Er(a,`r`),t.Er(o,`p`),t.Er(s,`dkLen`),t.Er(c,`asyncTick`),t.Er(l,`maxmem`),u!==void 0&&typeof u!=`function`)throw Error(`"onProgress" must be a function`);if(a<1)throw Error(`"r" expected integer >= 1`);let d=128*a,f=d/4,p=2**32;if(i<=1||i&i-1||i>p)throw Error(`"N" expected a power of 2, and 2^1 <= N <= 2^32`);if(o<1||o>(p-1)*32/d)throw Error(`"p" expected integer 1..((2^32 - 1) * 32) / (128 * r)`);if(s<1||s>(p-1)*32)throw Error(`"dkLen" expected integer 1..(2^32 - 1) * 32`);let m=d*(i+o+1);if(m>l)throw Error(`"maxmem" limit was hit: memUsed(128*r*(N+p+1))=`+m+`, maxmem=`+l);let h=Ue(V,e,n,{c:1,dkLen:d*o}),g=t.Ur(h),_=t.Ur(new Uint8Array(d*i)),v=t.Ur(new Uint8Array(d)),y=()=>{};if(u){let e=2*i*o,n=Math.max(Math.floor(e/1e4),1),r=0;y=()=>{if(r++,u&&(!(r%n)||r===e))try{u(r/e)}catch(e){throw t.jr(h,_,v),e}}}return{N:i,r:a,p:o,dkLen:s,blockSize32:f,V:_,B32:g,B:h,tmp:v,blockMixCb:y,asyncTick:c}}function Xe(e,n,r,i,a){let o=Ue(V,e,r,{c:1,dkLen:n});return t.jr(r,i,a),o}async function Ze(e,n,r){let{N:i,r:a,p:o,dkLen:s,blockSize32:c,V:l,B32:u,B:d,tmp:f,blockMixCb:p,asyncTick:m}=Ye(e,n,r);t.Hr(u);for(let e=0;e<o;e++){let n=c*e;for(let e=0;e<c;e++)l[e]=u[n+e];let r=0;await t.Or(i-1,m,()=>{Je(l,r,l,r+=c,a),p()}),Je(l,(i-1)*c,u,n,a),p(),await t.Or(i,m,()=>{let e=(u[n+c-16]&i-1)>>>0;for(let t=0;t<c;t++)f[t]=u[n+t]^l[e*c+t];Je(f,0,u,n,a),p()})}return t.Hr(u),Xe(e,s,d,l,f)}function Qe(e,n){return t.yr(k(t.Kr(e.slice(16,32),n))).slice(2)}async function $e(e,n,r){let i=t.zr(32),a=t.zr(16),o={dklen:32,salt:t.yr(i).slice(2),n:262144,r:8,p:1},s=await Ze(t.Yr(r,`utf8`),i,{N:o.n,r:o.r,p:o.p,dkLen:o.dklen}),c=Re(s.slice(0,16),a.map(e=>e)).encrypt(t.Kr(t.Yr(e),t.Yr(n)));return{id:t.yr(t.zr(16)).slice(2),crypto:{ciphertext:t.yr(c).slice(2),cipherparams:{iv:t.yr(a).slice(2)},cipher:`aes-128-ctr`,kdf:`scrypt`,kdfparams:o,mac:Qe(s,c)}}}async function et(e,n){if(typeof e!=`object`||!e||!(`crypto`in e))throw Error(`Invalid keystore`);let r=e.crypto;if(typeof r!=`object`||!r||!(`kdfparams`in r)||!(`ciphertext`in r)||typeof r.ciphertext!=`string`||!(`mac`in r)||typeof r.mac!=`string`||!(`cipherparams`in r)||typeof r.cipherparams!=`object`||r.cipherparams===null||!(`iv`in r.cipherparams)||typeof r.cipherparams.iv!=`string`)throw Error(`Invalid crypto`);let i=r.kdfparams;if(typeof i!=`object`||!i||!(`n`in i)||typeof i.n!=`number`||!(`r`in i)||typeof i.r!=`number`||!(`p`in i)||typeof i.p!=`number`||!(`dklen`in i)||typeof i.dklen!=`number`||!(`salt`in i)||typeof i.salt!=`string`)throw Error(`Invalid kdfparams`);let a=await Ze(t.Yr(n,`utf8`),t.Yr(i.salt),{N:i.n,r:i.r,p:i.p,dkLen:i.dklen}),o=t.Yr(r.ciphertext);if(Qe(a,o)!==r.mac)throw Error(`Invalid password`);let s=Re(a.slice(0,16),t.Yr(r.cipherparams.iv)).decrypt(o);return{privateKey:s.slice(0,32),chainCode:s.slice(32)}}var tt=class e{constructor(e,t){this.autoFinalized=e,this.inputsToSign=t}static from(t){return t instanceof e?t:new e(t?.autoFinalized??!0,t?.inputsToSign?.map(e=>nt.from(e))??[])}},nt=class e{constructor(e,t,n,r,i){this.index=e,this.sighashTypes=t,this.disableTweakSigner=n,this.address=r,this.publicKey=i}static from(n){return n instanceof e?n:new e(n.index,n.sighashTypes,n.disableTweakSigner,n.address,n.publicKey?t.yr(n.publicKey):void 0)}};
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function rt(e,t,n=()=>{}){if(!Array.isArray(e))throw TypeError(`"${t}" expected array, got type=${typeof e}`);for(let r=0;r<e.length;r++)n(e[r],`${t}[${r}]`);return e}const H=(e,n,r)=>t.Cr(e,n,r),it=t.Er;function at(e,t=``){if(typeof e!=`string`){let n=t&&`"${t}" `;throw TypeError(n+`expected string, got type=`+typeof e)}return e}function ot(e,t=`object`){if(typeof e!=`object`||!e||Array.isArray(e))throw TypeError(t===`object`?`expected valid options object`:`"${t}" expected object, got type=${typeof e}`);return e}function st(e,t){if(typeof e!=`function`)throw TypeError(`"${t}" is invalid: expected function, got ${typeof e}`);return e}const ct=t.kr,U=(...e)=>t.Mr(...e),lt=e=>t.Fr(e),ut=t.Ir,dt=e=>t.zr(e),ft=BigInt(0),pt=BigInt(1),mt=e=>e?`"${e}" `:``;function ht(e,t=``){if(typeof e!=`boolean`)throw TypeError(mt(t)+`expected boolean, got type=`+typeof e);return e}function gt(e){if(typeof e==`bigint`){if(!Et(e))throw RangeError(`positive bigint expected, got `+e)}else it(e);return e}function _t(e,t=``){if(typeof e!=`number`){let n=t&&`"${t}" `;throw TypeError(n+`expected number, got type=`+typeof e)}if(!Number.isSafeInteger(e)){let n=t&&`"${t}" `;throw RangeError(n+`expected safe integer, got `+e)}}function vt(e){let t=gt(e).toString(16);return t.length&1?`0`+t:t}function yt(e){if(typeof e!=`string`)throw TypeError(`hex string expected, got `+typeof e);return e===``?ft:BigInt(`0x`+e)}function bt(e){return yt(t.kr(e))}function xt(e){return yt(t.kr(wt(t.Cr(e)).reverse()))}function St(e,n){if(t.Er(n),n===0)throw Error(`zero output length is invalid`);e=gt(e);let r=n*2,i=e.toString(16);if(i.length>r)throw RangeError(`number is too large`);return t.Fr(i.padStart(r,`0`))}function Ct(e,t){return St(e,t).reverse()}function wt(e){return Uint8Array.from(H(e))}function Tt(e){if(typeof e!=`string`)throw TypeError(`ascii string expected, got `+typeof e);return Uint8Array.from(e,(t,n)=>{let r=t.charCodeAt(0);if(t.length!==1||r>127)throw RangeError(`string contains non-ASCII character "${e[n]}" with code ${r} at position ${n}`);return r})}function Et(e){return typeof e==`bigint`&&ft<=e}function Dt(e,t,n){return Et(e)&&Et(t)&&Et(n)&&t<=e&&e<n}function Ot(e,t,n,r){if(!Dt(t,n,r))throw RangeError(`expected valid `+e+`: `+n+` <= n < `+r+`, got `+t)}function kt(e){if(e<ft)throw Error(`expected non-negative bigint, got `+e);return e===ft?0:e.toString(2).length}const At=e=>(_t(e,`n`),(pt<<BigInt(e))-pt);function jt(e,n,r){if(t.Er(e,`hashLen`),t.Er(n,`qByteLen`),typeof r!=`function`)throw TypeError(`hmacFn must be a function`);let i=e=>new Uint8Array(e),a=Uint8Array.of(),o=Uint8Array.of(0),s=Uint8Array.of(1),c=i(e),l=i(e),u=0,d=()=>{c.fill(1),l.fill(0),u=0},f=(...e)=>r(l,U(c,...e)),p=(e=a)=>{l=f(o,e),c=f(),e.length!==0&&(l=f(s,e),c=f())},m=()=>{if(u++>=1e3)throw Error(`drbg: tried max amount of iterations`);let e=0,t=[];for(;e<n;){c=f();let n=c.slice();t.push(n),e+=c.length}return U(...t)};return(e,t)=>{d(),p(e);let n;for(;(n=t(m()))===void 0;)p();return d(),n}}function Mt(e,t={},n={},r=`object`){ot(e,r),ot(t,`fields`),ot(n,`optFields`);function i(t,n,i){let a=r===`object`?`param "${String(t)}"`:`"${r}.${String(t)}"`,o=e[t];if(!Object.hasOwn(e,t)&&(i?o!==void 0:n!==`function`))throw TypeError(`${a} is invalid: expected own property`);if(i&&o===void 0)return;let s=typeof o;if(s!==n||o===null)throw TypeError(`${a} is invalid: expected ${n}, got ${s}`)}let a=(e,t)=>Object.entries(e).forEach(([e,n])=>i(e,n,t));a(t,!1),a(n,!0)}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const W=BigInt(0),G=BigInt(1),K=BigInt(2),Nt=BigInt(3),Pt=BigInt(4),Ft=BigInt(5),It=BigInt(7),Lt=BigInt(8),Rt=BigInt(9),zt=BigInt(15),Bt=BigInt(16),Vt=BigInt(`0x10000000000000000`);function q(e,t){if(t<=W)throw Error(`mod: expected positive modulus, got `+t);let n=e%t;return n>=W?n:t+n}function Ht(e,t,n){if(n<=G)throw Error(`pow: expected modulus > 1, got `+n);if(typeof t!=`bigint`)throw TypeError(`invalid exponent: expected bigint, got `+typeof t);if(t<W)throw Error(`invalid exponent, negatives unsupported`);if(t===W)return G;if(t===G)return e;let r=e%n;if(r<W&&(r+=n),t<Vt){let e=G;for(;t>W;)t&G&&(e=e*r%n),r=r*r%n,t>>=G;return e}let i=[];for(;t>W;)i.push(Number(t&zt)),t>>=Pt;let a=Array(16);a[0]=G,a[1]=r;for(let e=2;e<16;e++)a[e]=a[e-1]*r%n;let o=a[i[i.length-1]];for(let e=i.length-2;e>=0;e--){o=o*o%n,o=o*o%n,o=o*o%n,o=o*o%n;let t=i[e];t!==0&&(o=o*a[t]%n)}return o}function J(e,t,n){if(n<=G)throw Error(`pow2: expected modulus > 1, got `+n);if(t<W)throw Error(`pow2: expected non-negative exponent, got `+t);let r=e;for(;t-->W;)r*=r,r%=n;return r}function Ut(e,t){if(e===W)throw Error(`invert: expected non-zero number`);if(t<=G)throw Error(`invert: expected modulus > 1, got `+t);let n=q(e,t),r=t,i=W,a=G;for(;n!==W;){let e=r/n,t=r-n*e,o=i-a*e;r=n,n=t,i=a,a=o}if(r!==G)throw Error(`invert: does not exist`);return q(i,t)}function Wt(e,t){if(t<=G)throw Error(`invertCt: expected prime modulus > 1, got `+t);let n=q(e,t);if(n===W)throw Error(`invertCt: expected non-zero number`);let r=Ht(n,t-K,t);if(q(n*r,t)!==G)throw Error(`invertCt: does not exist`);return r}function Gt(e,t,n){let r=e;if(!r.eql(r.sqr(t),n))throw Error(`Cannot find square root`)}function Kt(e,t){if((e&G)===W)throw Error(t+`: expected odd modulus, got `+e)}function qt(e,t){let n=e,r=(n.ORDER+G)/Pt,i=n.pow(t,r);return Gt(n,i,t),i}function Jt(e,t){let n=e,r=(n.ORDER-Ft)/Lt,i=n.mul(t,K),a=n.pow(i,r),o=n.mul(t,a),s=n.mul(n.mul(o,K),a),c=n.mul(o,n.sub(s,n.ONE));return Gt(n,c,t),c}function Yt(e){let t=on(e),n=Xt(e),r=n(t,t.neg(t.ONE)),i=n(t,r),a=n(t,t.neg(r)),o=(e+It)/Bt;return((e,t)=>{let n=e,s=n.pow(t,o),c=n.mul(s,r),l=n.mul(s,i),u=n.mul(s,a),d=n.eql(n.sqr(c),t),f=n.eql(n.sqr(l),t);s=n.cmov(s,c,d),c=n.cmov(u,l,f);let p=n.eql(n.sqr(c),t),m=n.cmov(s,c,p);return Gt(n,m,t),m})}function Xt(e){if(e<Nt)throw Error(`sqrt is not defined for small field`);Kt(e,`tonelliShanks`);let t=e-G,n=0;for(;t%K===W;)t/=K,n++;let r=K,i=on(e);for(;tn(i,r)===1;)if(r++>1e3)throw Error(`Cannot find square root: probably non-prime P`);if(n===1)return qt;let a=i.pow(r,t),o=(t+G)/K;return function(e,r){let i=e;if(i.is0(r))return r;if(tn(i,r)!==1)throw Error(`Cannot find square root`);let s=n,c=i.mul(i.ONE,a),l=i.pow(r,t),u=i.pow(r,o);for(;!i.eql(l,i.ONE);){if(i.is0(l))throw Error(`Cannot find square root: probably non-prime P`);let e=1,t=i.sqr(l);for(;!i.eql(t,i.ONE);)if(e++,t=i.sqr(t),e===s)throw Error(`Cannot find square root`);let n=G<<BigInt(s-e-1),r=i.pow(c,n);s=e,c=i.sqr(r),l=i.mul(l,c),u=i.mul(u,r)}return u}}function Zt(e){return Kt(e,`Fp.sqrt`),e%Pt===Nt?qt:e%Lt===Ft?Jt:e%Bt===Rt?Yt(e):Xt(e)}const Qt=[`create`,`isValid`,`is0`,`neg`,`inv`,`sqrt`,`sqr`,`eql`,`add`,`sub`,`mul`,`pow`,`div`,`addN`,`subN`,`mulN`,`sqrN`];function $t(e){if(ot(e,`field`),typeof e.ORDER!=`bigint`)throw TypeError(`param "ORDER" is invalid: expected bigint, got `+typeof e.ORDER);_t(e.BYTES,`BYTES`),_t(e.BITS,`BITS`);for(let t of Qt)st(e[t],`field.`+t);if(e.BYTES<1||e.BITS<1)throw Error(`invalid field: expected BYTES/BITS > 0`);if(e.ORDER<=G)throw Error(`invalid field: expected ORDER > 1, got `+e.ORDER);return e}function en(e,t,n=!1){$t(e),rt(t,`nums`),ht(n,`passZero`);let r=e,i=Array(t.length).fill(n?r.ZERO:void 0),a=t.reduce((e,t,n)=>r.is0(t)?e:(i[n]=e,r.mul(e,t)),r.ONE),o=r.inv(a);return t.reduceRight((e,t,n)=>r.is0(t)?e:(i[n]=r.mul(e,i[n]),r.mul(e,t)),o),i}function tn(e,t){$t(e);let n=e;Kt(n.ORDER,`FpLegendre`);let r=(n.ORDER-G)/K,i=n.pow(t,r),a=n.eql(i,n.ONE),o=n.eql(i,n.ZERO),s=n.eql(i,n.neg(n.ONE));if(!a&&!o&&!s)throw Error(`invalid Legendre symbol result`);return a?1:o?0:-1}function nn(e,t){if(t!==void 0&&it(t),e<=W)throw Error(`invalid n length: expected positive n, got `+e);if(t!==void 0&&t<1)throw Error(`invalid n length: expected positive bit length, got `+t);let n=kt(e);if(t!==void 0&&t<n)throw Error(`invalid n length: expected nBitLength (${t}) >= bitLen(n) (${n})`);let r=t===void 0?n:t;return{nBitLength:r,nByteLength:Math.ceil(r/8)}}const rn=new WeakMap;var an=class{ORDER;BITS;BYTES;isLE;ZERO=W;ONE=G;_lengths;_mod;constructor(e,t={}){if(e<=G)throw Error(`invalid field: expected ORDER > 1, got `+e);let n;this.isLE=!1,typeof t==`object`&&t&&(typeof t.BITS==`number`&&(n=t.BITS),typeof t.sqrt==`function`&&Object.defineProperty(this,"sqrt",{value:t.sqrt,enumerable:!0}),typeof t.isLE==`boolean`&&(this.isLE=t.isLE),t.allowedLengths&&(this._lengths=Object.freeze(t.allowedLengths.slice())),typeof t.modFromBytes==`boolean`&&(this._mod=t.modFromBytes));let{nBitLength:r,nByteLength:i}=nn(e,n);if(i>2048)throw Error(`invalid field: expected ORDER of <= 2048 bytes`);this.ORDER=e,this.BITS=r,this.BYTES=i,Object.freeze(this)}create(e){return q(e,this.ORDER)}isValid(e){if(typeof e!=`bigint`)throw TypeError(`invalid field element: expected bigint, got `+typeof e);return W<=e&&e<this.ORDER}is0(e){return e===W}isValidNot0(e){return!this.is0(e)&&this.isValid(e)}isOdd(e){return(e&G)===G}neg(e){return q(-e,this.ORDER)}eql(e,t){return e===t}sqr(e){return q(e*e,this.ORDER)}add(e,t){return q(e+t,this.ORDER)}sub(e,t){return q(e-t,this.ORDER)}mul(e,t){return q(e*t,this.ORDER)}pow(e,t){return Ht(e,t,this.ORDER)}div(e,t){return q(e*Ut(t,this.ORDER),this.ORDER)}sqrN(e){return e*e}addN(e,t){return e+t}subN(e,t){return e-t}mulN(e,t){return e*t}inv(e){return Ut(e,this.ORDER)}sqrt(e){let t=rn.get(this);return t||rn.set(this,t=Zt(this.ORDER)),t(this,e)}toBytes(e){return this.isLE?Ct(e,this.BYTES):St(e,this.BYTES)}fromBytes(e,t=!1){H(e);let{_lengths:n,BYTES:r,isLE:i,ORDER:a,_mod:o}=this;if(n){if(e.length<1||!n.includes(e.length)||e.length>r)throw Error(`Field.fromBytes: expected `+n+` bytes, got `+e.length);let t=new Uint8Array(r);t.set(e,i?0:t.length-e.length),e=t}if(e.length!==r)throw Error(`Field.fromBytes: expected `+r+` bytes, got `+e.length);let s=i?xt(e):bt(e);if(o&&(s=q(s,a)),!t&&!this.isValid(s))throw Error(`invalid field element: outside of range 0..ORDER`);return s}invertBatch(e){return en(this,e,!0)}cmov(e,t,n){return ht(n,`condition`),n?t:e}};function on(e,t={}){return Object.freeze(an.prototype),new an(e,t)}function sn(e){if(typeof e!=`bigint`)throw Error(`field order must be bigint`);if(e<=G)throw Error(`field order must be greater than 1`);let t=kt(e-G);return Math.ceil(t/8)}function cn(e){let t=sn(e);return t+Math.ceil(t/2)}function ln(e,t,n=!1){H(e);let r=e.length,i=sn(t),a=Math.max(cn(t),16);if(r<a||r>1024)throw Error(`expected `+a+`-1024 bytes of input, got `+r);let o=q(n?xt(e):bt(e),t-G)+G;return n?Ct(o,i):St(o,i)}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const un=BigInt(0),dn=BigInt(1),fn=BigInt(4),pn=2**31;function mn(e){let t=e;if(typeof t!=`function`)throw TypeError(`"Point" expected constructor, got type=`+typeof e);st(t.fromAffine,`Point.fromAffine`),st(t.fromBytes,`Point.fromBytes`),st(t.fromHex,`Point.fromHex`),ot(t.BASE,`Point.BASE`),ot(t.ZERO,`Point.ZERO`),$t(t.Fp),$t(t.Fn)}function hn(e,t){mn(e),yn(t,e);let n=en(e.Fp,t.map(e=>e.Z));return t.map((t,r)=>e.fromAffine(t.toAffine(n[r])))}function gn(e,t,n=1){if(!Number.isSafeInteger(e)||e<n||e>t)throw Error(`invalid window size, expected [`+n+`..`+t+`], got W=`+e)}function _n(e,t){let n=e*(4*t+128);if(n>pn)throw Error(`invalid window size: table would need ~`+Math.ceil(n/2**20)+` MiB, max `+pn/2**20+` MiB`)}function vn(e,t){if(e!==void 0){st(e,`randomBytes`);try{let n=e(t);if(!ut(n)||n.length!==t)return}catch{return}return e}}function yn(e,t){rt(e,`points`),e.forEach((e,n)=>{if(!(e instanceof t))throw Error(`invalid point at index `+n)})}function bn(e,t,n){if(!Array.isArray(e))throw Error(`array of scalars expected`);e.forEach((e,r)=>{if(!(n===void 0?t.isValid(e):Et(e)&&e<n))throw Error(`invalid scalar at index `+r)})}const xn=new WeakMap;function Sn(e){return xn.get(e)||1}function Cn(e,t){let n=e.double(),r=[e];for(let e=1;e<t;e++)r.push(r[e-1].add(n));return r}function wn(e,t){let n=2**t,r=n/2,i=BigInt(n-1),a=[];for(;e>un;){let t=0;e&dn&&(t=Number(e&i),t>=r&&(t-=n),e-=BigInt(t)),a.push(t),e>>=dn}return a}function Tn(e,t,n){let r=2**t,i=r/2,a=BigInt(r-1),o=BigInt(t),s=[];for(let t=0;t<n;t++){let t=Number(e&a);e>>=o,t>i&&(t-=r,e+=dn),s.push(t)}if(e!==un)throw Error(`invalid wnaf`);return s}function En(e,t,n){let r=0;for(let e of n)r=Math.max(r,e.length);let i=e;for(let e=r-1;e>=0;e--){e!==r-1&&(i=i.double());for(let r=0;r<n.length;r++){let a=n[r][e];if(a){let e=t[r][Math.abs(a)-1>>1];i=i.add(a<0?e.negate():e)}}}return i}var Dn=class{Point;BASE;ZERO;randomBytes;wnafPrecomputes=new WeakMap;baseCanBeBlinded;bits;constructor(e,t){mn(e),this.randomBytes=vn(t,16),this.Point=e,this.BASE=e.BASE,this.ZERO=e.ZERO,this.bits=e.Fn.BITS}buildWnafTable(e,t,n){let r=Math.ceil(n/t)+1,i=2**(t-1),a=[],o=e;for(let e=0;e<r;e++){let e=o;for(let t=0;t<i;t++)a.push(e),e=e.add(o);o=a[a.length-1].double()}return{W:t,bits:n,windows:r,comp:a}}wnafCachedCT(e,t){let{W:n,windows:r,comp:i}=e,a=2**(n-1),o=Tn(t,n,r),s=this.ZERO,c=this.BASE;for(let e=0;e<r;e++){let t=o[e],n=e*a,r=Math.abs(t)-1,l=i[n];for(let e=1;e<a;e++)l=e===r?i[n+e]:l;let u=l.negate();t===0?c=c.add(i[n]):s=s.add(t<0?u:l)}return{p:s,f:c}}getWnafPrecomputes(e,t,n,r){let i=this.wnafPrecomputes.get(t),a=i?.find(t=>t.W===e&&t.bits===n);return a||(a=this.buildWnafTable(t,e,n),typeof r==`function`&&(a={...a,comp:r(a.comp)}),i||(i=[],this.wnafPrecomputes.set(t,i)),i.push(a)),a}assertPoint(e){if(!(e instanceof this.Point))throw TypeError(`"point" expected Point instance, got type=`+typeof e)}validateMulInput(e,t){if(this.assertPoint(e),!Dt(t,dn,this.Point.Fn.ORDER))throw Error(`invalid scalar`)}runCT(e,t,n,r){let i=Sn(e);return i===1?this.fixedWindowCT(e,t,n):this.wnafCachedCT(this.getWnafPrecomputes(i,e,n,r),t)}mulCT(e,t,n){return this.validateMulInput(e,t),this.runCT(e,t,this.bits,n)}mulCTBlinded(e,t,n){if(this.validateMulInput(e,t),this.randomBytes===void 0)throw Error(`randomBytes is required for scalar blinding`);let r=this.Point.Fn.BITS+128,i=this.randomBytes(16);if(!ut(i)||i.length!==16)throw Error(`randomBytes returned invalid byte array`);i[0]=i[0]&63|128;let a=t+bt(i)*this.Point.Fn.ORDER;return this.runCT(e,a,r,n)}fixedWindowCT(e,t,n){let r=At(5),i=Array(32);i[0]=this.ZERO;for(let t=1;t<32;t++)i[t]=i[t-1].add(e);let a=Math.ceil(n/5),o=this.ZERO;for(let e=a-1;e>=0;e--){if(e!==a-1)for(let e=0;e<5;e++)o=o.double();let n=Number(t>>BigInt(e*5)&r),s=i[0];for(let e=1;e<32;e++)s=e===n?i[e]:s;o=o.add(s)}return{p:o,f:o}}shouldBlind(e,t){return this.randomBytes===void 0?!1:t===dn?!0:e===this.BASE?(this.baseCanBeBlinded===void 0&&(this.baseCanBeBlinded=this.mulUnsafe(this.BASE,this.Point.Fn.ORDER).is0()),this.baseCanBeBlinded):!1}mulSecret(e,t,n,r){return this.shouldBlind(e,n)?this.mulCTBlinded(e,t,r):this.mulCT(e,t,r)}mulUnsafe(e,t,n){if(this.assertPoint(e),!Et(t))throw Error(`invalid scalar`);let r=Sn(e);if(r===1||t>=this.Point.Fn.ORDER)return On(this.Point,[e],[t],!0);let i=this.getWnafPrecomputes(r,e,this.bits,n);return this.wnafCachedCT(i,t).p}setWindowSize(e,t){this.assertPoint(e),gn(t,this.bits),_n((Math.ceil((this.bits+128)/t)+1)*2**(t-1),this.Point.Fp.BYTES),xn.set(e,t),this.wnafPrecomputes.delete(e)}hasWindowSize(e){return Sn(e)!==1}};function On(e,t,n,r=!1){if(mn(e),yn(t,e),ht(r,`allowOversized`),bn(n,e.Fn,r?e.Fn.ORDER**fn:void 0),t.length!==n.length)throw Error(`arrays of points and scalars must have equal length`);let i=t.map(e=>Cn(e,4)),a=n.map(e=>wn(e,4));return En(e.ZERO,i,a)}function kn(e,t,n){if(t){if(t.ORDER!==e)throw Error(`Field.ORDER must match order: Fp == p, Fn == n`);return $t(t),t}else return on(e,{isLE:n})}function An(e,t,n={},r){if(e!==`weierstrass`&&e!==`edwards`)throw Error(`expected curve type "weierstrass" or "edwards"`);if(r===void 0&&(r=e===`edwards`),!t||typeof t!=`object`)throw Error(`expected valid ${e} CURVE object`);Mt(n);for(let e of[`p`,`n`,`h`]){let n=t[e];if(!(Et(n)&&n!==un))throw Error(`CURVE.${e} must be positive bigint`)}let i=kn(t.p,n.Fp,r),a=kn(t.n,n.Fn,r),o=[`Gx`,`Gy`,`a`,e===`weierstrass`?`b`:`d`];for(let e of o)if(!i.isValid(t[e]))throw Error(`CURVE.${e} must be valid field element of CURVE.Fp`);return t=Object.freeze(Object.assign({},t)),{CURVE:t,Fp:i,Fn:a}}function jn(e,t){return function(n){let r=e(n);return{secretKey:r,publicKey:t(r)}}}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const Mn=BigInt(0),Y={Err:class extends Error{constructor(e=``){super(e)}},_tlv:{encode:(e,t)=>{let{Err:n}=Y;if(_t(e,`tag`),e<0||e>255)throw new n(`tlv.encode: wrong tag`);if(at(t,`data`),t.length&1)throw new n(`tlv.encode: unpadded data`);let r=t.length/2,i=vt(r);if(i.length/2&128)throw new n(`tlv.encode: long form length too big`);let a=r>127?vt(i.length/2|128):``;return vt(e)+a+i+t},decode(e,t){let{Err:n}=Y;t=H(t,void 0,`DER data`);let r=0;if(e<0||e>255)throw new n(`tlv.decode: wrong tag`);if(t.length<2||t[r++]!==e)throw new n(`tlv.decode: wrong tlv`);let i=t[r++],a=!!(i&128),o=0;if(!a)o=i;else{let e=i&127;if(!e)throw new n(`tlv.decode(long): indefinite length not supported`);if(e>4)throw new n(`tlv.decode(long): byte length is too big`);let a=t.subarray(r,r+e);if(a.length!==e)throw new n(`tlv.decode: length bytes not complete`);if(a[0]===0)throw new n(`tlv.decode(long): zero leftmost byte`);for(let e of a)o=o<<8|e;if(r+=e,o<128)throw new n(`tlv.decode(long): not minimal encoding`)}let s=t.subarray(r,r+o);if(s.length!==o)throw new n(`tlv.decode: wrong value length`);return{v:s,l:t.subarray(r+o)}}},_int:{encode(e){let{Err:t}=Y;if(gt(e),e<Mn)throw new t(`integer: negative integers are not allowed`);let n=vt(e);if(Number.parseInt(n[0],16)&8&&(n=`00`+n),n.length&1)throw new t(`unexpected DER parsing assertion: unpadded hex`);return n},decode(e){let{Err:t}=Y;if(e.length<1)throw new t(`invalid signature integer: empty`);if(e[0]&128)throw new t(`invalid signature integer: negative`);if(e.length>1&&e[0]===0&&!(e[1]&128))throw new t(`invalid signature integer: unnecessary leading zero`);return bt(e)}},toSig(e){let{Err:t,_int:n,_tlv:r}=Y,i=H(e,void 0,`signature`),{v:a,l:o}=r.decode(48,i);if(o.length)throw new t(`invalid signature: left bytes after parsing`);let{v:s,l:c}=r.decode(2,a),{v:l,l:u}=r.decode(2,c);if(u.length)throw new t(`invalid signature: left bytes after parsing`);return{r:n.decode(s),s:n.decode(l)}},hexFromSig(e){let{_tlv:t,_int:n}=Y;Mt(e,{r:`bigint`,s:`bigint`},{},`sig`);let r=t.encode(2,n.encode(e.r))+t.encode(2,n.encode(e.s));return t.encode(48,r)}},Nn=(Object.freeze(Y._tlv),Object.freeze(Y._int),Object.freeze(Y)),Pn=(e,t)=>(e+(e>=0?t:-t)/zn)/t
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+;function Fn(e,t,n){Ot(`scalar`,e,X,n);let[[r,i],[a,o]]=t,s=Pn(o*e,n),c=Pn(-i*e,n),l=e-s*r-c*a,u=-s*i-c*o,d=l<X,f=u<X;d&&(l=-l),f&&(u=-u);let p=At(Math.ceil(kt(n)/2))+Rn;if(l<X||l>=p||u<X||u>=p)throw Error(`splitScalar (endomorphism): failed for k`);return{k1neg:d,k1:l,k2neg:f,k2:u}}function In(e){if(![`compact`,`recovered`,`der`].includes(e))throw Error(`Signature format must be "compact", "recovered", or "der"`);return e}function Ln(e,t){Mt(e);let n={};for(let r of Object.keys(t))n[r]=e[r]===void 0?t[r]:e[r];return ht(n.lowS,`lowS`),ht(n.prehash,`prehash`),n.format!==void 0&&In(n.format),n}const X=BigInt(0),Rn=BigInt(1),zn=BigInt(2),Bn=BigInt(3),Vn=BigInt(4);function Hn(e,t={}){let n=An(`weierstrass`,e,t),r=n.Fp,i=n.Fn,a=n.CURVE,{h:o,n:s}=a;Mt(t,{},{allowInfinityPoint:`boolean`,clearCofactor:`function`,isTorsionFree:`function`,fromBytes:`function`,toBytes:`function`,endo:`object`,randomBytes:`function`});let{endo:c,allowInfinityPoint:l}=t,u=t.randomBytes===void 0?dt:t.randomBytes;if(c&&(!r.is0(a.a)||typeof c.beta!=`bigint`||!Array.isArray(c.basises)))throw Error(`invalid endo: expected "beta": bigint and "basises": array`);let d=Wn(r,i);function f(){if(!r.isOdd)throw Error(`compression is not supported: Field does not have .isOdd()`)}function p(e,t,n){if(l&&t.is0())return Uint8Array.of(0);let{x:i,y:a}=t.toAffine(),o=r.toBytes(i);return ht(n,`isCompressed`),n?(f(),U(Un(!r.isOdd(a)),o)):U(Uint8Array.of(4),o,r.toBytes(a))}function m(e){H(e,void 0,`Point`);let{publicKey:t,publicKeyUncompressed:n}=d,i=e.length,a=e[0],o=e.subarray(1);if(l&&i===1&&a===0)return{x:r.ZERO,y:r.ZERO};if(i===t&&(a===2||a===3)){let e=r.fromBytes(o);if(!r.isValid(e))throw Error(`bad point: is not on curve, wrong x`);let t=y(e),n;try{n=r.sqrt(t)}catch(e){let t=e instanceof Error?`: `+e.message:``;throw Error(`bad point: is not on curve, sqrt error`+t)}f();let i=r.isOdd(n);return(a&1)==1!==i&&(n=r.neg(n)),{x:e,y:n}}else if(i===n&&a===4){let e=r.BYTES,t=r.fromBytes(o.subarray(0,e)),n=r.fromBytes(o.subarray(e,e*2));if(!b(t,n))throw Error(`bad point: is not on curve`);return{x:t,y:n}}else throw Error(`bad point: got length ${i}, expected compressed=${t} or uncompressed=${n}`)}let h=t.toBytes===void 0?p:t.toBytes,g=t.fromBytes===void 0?m:t.fromBytes,_=r.mul(a.b,Bn),v=r.is0(a.a)?e=>r.ZERO:e=>r.mul(a.a,e);function y(e){let t=r.sqr(e),n=r.mul(t,e);return r.add(r.add(n,r.mul(e,a.a)),a.b)}function b(e,t){let n=r.sqr(t),i=y(e);return r.eql(n,i)}if(!b(a.Gx,a.Gy))throw Error(`bad curve params: generator point`);let ee=r.mul(r.pow(a.a,Bn),Vn),te=r.mul(r.sqr(a.b),BigInt(27));if(r.is0(r.add(ee,te)))throw Error(`bad curve params: a or b`);function x(e,t,n=!1){if(!r.isValid(t)||n&&r.is0(t))throw Error(`bad point coordinate ${e}`);return t}function S(e){if(!(e instanceof E))throw Error(`Weierstrass Point expected`)}function C(e){if(!c||!c.basises)throw Error(`no endo`);return Fn(e,c.basises,i.ORDER)}function w(e,t,n,a){if(!i.isValid(a))throw RangeError(`invalid scalar: out of range`);if(c){let{k1neg:i,k1:o,k2neg:s,k2:l}=C(a),u=new E(r.mul(n.X,c.beta),n.Y,n.Z);e.push(i?n.negate():n,s?u.negate():u),t.push(o,l)}else e.push(n),t.push(a)}let T=new WeakSet;class E{static BASE=new E(a.Gx,a.Gy,r.ONE);static ZERO=new E(r.ZERO,r.ONE,r.ZERO);static Fp=r;static Fn=i;X;Y;Z;constructor(e,t,n){this.X=x(`x`,e),this.Y=x(`y`,t,!0),this.Z=x(`z`,n),Object.freeze(this)}static CURVE(){return a}static fromAffine(e){let{x:t,y:n}=e||{};if(!e||!r.isValid(t)||!r.isValid(n))throw Error(`invalid affine point`);if(e instanceof E)throw Error(`projective point not allowed`);return r.is0(t)&&r.is0(n)?E.ZERO:new E(t,n,r.ONE)}static fromBytes(e){let t=E.fromAffine(g(H(e,void 0,`point`)));return t.assertValidity(),t}static fromHex(e){return E.fromBytes(lt(e))}get x(){return this.toAffine().x}get y(){return this.toAffine().y}precompute(e=6,t=!0){return O.setWindowSize(this,e),t||this.multiply(Bn),this}assertValidity(){let e=this;if(e.is0()){if(t.allowInfinityPoint&&r.is0(e.X)&&r.eql(e.Y,r.ONE)&&r.is0(e.Z))return;throw Error(`bad point: ZERO`)}if(T.has(e))return;let{x:n,y:i}=e.toAffine();if(!r.isValid(n)||!r.isValid(i))throw Error(`bad point: x or y not field elements`);if(!b(n,i))throw Error(`bad point: equation left != right`);if(!e.isTorsionFree())throw Error(`bad point: not in prime-order subgroup`);T.add(e)}hasEvenY(){let{y:e}=this.toAffine();if(!r.isOdd)throw Error(`Field doesn't support isOdd`);return!r.isOdd(e)}equals(e){S(e);let{X:t,Y:n,Z:i}=this,{X:a,Y:o,Z:s}=e,c=r.eql(r.mul(t,s),r.mul(a,i)),l=r.eql(r.mul(n,s),r.mul(o,i));return c&&l}negate(){return new E(this.X,r.neg(this.Y),this.Z)}double(){let{X:e,Y:t,Z:n}=this,i=r.ZERO,a=r.ZERO,o=r.ZERO,s=r.mul(e,e),c=r.mul(t,t),l=r.mul(n,n),u=r.mul(e,t);return u=r.add(u,u),o=r.mul(e,n),o=r.add(o,o),i=v(o),a=r.mul(_,l),a=r.add(i,a),i=r.sub(c,a),a=r.add(c,a),a=r.mul(i,a),i=r.mul(u,i),o=r.mul(_,o),l=v(l),u=r.sub(s,l),u=v(u),u=r.add(u,o),o=r.add(s,s),s=r.add(o,s),s=r.add(s,l),s=r.mul(s,u),a=r.add(a,s),l=r.mul(t,n),l=r.add(l,l),s=r.mul(l,u),i=r.sub(i,s),o=r.mul(l,c),o=r.add(o,o),o=r.add(o,o),new E(i,a,o)}add(e){S(e);let{X:t,Y:n,Z:i}=this,{X:a,Y:o,Z:s}=e,c=r.ZERO,l=r.ZERO,u=r.ZERO,d=r.mul(t,a),f=r.mul(n,o),p=r.mul(i,s),m=r.add(t,n),h=r.add(a,o);m=r.mul(m,h),h=r.add(d,f),m=r.sub(m,h),h=r.add(t,i);let g=r.add(a,s);return h=r.mul(h,g),g=r.add(d,p),h=r.sub(h,g),g=r.add(n,i),c=r.add(o,s),g=r.mul(g,c),c=r.add(f,p),g=r.sub(g,c),u=v(h),c=r.mul(_,p),u=r.add(c,u),c=r.sub(f,u),u=r.add(f,u),l=r.mul(c,u),f=r.add(d,d),f=r.add(f,d),p=v(p),h=r.mul(_,h),f=r.add(f,p),p=r.sub(d,p),p=v(p),h=r.add(h,p),d=r.mul(f,h),l=r.add(l,d),d=r.mul(g,h),c=r.mul(m,c),c=r.sub(c,d),d=r.mul(m,f),u=r.mul(g,u),u=r.add(u,d),new E(c,l,u)}subtract(e){return S(e),this.add(e.negate())}is0(){return this.equals(E.ZERO)}multiply(e){if(!i.isValidNot0(e))throw RangeError(`invalid scalar: out of range`);let{p:t,f:n}=O.mulSecret(this,e,o,D);return D([t,n])[0]}multiplyUnsafe(e){let t=this,n=e;if(!i.isValid(n))throw RangeError(`invalid scalar: out of range`);if(n===X||t.is0())return E.ZERO;if(n===Rn)return t;if(O.hasWindowSize(this))return O.mulUnsafe(t,n,D);let r=[],a=[];return w(r,a,t,n),On(E,r,a)}mulAddUnsafe(e,t,n){S(t);let r=[],i=[];return w(r,i,this,e),w(r,i,t,n),On(E,r,i)}toAffine(e){let t=this,n=e;if(n!=null&&!r.isValid(n))throw RangeError(`"invertedZ" expected valid field element`);let{X:i,Y:a,Z:o}=t;if(r.eql(o,r.ONE))return{x:i,y:a};let s=t.is0();n??=s?r.ONE:r.inv(o);let c=r.mul(i,n),l=r.mul(a,n),u=r.mul(o,n);if(s)return{x:r.ZERO,y:r.ZERO};if(!r.eql(u,r.ONE))throw Error(`invZ was invalid`);return{x:c,y:l}}isTorsionFree(){let{isTorsionFree:e}=t;return o===Rn?!0:e?e(E,this):O.mulUnsafe(this,s).is0()}clearCofactor(){let{clearCofactor:e}=t;return o===Rn?this:e?e(E,this):this.multiplyUnsafe(o)}isSmallOrder(){return o===Rn?this.is0():this.clearCofactor().is0()}toBytes(e=!0){return ht(e,`isCompressed`),this.assertValidity(),h(E,this,e)}toHex(e=!0){return ct(this.toBytes(e))}toString(){return`<Point ${this.is0()?`ZERO`:this.toHex()}>`}}let D=e=>hn(E,e),O=new Dn(E,u);return O.bits>=6&&E.BASE.precompute(6),Object.freeze(E.prototype),Object.freeze(E),E}function Un(e){return Uint8Array.of(e?2:3)}function Wn(e,t){return{secretKey:t.BYTES,publicKey:1+e.BYTES,publicKeyUncompressed:1+2*e.BYTES,publicKeyHasPrefix:!0,signature:2*t.BYTES}}function Gn(e,t={}){mn(e);let{Fn:n}=e,r=t.randomBytes===void 0?dt:t.randomBytes,i=Object.assign(Wn(e.Fp,n),{seed:Math.max(cn(n.ORDER),16)});function a(e){try{let t=n.fromBytes(e);return n.isValidNot0(t)}catch{return!1}}function o(t,n){let{publicKey:r,publicKeyUncompressed:a}=i;try{let i=t.length;return n===!0&&i!==r||n===!1&&i!==a?!1:!!e.fromBytes(t)}catch{return!1}}function s(e){return e=e===void 0?r(i.seed):e,ln(H(e,i.seed,`seed`),n.ORDER)}function c(t,r=!0){return e.BASE.multiply(n.fromBytes(t)).toBytes(r)}function l(e){let{secretKey:t,publicKey:r,publicKeyUncompressed:a}=i,o=n._lengths;if(!ut(e))return;let s=H(e,void 0,`key`).length,c=s===r||s===a,l=s===t||!!o?.includes(s);if(!(c&&l))return c}function u(t,r,i=!0){if(l(t)===!0)throw Error(`first arg must be private key`);if(l(r)===!1)throw Error(`second arg must be public key`);let a=n.fromBytes(t);return e.fromBytes(r).multiply(a).toBytes(i)}let d={isValidSecretKey:a,isValidPublicKey:o,randomSecretKey:s},f=jn(s,c);return Object.freeze(d),Object.freeze(i),Object.freeze({getPublicKey:c,getSharedSecret:u,keygen:f,Point:e,utils:d,lengths:i})}function Kn(e,n,r={}){mn(e);let i=n;t.Tr(i),Mt(r,{},{hmac:`function`,lowS:`boolean`,randomBytes:`function`,bits2int:`function`,bits2int_modN:`function`});let a=Object.assign({},r),o=a.randomBytes===void 0?dt:a.randomBytes,s=a.hmac===void 0?(e,t)=>Be(i,e,t):a.hmac,{Fp:c,Fn:l}=e,{ORDER:u,BITS:d}=l,f=cn(u),p=vn(o,f),{keygen:m,getPublicKey:h,getSharedSecret:g,utils:_,lengths:v}=Gn(e,a),y={prehash:!0,lowS:typeof a.lowS!=`boolean`||a.lowS,format:`compact`,extraEntropy:!1},b=u*zn+Rn<c.ORDER;function ee(e){return e>u>>Rn}function te(e,t){if(!l.isValidNot0(t))throw Error(`invalid signature ${e}: out of range 1..Point.Fn.ORDER`);return t}function x(){if(!c.isOdd)throw Error(`Field doesn't support isOdd`)}function S(e,t,n){return x(),(e===n?0:2)|Number(c.isOdd(t))}function C(){if(b)throw Error(`"recovered" sig type is not supported for cofactor >2 curves`)}function w(e,t){In(t);let n=v.signature;return H(e,t===`compact`?n:t===`recovered`?n+1:void 0)}class T{r;s;recovery;constructor(e,t,n){if(this.r=te(`r`,e),this.s=te(`s`,t),n!=null){if(C(),![0,1,2,3].includes(n))throw Error(`invalid recovery id`);this.recovery=n}Object.freeze(this)}static fromBytes(e,t=y.format){w(e,t);let n;if(t===`der`){let{r:t,s:n}=Nn.toSig(H(e));return new T(t,n)}t===`recovered`&&(n=e[0],t=`compact`,e=e.subarray(1));let r=v.signature/2,i=e.subarray(0,r),a=e.subarray(r,r*2);return new T(l.fromBytes(i),l.fromBytes(a),n)}static fromHex(e,t){return this.fromBytes(lt(e),t)}assertRecovery(){let{recovery:e}=this;if(e==null)throw Error(`invalid recovery id: must be present`);return e}addRecoveryBit(e){return new T(this.r,this.s,e)}recoverPublicKey(t){let{r:n,s:r}=this,i=this.assertRecovery(),a=i===2||i===3?n+u:n;if(!c.isValid(a))throw Error(`invalid recovery id: sig.r+curve.n != R.x`);let o=c.toBytes(a),s=e.fromBytes(U(Un((i&1)==0),o)),d=l.inv(a),f=D(H(t,void 0,`msgHash`)),p=l.create(-f*d),m=l.create(r*d),h=e.BASE.mulAddUnsafe(p,s,m);if(h.is0())throw Error(`invalid recovery: point at infinify`);return h.assertValidity(),h}hasHighS(){return ee(this.s)}toBytes(e=y.format){if(In(e),e===`der`)return lt(Nn.hexFromSig(this));let{r:t,s:n}=this,r=l.toBytes(t),i=l.toBytes(n);return e===`recovered`?(C(),U(Uint8Array.of(this.assertRecovery()),r,i)):U(r,i)}toHex(e){return ct(this.toBytes(e))}}Object.freeze(T.prototype),Object.freeze(T);let E=a.bits2int===void 0?function(e){if(e.length>8192)throw Error(`input is too large`);let t=bt(e),n=e.length*8-d;return n>0?t>>BigInt(n):t}:a.bits2int,D=a.bits2int_modN===void 0?function(e){return l.create(E(e))}:a.bits2int_modN,O=At(d);function k(e){return Ot(`num < 2^`+d,e,X,O),l.toBytes(e)}function A(e,t){return H(e,void 0,`message`),t?H(i(e),void 0,`prehashed message`):e}function j(t,n,r){let{lowS:i,prehash:a,extraEntropy:s}=Ln(r,y);t=A(t,a);let c=D(t),d=l.fromBytes(n);if(!l.isValidNot0(d))throw Error(`invalid private key`);let m=[k(d),k(c)];if(s!=null&&s!==!1){let e=s===!0?o(v.secretKey):s;m.push(H(e,void 0,`extraEntropy`))}let h=U(...m),g=c;function _(t){let n=E(t);if(!l.isValidNot0(n))return;let r=e.BASE.multiply(n).toAffine(),a=l.create(r.x);if(a===X)return;let o;if(p!==void 0){let e=bt(ln(p(f),u)),t=l.inv(l.mul(e,n)),r=l.mul(e,g),i=l.mul(e,d);o=l.create(t*l.create(r+i*a))}else{let e=Wt(n,u);o=l.create(e*l.create(g+a*d))}if(o===X)return;let s=S(r.x,r.y,a),c=o;return i&&ee(o)&&(c=l.neg(o),s^=1),new T(a,c,b?void 0:s)}return{seed:h,k2sig:_}}function M(e,t,n={}){let{seed:r,k2sig:a}=j(e,t,n);return jt(i.outputLen,l.BYTES,s)(r,a).toBytes(n.format)}function N(t,n,r,i={}){let{lowS:a,prehash:o,format:s}=Ln(i,y);if(r=H(r,void 0,`publicKey`),n=A(n,o),!ut(t)){let e=t instanceof T?`, use sig.toBytes()`:``;throw Error(`verify expects Uint8Array signature`+e)}w(t,s);try{let i=T.fromBytes(t,s),o=e.fromBytes(r);if(a&&i.hasHighS())return!1;let{r:c,s:u}=i,d=D(n),f=l.inv(u),p=l.create(d*f),m=l.create(c*f),h=e.BASE.mulAddUnsafe(p,o,m);if(h.is0())return!1;let g=h.toAffine();return!(l.create(g.x)!==c||s===`recovered`&&i.recovery!==S(g.x,g.y,c))}catch{return!1}}function P(e,t,n={}){let{prehash:r}=Ln(n,y);return t=A(t,r),T.fromBytes(e,`recovered`).recoverPublicKey(t).toBytes()}return Object.freeze({keygen:m,getPublicKey:h,getSharedSecret:g,utils:_,lengths:v,Point:e,sign:M,verify:N,recoverPublicKey:P,Signature:T,hash:i})}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const qn={p:BigInt(`0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f`),n:BigInt(`0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141`),h:BigInt(1),a:BigInt(0),b:BigInt(7),Gx:BigInt(`0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798`),Gy:BigInt(`0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8`)},Jn={beta:BigInt(`0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee`),basises:[[BigInt(`0x3086d221a7d46bcde86c90e49284eb15`),-BigInt(`0xe4437ed6010e88286f547fa90abfe4c3`)],[BigInt(`0x114ca50f7a8e2f3f657c1108d9d44cfd8`),BigInt(`0x3086d221a7d46bcde86c90e49284eb15`)]]},Yn=BigInt(0),Xn=BigInt(2);function Zn(e){let t=qn.p,n=BigInt(3),r=BigInt(6),i=BigInt(11),a=BigInt(22),o=BigInt(23),s=BigInt(44),c=BigInt(88),l=e*e*e%t,u=l*l*e%t,d=J(J(J(u,n,t)*u%t,n,t)*u%t,Xn,t)*l%t,f=J(d,i,t)*d%t,p=J(f,a,t)*f%t,m=J(p,s,t)*p%t,h=J(J(J(J(J(J(m,c,t)*m%t,s,t)*p%t,n,t)*u%t,o,t)*f%t,r,t)*l%t,Xn,t);if(!Qn.eql(Qn.sqr(h),e))throw Error(`Cannot find square root`);return h}const Qn=on(qn.p,{sqrt:Zn}),$n=Hn(qn,{Fp:Qn,endo:Jn}),er=Kn($n,V),tr=Object.create(null);function nr(e,...t){let n=tr[e];if(n===void 0){let t=V(Tt(e));n=U(t,t),tr[e]=n}return V(U(n,...t))}const rr=e=>e.toBytes(!0).slice(1),ir=({x:e})=>Qn.toBytes(e),ar=e=>!Qn.isOdd(e);function or(e){let{Fn:t,BASE:n}=$n,r=t.fromBytes(H(e,32,`secretKey`)),i=n.multiply(r).toAffine();return{scalar:ar(i.y)?r:t.neg(r),bytes:ir(i)}}function sr(e){let t=Qn;if(!t.isValidNot0(e))throw Error(`invalid x: Fail if x ≥ p`);let n=t.sqr(e),r=t.add(t.mulN(n,e),BigInt(7)),i=t.sqrt(r);ar(i)||(i=t.neg(i));let a=$n.fromAffine({x:e,y:i});return a.assertValidity(),a}const cr=bt;function lr(...e){return $n.Fn.create(cr(nr(`BIP0340/challenge`,...e)))}function ur(e){return or(e).bytes}function dr(e,n,r=t.zr(32)){let{Fn:i,BASE:a}=$n,o=H(e,void 0,`message`),{bytes:s,scalar:c}=or(n),l=H(r,32,`auxRand`),u=nr(`BIP0340/nonce`,i.toBytes(c^cr(nr(`BIP0340/aux`,l))),s,o),d=i.create(cr(u));if(d===Yn)throw Error(`sign failed: k is zero`);let f=a.multiply(d).toAffine(),p=ar(f.y)?d:i.neg(d),m=ir(f),h=lr(m,s,o),g=new Uint8Array(64);if(g.set(m,0),g.set(i.toBytes(i.create(p+h*c)),32),!fr(g,o,s))throw Error(`sign: Invalid signature produced`);return g}function fr(e,t,n){let{Fp:r,Fn:i,BASE:a}=$n,o=H(e,64,`signature`),s=H(t,void 0,`message`),c=H(n,32,`publicKey`);try{let e=sr(cr(c)),t=o.subarray(0,32),n=cr(t);if(!r.isValidNot0(n))return!1;let l=cr(o.subarray(32,64));if(!i.isValidNot0(l))return!1;let u=lr(t,rr(e),s),d=a.mulAddUnsafe(l,e,i.neg(u)),{x:f,y:p}=d.toAffine();return!(d.is0()||!ar(p)||!r.eql(f,n))}catch{return!1}}const pr=(()=>{let e=e=>(e=e===void 0?t.zr(48):e,ln(H(e,48,`seed`),qn.n));return Object.freeze({keygen:jn(e,ur),getPublicKey:ur,sign:dr,verify:fr,Point:$n,utils:Object.freeze({randomSecretKey:e,taggedHash:nr,lift_x:sr,pointToBytes:rr}),lengths:Object.freeze({secretKey:32,publicKey:32,publicKeyHasPrefix:!1,signature:64,seed:48})})})(),mr=Uint8Array.from([7,4,13,1,10,6,15,3,12,0,9,5,2,14,11,8]),hr=Uint8Array.from(Array(16).fill(0).map((e,t)=>t)),gr=hr.map(e=>(9*e+5)%16),_r=(()=>{let e=[[hr],[gr]];for(let t=0;t<4;t++)for(let n of e)n.push(n[t].map(e=>mr[e]));return e})(),vr=_r[0],yr=_r[1],br=[[11,14,15,12,5,8,7,9,11,13,14,15,6,7,9,8],[12,13,11,15,6,9,9,7,12,15,11,13,7,8,7,7],[13,15,14,11,7,7,6,8,13,14,13,12,5,5,6,9],[14,11,12,14,8,6,5,5,15,12,15,14,9,9,8,6],[15,12,13,13,9,5,8,6,14,11,12,11,8,6,5,5]].map(e=>Uint8Array.from(e)),xr=vr.map((e,t)=>e.map(e=>br[t][e])),Sr=yr.map((e,t)=>e.map(e=>br[t][e])),Cr=Uint32Array.from([0,1518500249,1859775393,2400959708,2840853838]),wr=Uint32Array.from([1352829926,1548603684,1836072691,2053994217,0]);function Tr(e,t,n,r){return e===0?t^n^r:e===1?t&n|~t&r:e===2?(t|~n)^r:e===3?t&r|n&~r:t^(n|~r)}const Er=new Uint32Array(16);var Dr=class extends c{h0=1732584193;h1=-271733879;h2=-1732584194;h3=271733878;h4=-1009589776;constructor(){super(64,20,8,!0)}get(){let{h0:e,h1:t,h2:n,h3:r,h4:i}=this;return[e,t,n,r,i]}set(e,t,n,r,i){this.h0=e|0,this.h1=t|0,this.h2=n|0,this.h3=r|0,this.h4=i|0}_cloneInto(e){return(e||=new this.constructor).set(...this.get()),this._cloneIntoMeta(e)}process(e,n){for(let t=0;t<16;t++,n+=4)Er[t]=e.getUint32(n,!0);let r=this.h0|0,i=r,a=this.h1|0,o=a,s=this.h2|0,c=s,l=this.h3|0,u=l,d=this.h4|0,f=d;for(let e=0;e<5;e++){let n=4-e,p=Cr[e],m=wr[e],h=vr[e],g=yr[e],_=xr[e],v=Sr[e];for(let n=0;n<16;n++){let i=t.Br(r+Tr(e,a,s,l)+Er[h[n]]+p,_[n])+d|0;r=d,d=l,l=t.Br(s,10)|0,s=a,a=i}for(let e=0;e<16;e++){let r=t.Br(i+Tr(n,o,c,u)+Er[g[e]]+m,v[e])+f|0;i=f,f=u,u=t.Br(c,10)|0,c=o,o=r}}this.set(this.h1+s+u|0,this.h2+l+f|0,this.h3+d+i|0,this.h4+r+o|0,this.h0+a+c|0)}roundClean(){t.jr(Er)}destroy(){this.destroyed=!0,t.jr(this.buffer),this.set(0,0,0,0,0)}};const Or=t.Nr(()=>new Dr);
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function kr(e){return e instanceof Uint8Array||ArrayBuffer.isView(e)&&e.constructor.name===`Uint8Array`}function Ar(e,...t){if(!kr(e))throw Error(`Uint8Array expected`);if(t.length>0&&!t.includes(e.length))throw Error(`Uint8Array expected of length `+t+`, got length=`+e.length)}function jr(e,t=!0){if(e.destroyed)throw Error(`Hash instance has been destroyed`);if(t&&e.finished)throw Error(`Hash#digest() has already been called`)}function Mr(e,t){Ar(e);let n=t.outputLen;if(e.length<n)throw Error(`digestInto() expects output buffer of length at least `+n)}function Nr(...e){for(let t=0;t<e.length;t++)e[t].fill(0)}function Pr(e){return new DataView(e.buffer,e.byteOffset,e.byteLength)}function Z(e,t){return e<<32-t|e>>>t}function Fr(e){if(typeof e!=`string`)throw Error(`string expected`);return new Uint8Array(new TextEncoder().encode(e))}function Ir(e){return typeof e==`string`&&(e=Fr(e)),Ar(e),e}var Lr=class{};function Rr(e){let t=t=>e().update(Ir(t)).digest(),n=e();return t.outputLen=n.outputLen,t.blockLen=n.blockLen,t.create=()=>e(),t}function zr(e,t,n,r){if(typeof e.setBigUint64==`function`)return e.setBigUint64(t,n,r);let i=BigInt(32),a=BigInt(4294967295),o=Number(n>>i&a),s=Number(n&a),c=r?4:0,l=r?0:4;e.setUint32(t+c,o,r),e.setUint32(t+l,s,r)}function Br(e,t,n){return e&t^~e&n}function Vr(e,t,n){return e&t^e&n^t&n}var Hr=class extends Lr{constructor(e,t,n,r){super(),this.finished=!1,this.length=0,this.pos=0,this.destroyed=!1,this.blockLen=e,this.outputLen=t,this.padOffset=n,this.isLE=r,this.buffer=new Uint8Array(e),this.view=Pr(this.buffer)}update(e){jr(this),e=Ir(e),Ar(e);let{view:t,buffer:n,blockLen:r}=this,i=e.length;for(let a=0;a<i;){let o=Math.min(r-this.pos,i-a);if(o===r){let t=Pr(e);for(;r<=i-a;a+=r)this.process(t,a);continue}n.set(e.subarray(a,a+o),this.pos),this.pos+=o,a+=o,this.pos===r&&(this.process(t,0),this.pos=0)}return this.length+=e.length,this.roundClean(),this}digestInto(e){jr(this),Mr(e,this),this.finished=!0;let{buffer:t,view:n,blockLen:r,isLE:i}=this,{pos:a}=this;t[a++]=128,Nr(this.buffer.subarray(a)),this.padOffset>r-a&&(this.process(n,0),a=0);for(let e=a;e<r;e++)t[e]=0;zr(n,r-8,BigInt(this.length*8),i),this.process(n,0);let o=Pr(e),s=this.outputLen;if(s%4)throw Error(`_sha2: outputLen should be aligned to 32bit`);let c=s/4,l=this.get();if(c>l.length)throw Error(`_sha2: outputLen bigger than state`);for(let e=0;e<c;e++)o.setUint32(4*e,l[e],i)}digest(){let{buffer:e,outputLen:t}=this;this.digestInto(e);let n=e.slice(0,t);return this.destroy(),n}_cloneInto(e){e||=new this.constructor,e.set(...this.get());let{blockLen:t,buffer:n,length:r,finished:i,destroyed:a,pos:o}=this;return e.destroyed=a,e.finished=i,e.length=r,e.pos=o,r%t&&e.buffer.set(n),e}clone(){return this._cloneInto()}};const Ur=Uint32Array.from([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),Wr=Uint32Array.from([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),Gr=new Uint32Array(64);var Kr=class extends Hr{constructor(e=32){super(64,e,8,!1),this.A=Ur[0]|0,this.B=Ur[1]|0,this.C=Ur[2]|0,this.D=Ur[3]|0,this.E=Ur[4]|0,this.F=Ur[5]|0,this.G=Ur[6]|0,this.H=Ur[7]|0}get(){let{A:e,B:t,C:n,D:r,E:i,F:a,G:o,H:s}=this;return[e,t,n,r,i,a,o,s]}set(e,t,n,r,i,a,o,s){this.A=e|0,this.B=t|0,this.C=n|0,this.D=r|0,this.E=i|0,this.F=a|0,this.G=o|0,this.H=s|0}process(e,t){for(let n=0;n<16;n++,t+=4)Gr[n]=e.getUint32(t,!1);for(let e=16;e<64;e++){let t=Gr[e-15],n=Gr[e-2],r=Z(t,7)^Z(t,18)^t>>>3,i=Z(n,17)^Z(n,19)^n>>>10;Gr[e]=i+Gr[e-7]+r+Gr[e-16]|0}let{A:n,B:r,C:i,D:a,E:o,F:s,G:c,H:l}=this;for(let e=0;e<64;e++){let t=Z(o,6)^Z(o,11)^Z(o,25),u=l+t+Br(o,s,c)+Wr[e]+Gr[e]|0,d=(Z(n,2)^Z(n,13)^Z(n,22))+Vr(n,r,i)|0;l=c,c=s,s=o,o=a+u|0,a=i,i=r,r=n,n=u+d|0}n=n+this.A|0,r=r+this.B|0,i=i+this.C|0,a=a+this.D|0,o=o+this.E|0,s=s+this.F|0,c=c+this.G|0,l=l+this.H|0,this.set(n,r,i,a,o,s,c,l)}roundClean(){Nr(Gr)}destroy(){this.set(0,0,0,0,0,0,0,0),Nr(this.buffer)}};const qr=Rr(()=>new Kr);function Jr(e){if(e.length>=255)throw TypeError(`Alphabet too long`);let t=new Uint8Array(256);for(let e=0;e<t.length;e++)t[e]=255;for(let n=0;n<e.length;n++){let r=e.charAt(n),i=r.charCodeAt(0);if(t[i]!==255)throw TypeError(r+` is ambiguous`);t[i]=n}let n=e.length,r=e.charAt(0),i=Math.log(n)/Math.log(256),a=Math.log(256)/Math.log(n);function o(t){if(t instanceof Uint8Array||(ArrayBuffer.isView(t)?t=new Uint8Array(t.buffer,t.byteOffset,t.byteLength):Array.isArray(t)&&(t=Uint8Array.from(t))),!(t instanceof Uint8Array))throw TypeError(`Expected Uint8Array`);if(t.length===0)return``;let i=0,o=0,s=0,c=t.length;for(;s!==c&&t[s]===0;)s++,i++;let l=(c-s)*a+1>>>0,u=new Uint8Array(l);for(;s!==c;){let e=t[s],r=0;for(let t=l-1;(e!==0||r<o)&&t!==-1;t--,r++)e+=256*u[t]>>>0,u[t]=e%n>>>0,e=e/n>>>0;if(e!==0)throw Error(`Non-zero carry`);o=r,s++}let d=l-o;for(;d!==l&&u[d]===0;)d++;let f=r.repeat(i);for(;d<l;++d)f+=e.charAt(u[d]);return f}function s(e){if(typeof e!=`string`)throw TypeError(`Expected String`);if(e.length===0)return new Uint8Array;let a=0,o=0,s=0;for(;e[a]===r;)o++,a++;let c=(e.length-a)*i+1>>>0,l=new Uint8Array(c);for(;a<e.length;){let r=e.charCodeAt(a);if(r>255)return;let i=t[r];if(i===255)return;let o=0;for(let e=c-1;(i!==0||o<s)&&e!==-1;e--,o++)i+=n*l[e]>>>0,l[e]=i%256>>>0,i=i/256>>>0;if(i!==0)throw Error(`Non-zero carry`);s=o,a++}let u=c-s;for(;u!==c&&l[u]===0;)u++;let d=new Uint8Array(o+(c-u)),f=o;for(;u!==c;)d[f++]=l[u++];return d}function c(e){let t=s(e);if(t)return t;throw Error(`Non-base`+n+` character`)}return{encode:o,decodeUnsafe:s,decode:c}}var Yr=Jr(`123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`);function Xr(e){function t(t){var n=Uint8Array.from(t),r=e(n),i=n.length+4,a=new Uint8Array(i);return a.set(n,0),a.set(r.subarray(0,4),n.length),Yr.encode(a)}function n(t){var n=t.slice(0,-4),r=t.slice(-4),i=e(n);if(!(r[0]^i[0]|r[1]^i[1]|r[2]^i[2]|r[3]^i[3]))return n}function r(e){var t=Yr.decodeUnsafe(e);if(t!=null)return n(t)}function i(e){var t=n(Yr.decode(e));if(t==null)throw Error(`Invalid checksum`);return t}return{encode:t,decode:i,decodeUnsafe:r}}function Zr(e){return qr(qr(e))}var Qr=Xr(Zr);function $r(e){let n=t.Zn(e);return n<253?t.er(n,1):n<=65535?t.Kr([253],t.er(n,2)):n<=4294967295?t.Kr([254],t.er(n,4)):t.Kr([255],t.er(n,8))}function ei(e,n){let r=n??`Bitcoin Signed Message:
+`,i=typeof r==`string`?t.Yr(r,`utf8`):t.Yr(r),a=typeof e==`string`?t.Yr(e,`utf8`):t.Yr(e);return V(V(t.Kr(i,$r(a.length),a)))}function ti(e){return Or(V(t.Yr(e)))}function ni(e,n){return Qr.encode(t.Kr([n],ti(e)))}function ri(e){return t.yr(Qr.decode(e).slice(1))}function ii(e,n,r){let i=typeof e==`string`?e:t.yr(e).slice(2),a=t.Yr(n,`base64`).slice(1);return er.verify(t.Yr(a),ei(i),t.Yr(r),{prehash:!1})}function ai(e,n){let r=er.sign(t.Yr(e),t.Yr(n),{format:`recovered`,prehash:!1});return t.yr(t.Kr(r.slice(1),r.slice(0,1)))}function oi(e,n,r){let i=t.Yr(n);return er.verify(t.Kr(i.slice(64),i.slice(0,64)),t.Yr(e),t.Yr(r),{format:`recovered`,prehash:!1})}function si(e,n){let r=t.Yr(n);return t.yr(er.recoverPublicKey(t.Kr(r.slice(64),r.slice(0,64)),t.Yr(e),{prehash:!1}))}function ci(e){return t.mr(t.Yr(`Nervos Message:${typeof e==`string`?e:t.yr(e)}`,`utf8`))}function li(e,t,n){return oi(ci(e),t,n)}function ui(e,n,r){let a=typeof e==`string`?e:t.yr(e).slice(2),{publicKey:o,keyType:s}=JSON.parse(r);return(0,i.verifySignature)({challenge:a,pubkey:o,keyType:s,...JSON.parse(n)})}function di(e,t){return ei(e,t??`Dogecoin Signed Message:
+`)}function fi(e,n,r){let i=typeof e==`string`?e:t.yr(e).slice(2),a=t.Yr(n,`base64`);return a[0]-=31,ri(r)===t.yr(ti(er.recoverPublicKey(a,di(i),{prehash:!1})))}function pi(e,n,r){return r.toLowerCase()===(0,a.verifyMessage)(typeof e==`string`?e:t.Yr(e),n).toLowerCase()}function mi(e){if(typeof e==`string`)try{let t=JSON.parse(e);if(typeof t==`object`&&typeof t.created_at==`number`&&typeof t.kind==`number`&&typeof t.content==`string`&&Array.isArray(t.tags)&&t.tags.every(e=>Array.isArray(e)&&e.every(e=>typeof e==`string`)))return t}catch{}return{kind:23335,created_at:0,content:typeof e==`string`?e:t.yr(e),tags:[]}}function hi(e){return V(t.Yr(JSON.stringify([0,e.pubkey,e.created_at,e.kind,e.tags,e.content]),`utf8`))}function gi(e,r,i){let{words:a}=n.bech32.decode(i),o=t.yr(n.bech32.fromWords(a)).slice(2),s=hi({...mi(e),pubkey:o});try{return pr.verify(t.Yr(r),s,t.Yr(o))}catch{return!1}}let _i=function(e){return e.Unknown=`Unknown`,e.BtcEcdsa=`BtcEcdsa`,e.EvmPersonal=`EvmPersonal`,e.JoyId=`JoyId`,e.NostrEvent=`NostrEvent`,e.CkbSecp256k1=`CkbSecp256k1`,e.DogeEcdsa=`DogeEcdsa`,e}({}),vi=function(e){return e.EVM=`EVM`,e.BTC=`BTC`,e.CKB=`CKB`,e.Nostr=`Nostr`,e.Doge=`Doge`,e}({});var yi=class{constructor(e,t,n){this.signature=e,this.identity=t,this.signType=n}},Q=class e{constructor(e){this.client_=e}get client(){return this.client_}matchNetworkPreference(e,t){if(!(t!==void 0&&e.some(({signerType:e,addressPrefix:n,network:r})=>e===this.type&&n===this.client.addressPrefix&&r===t)))return e.find(({signerType:e,addressPrefix:t})=>e===this.type&&t===this.client.addressPrefix)}static async verifyMessage(e,t){switch(t.signType){case`EvmPersonal`:return pi(e,t.signature,t.identity);case`BtcEcdsa`:return ii(e,t.signature,t.identity);case`JoyId`:return ui(e,t.signature,t.identity);case`NostrEvent`:return gi(e,t.signature,t.identity);case`CkbSecp256k1`:return li(e,t.signature,t.identity);case`DogeEcdsa`:return fi(e,t.signature,t.identity);case`Unknown`:throw Error(`Unknown signer sign type`)}}onReplaced(e){return()=>{}}async disconnect(){}async getIdentity(){return this.getInternalAddress()}async getRecommendedAddressObj(e){return(await this.getAddressObjs())[0]}async getRecommendedAddress(e){return(await this.getRecommendedAddressObj(e)).toString()}async getAddresses(){return this.getAddressObjs().then(e=>e.map(e=>e.toString()))}async*findCellsOnChain(e,t,n,r){let i=await this.getAddressObjs();for(let{script:a}of i)for await(let i of this.client.findCellsOnChain({script:a,scriptType:`lock`,filter:e,scriptSearchMode:`exact`,withData:t},n,r))yield i}async*findCells(e,t,n,r){let i=await this.getAddressObjs();for(let{script:a}of i)for await(let i of this.client.findCells({script:a,scriptType:`lock`,filter:e,scriptSearchMode:`exact`,withData:t},n,r))yield i}async*findTransactions(e,t,n,r){let i=await this.getAddressObjs();for(let{script:a}of i)for await(let i of this.client.findTransactions({script:a,scriptType:`lock`,filter:e,scriptSearchMode:`exact`,groupByTransaction:t},n,r))yield i}async getBalance(){return this.client.getBalance((await this.getAddressObjs()).map(({script:e})=>e))}async signMessage(e){return{signature:await this.signMessageRaw(e),identity:await this.getIdentity(),signType:this.signType}}signMessageRaw(e){throw Error(`Signer.signMessageRaw not implemented`)}async verifyMessage(t,n){return typeof n==`string`?e.verifyMessage(t,{signType:this.signType,signature:n,identity:await this.getIdentity()}):n.identity!==await this.getIdentity()||![`Unknown`,this.signType].includes(n.signType)?!1:e.verifyMessage(t,n)}async sendTransaction(e){return this.client.sendTransaction(await this.signTransaction(e))}async signTransaction(e){let t=await this.prepareTransaction(e);return this.signOnlyTransaction(t)}async prepareTransaction(e){return t._.from(e)}signOnlyTransaction(e){throw Error(`Signer.signOnlyTransaction not implemented`)}},bi=class extends Q{async sendTransaction(e){let t=await this.signTransaction(e);if(await this.needMoreSignatures(t))throw new xi(await this.getSignaturesCount(t)??0,await this.getMemberThreshold());return this.client.sendTransaction(t)}},xi=class extends Error{constructor(e,t){let n=`Not enough signatures: got ${e}, need ${t}`;super(n),this.name=`SignerMultisigNotEnoughSignaturesError`,this.signaturesCount=e,this.threshold=t}},Si=class{constructor(e,t){this.name=e,this.signer=t}},Ci=class extends Q{get type(){return`BTC`}get signType(){return`BtcEcdsa`}async signAndBroadcastPsbt(e,t){let n=await this.signPsbt(e,t);return this.broadcastPsbt(n,t)}async getInternalAddress(){return this.getBtcAccount()}async getIdentity(){return t.yr(await this.getBtcPublicKey()).slice(2)}async getAddressObjs(){let e=ti(await this.getBtcPublicKey());return[await L.fromKnownScript(this.client,`OmniLock`,t.yr([4,...e,0]))]}async prepareTransaction(e){let n=t._.from(e),{script:r}=await this.getRecommendedAddressObj();return await n.addCellDepsOfKnownScripts(this.client,`OmniLock`),await n.prepareSighashAllWitness(r,85,this.client),n}async signOnlyTransaction(e){let n=t._.from(e),{script:r}=await this.getRecommendedAddressObj(),i=await n.getSignHashInfo(r,this.client);if(!i)return n;let a=t.Yr(await this.signMessageRaw(`CKB (Bitcoin Layer) transaction: ${i.message}`),`base64`);a[0]=31+(a[0]-27)%4;let o=t.v.fromBytes(n.witnesses[i.position]);return o.lock=t.yr(t.Kr(t.rr(20+a.length,4),t.rr(16,4),t.rr(20+a.length,4),t.rr(20+a.length,4),t.rr(a.length,4),a)),n.setWitnessArgs(i.position,o),n}},wi=class extends Ci{constructor(e,n,r){super(e),this.account=n,this.publicKey=t.yr(r)}async connect(){}async isConnected(){return!0}async getBtcAccount(){return this.account}async getBtcPublicKey(){return this.publicKey}async signPsbt(e,t){throw Error(`Read-only signer does not support signPsbt`)}async broadcastPsbt(e,t){throw Error(`Read-only signer does not support broadcastPsbt`)}},Ti=class extends Q{get type(){return`CKB`}get signType(){return`Unknown`}constructor(e){super(e)}async connect(){}async isConnected(){return!0}async getInternalAddress(){return this.getRecommendedAddress()}async getAddressObjs(){return[await L.fromKnownScript(this.client,`AlwaysSuccess`,`0x`)]}async prepareTransaction(e){let n=t._.from(e);return await n.addCellDepsOfKnownScripts(this.client,`AlwaysSuccess`),n}async signOnlyTransaction(e){return t._.from(e)}},Ei=class extends Q{get type(){return`CKB`}get signType(){return`CkbSecp256k1`}constructor(e,n){if(super(e),this.publicKey=t.yr(n),t.Yr(this.publicKey).length!==33)throw Error(`Public key must be 33 bytes!`)}async connect(){}async isConnected(){return!0}async getInternalAddress(){return this.getRecommendedAddress()}async getIdentity(){return this.publicKey}async getAddressObjSecp256k1(){return L.fromKnownScript(this.client,`Secp256k1Blake160`,t.hr(this.publicKey))}async getRecommendedAddressObj(e){return this.getAddressObjSecp256k1()}async getAddressObjs(){let e=await this.getAddressObjSecp256k1(),n=[],r=0;for await(let i of this.client.findCells({script:await t.M.fromKnownScript(this.client,`AnyoneCanPay`,e.script.args),scriptType:`lock`,scriptSearchMode:`prefix`,withData:!1})){if(r>=10)break;r+=1,!n.some(({script:e})=>e.eq(i.cellOutput.lock))&&n.push(L.from({prefix:this.client.addressPrefix,script:i.cellOutput.lock}))}return[e,...n]}async getRelatedScripts(e){let n=t._.from(e),r=await this.getAddressObjSecp256k1(),i=await t.M.fromKnownScript(this.client,`AnyoneCanPay`,r.script.args),a=[];for(let e of n.inputs){let{cellOutput:{lock:t}}=await e.getCell(this.client);a.some(({script:e})=>e.eq(t))||(t.eq(r.script)?a.push({script:t,cellDeps:(await this.client.getKnownScript(`Secp256k1Blake160`)).cellDeps}):t.codeHash===i.codeHash&&t.hashType===i.hashType&&t.args.startsWith(i.args)&&a.push({script:t,cellDeps:(await this.client.getKnownScript(`AnyoneCanPay`)).cellDeps}))}return a}async prepareTransaction(e){let n=t._.from(e);return await Promise.all((await this.getRelatedScripts(n)).map(async({script:e,cellDeps:t})=>{await n.prepareSighashAllWitness(e,65,this.client),await n.addCellDepInfos(this.client,t)})),n}},Di=class extends Ei{constructor(e,n){let r=t.yr(n);if(t.Yr(r).length!==32)throw Error(`Private key must be 32 bytes!`);super(e,er.getPublicKey(t.Yr(r),!0)),this.privateKey=r}async _signMessage(e){return ai(e,this.privateKey)}async signMessageRaw(e){return this._signMessage(ci(e))}async signOnlyTransaction(e){let n=t._.from(e);for(let{script:e}of await this.getRelatedScripts(n)){let r=await n.getSignHashInfo(e,this.client);if(!r)return n;let i=await this._signMessage(r.message),a=n.getWitnessArgs(r.position)??t.v.from({});a.lock=i,n.setWitnessArgs(r.position,a)}return n}},Oi=class extends Q{get type(){return`CKB`}get signType(){return`Unknown`}constructor(e,...n){if(super(e),this.scripts=n.flat().map(t.M.from),this.scripts.length===0)throw Error(`SignerCkbScriptReadonly requires at least one script.`)}async connect(){}async isConnected(){return!0}async getInternalAddress(){return this.getRecommendedAddress()}async getAddressObjs(){return this.scripts.map(e=>L.fromScript(e,this.client))}},ki;let $=ki=class extends t.lr.Base(){constructor(e,t,n,r){super(),this.publicKeyHashes=e,this.threshold=t,this.mustMatch=n,this.signatures=r;let i=e.length;if(t<=0||t>i)throw Error(`threshold should be in range from 1 to public keys length`);if(n<0||n>Math.min(i,t))throw Error(`mustMatch should be in range from 0 to min(public keys length, threshold)`);if(i>255)throw Error(`public keys length should be less than 256`)}static from(e){let n=e.publicKeyHashes?e.publicKeyHashes:e.publicKeys.map(e=>t.hr(e));return new ki(n.map(t.yr),Number(t.Zn(e.threshold)),Number(t.Zn(e.mustMatch??0)),e.signatures?.map(t.yr)??[])}get flexibleThreshold(){return this.threshold-this.mustMatch}scriptArgs(e){let n=t.hr(ki.from({...this,signatures:[]}).toBytes());return e==null?t.Yr(n):t.Kr(n,t.g.from(e).toBytes())}eqInfo(e){let t=ki.from(e);return this.publicKeyHashes.length===t.publicKeyHashes.length&&this.publicKeyHashes.every((e,n)=>e===t.publicKeyHashes[n])&&this.threshold===t.threshold&&this.mustMatch===t.mustMatch}*generatePublicKeyHashesFromSignatures(e){let n=new Set;for(let r of this.signatures.filter(e=>e!==Ai.EmptySignature)){let i=(()=>{try{return si(e,r)}catch{return}})();if(i===void 0)continue;let a=t.hr(i);if(n.has(a))continue;let o=this.publicKeyHashes.indexOf(a);o!==-1&&(n.add(a),yield{pubkeyHash:a,signature:r,isRequired:o<this.mustMatch})}}calcMatchedSignaturesCount(e){let t=0,n=0;for(let{isRequired:r}of this.generatePublicKeyHashesFromSignatures(e))r?t+=1:n+=1;return{required:t,flexible:n}}};$=ki=t.Tt([t.ur({encode:e=>{let{publicKeyHashes:n,threshold:r,mustMatch:i,signatures:a}=$.from(e);if(a.some(e=>e.length!==132))throw Error(`MultisigCkbWitness: invalid signature length`);if(n.some(e=>e.length!==42))throw Error(`MultisigCkbWitness: invalid public key hash length`);return t.Kr(`0x00`,t.rr(i??0),t.rr(r),t.rr(n.length),...n,...a)},decode:e=>{if(e.length<4)throw Error(`MultisigCkbWitness: data length too short`);let[n,r,i,a,...o]=e;if(o.length<a*20)throw Error(`MultisigCkbWitness: invalid public key hashes length`);let s=o.slice(a*20);return $.from({publicKeyHashes:Array.from(Array(a),(e,n)=>t.yr(o.slice(n*20,(n+1)*20))),threshold:t.Zn(i),mustMatch:t.Zn(r),signatures:Array.from(Array(Math.floor(s.length/65)),(e,n)=>t.yr(s.slice(n*65,(n+1)*65)))})}})],$);var Ai=class e extends bi{static{this.EmptySignature=t.yr(`00`.repeat(65))}get type(){return`CKB`}get signType(){return`Unknown`}constructor(e,n,r){super(e),this.multisigInfo=$.from(n),this.since=t.Et(t.g.from,r?.since);let i=this.multisigInfo.scriptArgs(this.since);this.scriptInfos=Promise.all((r?.scriptInfos??[`Secp256k1MultisigV2`,`Secp256k1MultisigV2Beta`,`Secp256k1Multisig`]).map(async n=>{if(typeof n!=`string`)return t._t.from(n);try{return await e.getKnownScript(n)}catch{return}})).then(e=>e.filter(e=>e!==void 0).map(e=>({script:t.M.from({...e,args:i}),cellDeps:e.cellDeps})))}async getMemberCount(){return this.multisigInfo.publicKeyHashes.length}async getMemberThreshold(){return this.multisigInfo.threshold}async getMemberRequiredCount(){return this.multisigInfo.mustMatch}async connect(){}async isConnected(){return!0}async getInternalAddress(){return this.getRecommendedAddress()}async getAddressObjs(){return(await this.scriptInfos).map(({script:e})=>L.fromScript(e,this.client))}decodeWitnessArgsAt(e,n){let r=t._.from(e);return this.decodeWitnessArgs(r.getWitnessArgs(n))}decodeWitnessArgs(e){if(!e)return;let n=t.v.from(e);if(n.lock!=null)try{let e=$.decode(n.lock);if(e.eqInfo(this.multisigInfo))return e}catch{}}async prepareWitnessArgsAt(n,r,i){let a=t._.from(n),o=a.getWitnessArgs(r)??t.v.from({}),s=this.decodeWitnessArgs(o)??this.multisigInfo.clone(),c=$.from(await i?.(s,o)??s);return c.signatures=c.signatures.slice(0,this.multisigInfo.threshold),c.signatures.push(...Array.from(Array(this.multisigInfo.threshold-c.signatures.length),()=>e.EmptySignature)),o.lock=c.toHex(),a.setWitnessArgs(r,o),a}async prepareTransactionOneScript(e,n,r){let i=t._.from(e),a=await i.findInputIndexByLock(n,this.client);return a===void 0?i:(await i.addCellDepInfos(this.client,r),this.prepareWitnessArgsAt(i,a))}async prepareTransaction(e){return await t.kt(await this.scriptInfos,(e,{script:t,cellDeps:n})=>this.prepareTransactionOneScript(e,t,n),t._.from(e))}async getSignaturesCount(e){let n=t._.from(e),r;for(let{script:e}of await this.scriptInfos){let t=await this.getSignInfo(n,e);if(t===void 0)continue;let i=this.decodeWitnessArgsAt(n,t.position);if(!i){r=0;continue}let{required:a,flexible:o}=i.calcMatchedSignaturesCount(t.message);r=Math.min(r??256,a+Math.min(o,this.multisigInfo.flexibleThreshold))}return r}async needMoreSignatures(e){let t=await this.getSignaturesCount(e);return t!=null&&t<await this.getMemberThreshold()}async getSignInfo(n,r){let i=t._.from(n),a=await i.findInputIndexByLock(r,this.client);if(a==null)return;let o=i.getWitnessArgs(a)??t.v.from({});o.lock=$.from({...this.multisigInfo,signatures:Array.from(Array(this.multisigInfo.threshold),()=>e.EmptySignature)}).toHex();let s=i.clone();return s.setWitnessArgs(a,o),s.getSignHashInfo(r,this.client)}async aggregateTransactions(e){if(e.length===0)throw Error(`No transaction to aggregate`);let n=t._.from(e[0]);for(let{script:r}of await this.scriptInfos){let i=await this.getSignInfo(n,r);if(i===void 0)continue;let a=new Map,o=0;for(let n of e){let e=t._.from(n),r=this.decodeWitnessArgsAt(e,i.position);if(r){for(let{pubkeyHash:e,signature:t,isRequired:n}of r.generatePublicKeyHashesFromSignatures(i.message))if(!a.has(e)){if(n)o+=1;else if(a.size-o>=this.multisigInfo.flexibleThreshold)continue;if(a.set(e,t),a.size>=this.multisigInfo.threshold)break}if(a.size>=this.multisigInfo.threshold)break}}n=await this.prepareWitnessArgsAt(n,i.position,e=>{e.signatures=Array.from(a.values())})}return n}},ji=class extends Ai{constructor(e,n,r,i){super(e,r,i),this.privateKey=t.yr(n),this.signer=new Di(e,this.privateKey)}async signOnlyTransaction(e){let n=t._.from(e),r=t.hr(this.signer.publicKey),i=this.multisigInfo.publicKeyHashes.indexOf(r);if(i===-1)return n;let a=i<this.multisigInfo.mustMatch;for(let{script:e}of await this.scriptInfos){let t=await this.getSignInfo(n,e);t&&(n=await this.prepareWitnessArgsAt(n,t.position,async e=>{let n=[],i=0,o=!0;for(let{pubkeyHash:a,signature:s,isRequired:c}of e.generatePublicKeyHashesFromSignatures(t.message)){if(a===r){if(!o)continue;o=!1}if(c)i+=1;else if(n.length-i>=this.multisigInfo.flexibleThreshold)continue;if(n.push(s),n.length>=this.multisigInfo.threshold){o=!1;break}}return o&&(a||n.length-i<this.multisigInfo.flexibleThreshold)&&n.push(ai(t.message,this.privateKey)),e.signatures=n,e}))}return n}},Mi=class extends Q{get type(){return`Doge`}get signType(){return`DogeEcdsa`}async getInternalAddress(){return this.getDogeAddress()}async getIdentity(){return this.getDogeAddress()}async getAddressObjs(){let e=Qr.decode(await this.getDogeAddress()).slice(1);return[await L.fromKnownScript(this.client,`OmniLock`,t.yr([5,...e,0]))]}async prepareTransaction(e){let n=t._.from(e),{script:r}=await this.getRecommendedAddressObj();return await n.addCellDepsOfKnownScripts(this.client,`OmniLock`),await n.prepareSighashAllWitness(r,85,this.client),n}async signOnlyTransaction(e){let n=t._.from(e),{script:r}=await this.getRecommendedAddressObj(),i=await n.getSignHashInfo(r,this.client);if(!i)return n;let a=t.Yr(await this.signMessageRaw(i.message.slice(2)),`base64`);a[0]=31+(a[0]-27)%4;let o=t.v.fromBytes(n.witnesses[i.position]);return o.lock=t.yr(t.Kr(t.rr(20+a.length,4),t.rr(16,4),t.rr(20+a.length,4),t.rr(20+a.length,4),t.rr(a.length,4),a)),n.setWitnessArgs(i.position,o),n}},Ni=class extends Mi{constructor(e,t){super(e),this.address=t}async connect(){}async isConnected(){return!0}async getDogeAddress(){return this.address}},Pi=class extends Mi{constructor(e,n,r=30){if(super(e),this.dogeNetwork=r,this.privateKey=t.Yr(n),this.privateKey.length!==32)throw Error(`Private key must be 32 bytes!`)}async connect(){}async isConnected(){return!0}async getDogePublicKey(){return t.yr(er.getPublicKey(this.privateKey,!0))}async getDogeAddress(){return ni(await this.getDogePublicKey(),this.dogeNetwork)}async signMessageRaw(e){let n=typeof e==`string`?e:t.yr(e).slice(2),r=er.sign(di(n),this.privateKey,{format:`recovered`,prehash:!1});return t.Xr(t.Kr([31+Number(r[0])],r.slice(1)),`base64`)}},Fi=class extends Q{get signType(){return`Unknown`}constructor(e,t){super(e),this.type=t}async isConnected(){return!1}async getInternalAddress(){throw Error(`Can't get address from SignerDummy`)}async getAddressObjs(){throw Error(`Can't get addresses from SignerDummy`)}},Ii=class extends Fi{constructor(e,t,n){super(e,t),this.message=n}async connect(){throw Error(this.message)}},Li=class extends Fi{constructor(e,t,n){super(e,t),this.link=n}async connect(){window.open(this.link,`_blank`)?.focus()}},Ri=class extends Q{get type(){return`EVM`}get signType(){return`EvmPersonal`}async getInternalAddress(){return this.getEvmAccount()}async getAddressObjs(){let e=await this.getEvmAccount();return(await Promise.all([this._getOmniLockAddresses(e),this._getPWLockAddresses(e)])).flat()}_getOmniLockAddresses(e){return Promise.all([this._getOmniLockEvmAddressObj(e),this._getOmniLockOldEvmAddressObj(e)])}async _getPWLockAddresses(e){let t=await this._getPWLockEvmAddressObj(e);return t?[t]:[]}async _getOmniLockEvmAddressObj(e){return L.fromKnownScript(this.client,`OmniLock`,t.yr([18,...t.Yr(e),0]))}async _getOmniLockOldEvmAddressObj(e){return L.fromKnownScript(this.client,`OmniLock`,t.yr([1,...t.Yr(e),0]))}async _getPWLockEvmAddressObj(e){try{return L.fromKnownScript(this.client,`PWLock`,t.yr(t.Yr(e)))}catch{}}async prepareTransaction(e){let n=t._.from(e);await n.findInputIndexByLockId(await this.client.getKnownScript(`OmniLock`),this.client)!==void 0&&await n.addCellDepsOfKnownScripts(this.client,`OmniLock`),await n.findInputIndexByLockId(await this.client.getKnownScript(`PWLock`),this.client)!==void 0&&await n.addCellDepsOfKnownScripts(this.client,`PWLock`);let r=await this.getEvmAccount(),i=await this._getOmniLockAddresses(r);return t.kt(await this._getPWLockAddresses(r),(e,{script:t})=>e.prepareSighashAllWitness(t,65,this.client),t.kt(i,(e,{script:t})=>e.prepareSighashAllWitness(t,85,this.client),n))}async signOnlyTransaction(e){let n=t._.from(e),r=await this.getEvmAccount(),{script:i}=await this._getOmniLockEvmAddressObj(r),{script:a}=await this._getOmniLockOldEvmAddressObj(r);n=await this._signOmniLockScriptForTransaction(n,i,e=>`CKB transaction: ${e}`),n=await this._signOmniLockScriptForTransaction(n,a,e=>t.Yr(e));let o=await this._getPWLockEvmAddressObj(r);return o&&(n=await this._signPWLockScriptForTransaction(n,o.script,e=>t.Yr(e))),n}async _signOmniLockScriptForTransaction(e,n,r){let i=await this._signPersonalEvmForTransaction(e,n,r);if(!i)return e;let a=t.v.fromBytes(e.witnesses[i.position]);return a.lock=t.yr(t.Kr(t.rr(20+i.signature.length,4),t.rr(16,4),t.rr(20+i.signature.length,4),t.rr(20+i.signature.length,4),t.rr(i.signature.length,4),i.signature)),e.setWitnessArgs(i.position,a),e}async _signPWLockScriptForTransaction(e,n,r){let i=await this._signPersonalEvmForTransaction(e,n,r,new A);if(!i)return e;let a=t.v.fromBytes(e.witnesses[i.position]);return a.lock=t.yr(i.signature),e.setWitnessArgs(i.position,a),e}async _signPersonalEvmForTransaction(e,n,r,i){let a=await e.getSignHashInfo(n,this.client,i);if(!a)return;let o=t.Yr(await this.signMessageRaw(r(a.message)));return o[o.length-1]>=27&&(o[o.length-1]-=27),{signature:o,position:a.position}}},zi=class extends Ri{constructor(e,n){super(e),this.address=t.yr(n)}async connect(){}async isConnected(){return!0}async getEvmAccount(){return this.address}},Bi=class e extends Q{static{this.CKB_SIG_HASH_ALL_TAG=`ckb_sighash_all`}static{this.CKB_UNLOCK_EVENT_KIND=23334}static{this.CKB_UNLOCK_EVENT_CONTENT=`Signing a CKB transaction
+
+IMPORTANT: Please verify the integrity and authenticity of connected Nostr client before signing this message
+`}get type(){return`Nostr`}get signType(){return`NostrEvent`}async signNostrEvent(e){throw Error(`SignerNostr.signNostrEvent not implemented`)}async signMessageRaw(e){return t.yr((await this.signNostrEvent(mi(e))).sig)}async getInternalAddress(){return n.bech32.encode(`npub`,n.bech32.toWords(t.Yr(await this.getNostrPublicKey())))}async getAddressObjs(){let e=await this.getNostrPublicKey();return[await L.fromKnownScript(this.client,`NostrLock`,t.yr(t.Kr([0],t.mr(e).slice(0,42))))]}async prepareTransaction(e){let n=t._.from(e),{script:r}=await this.getRecommendedAddressObj();return await n.addCellDepsOfKnownScripts(this.client,`NostrLock`),await n.prepareSighashAllWitness(r,572,this.client),n}async signOnlyTransaction(n){let r=t._.from(n),{script:i}=await this.getRecommendedAddressObj(),a=await r.getSignHashInfo(i,this.client);if(!a)return r;let o=t.Yr(JSON.stringify(await this.signNostrEvent({pubkey:(await this.getNostrPublicKey()).slice(2),tags:[[e.CKB_SIG_HASH_ALL_TAG,a.message.slice(2)]],created_at:Math.floor(Date.now()/1e3),kind:e.CKB_UNLOCK_EVENT_KIND,content:e.CKB_UNLOCK_EVENT_CONTENT})),`utf8`),s=t.v.fromBytes(r.witnesses[a.position]);return s.lock=t.yr(o),r.setWitnessArgs(a.position,s),r}},Vi=class extends Bi{constructor(e,r){if(super(e),typeof r==`string`&&r.startsWith(`npub`)){let{words:e}=n.bech32.decode(r);this.publicKey=t.yr(n.bech32.fromWords(e))}else this.publicKey=t.yr(r)}async connect(){}async isConnected(){return!0}async getNostrPublicKey(){return this.publicKey}},Hi=class extends Vi{constructor(e,r){let i=(()=>{if(typeof r==`string`&&r.startsWith(`nsec`)){let{words:e}=n.bech32.decode(r);return t.Yr(n.bech32.fromWords(e))}return t.Yr(r)})();super(e,pr.getPublicKey(i)),this.privateKey=i}async signNostrEvent(e){let n=(await this.getNostrPublicKey()).slice(2),r=hi({...e,pubkey:n}),i=pr.sign(r,this.privateKey);return{...e,id:t.yr(r).slice(2),pubkey:n,sig:t.yr(i).slice(2)}}},Ui=e.t({Address:()=>L,Bytes:()=>t.Gr,Cell:()=>t.a,CellAny:()=>t.o,CellDep:()=>t.s,CellDepInfo:()=>t.nt,CellDepVec:()=>t.c,CellInput:()=>t.l,CellInputVec:()=>t.u,CellOutput:()=>t.d,CellOutputVec:()=>t.f,Client:()=>F,ClientBlock:()=>t.rt,ClientBlockHeader:()=>t.it,ClientBlockUncle:()=>t.at,ClientCache:()=>N,ClientCacheMemory:()=>P,ClientIndexerSearchKey:()=>t.ot,ClientIndexerSearchKeyFilter:()=>t.st,ClientIndexerSearchKeyTransaction:()=>t.ct,ClientJsonRpc:()=>ie,ClientPublicMainnet:()=>ae,ClientPublicTestnet:()=>oe,ClientTransactionResponse:()=>t.lt,Codec:()=>t.Wr,CodecBool:()=>t.yn,CodecByte:()=>t.bn,CodecByte16:()=>t.xn,CodecByte32:()=>t.Sn,CodecByte4:()=>t.Cn,CodecByte8:()=>t.wn,CodecBytes:()=>t.Tn,CodecRaw:()=>t.En,CodecUint128:()=>t.Dn,CodecUint128BE:()=>t.On,CodecUint128LE:()=>t.kn,CodecUint16:()=>t.An,CodecUint16BE:()=>t.jn,CodecUint16LE:()=>t.Mn,CodecUint256:()=>t.Nn,CodecUint256BE:()=>t.Pn,CodecUint256LE:()=>t.Fn,CodecUint32:()=>t.In,CodecUint32BE:()=>t.Ln,CodecUint32LE:()=>t.Rn,CodecUint512:()=>t.zn,CodecUint512BE:()=>t.Bn,CodecUint512LE:()=>t.Vn,CodecUint64:()=>t.Hn,CodecUint64BE:()=>t.Un,CodecUint64LE:()=>t.Wn,CodecUint8:()=>t.Gn,DepTypeCodec:()=>t.p,Entity:()=>t.lr,Epoch:()=>t.xt,ErrorClientBase:()=>t.ut,ErrorClientDuplicatedTransaction:()=>t.dt,ErrorClientMaxFeeRateExceeded:()=>t.ft,ErrorClientRBFRejected:()=>t.pt,ErrorClientResolveUnknown:()=>t.mt,ErrorClientVerification:()=>t.ht,ErrorClientWaitTransactionTimeout:()=>t.gt,ErrorTransactionInsufficientCapacity:()=>t.E,ErrorTransactionInsufficientCoin:()=>t.D,HASH_CKB_LENGTH:()=>32,HASH_CKB_SHORT_LENGTH:()=>20,HashTypeCodec:()=>t.j,HasherCkb:()=>t.pr,HasherKeecak256:()=>A,InputToSign:()=>nt,KnownScript:()=>t.J,MultisigCkbWitness:()=>$,One:()=>t.ar,OutPoint:()=>t.m,Proxy:()=>M,RawTransaction:()=>t.h,RequestorJsonRpc:()=>ne,SECP256K1_SIGNATURE_LENGTH:()=>65,Script:()=>t.M,ScriptInfo:()=>t._t,ScriptOpt:()=>t.N,ScriptVec:()=>t.P,SignPsbtOptions:()=>tt,Signature:()=>yi,Signer:()=>Q,SignerAlwaysError:()=>Ii,SignerBtc:()=>Ci,SignerBtcPublicKeyReadonly:()=>wi,SignerCkbAlwaysSuccess:()=>Ti,SignerCkbPrivateKey:()=>Di,SignerCkbPublicKey:()=>Ei,SignerCkbScriptReadonly:()=>Oi,SignerDoge:()=>Mi,SignerDogeAddressReadonly:()=>Ni,SignerDogePrivateKey:()=>Pi,SignerDummy:()=>Fi,SignerEvm:()=>Ri,SignerEvmAddressReadonly:()=>zi,SignerInfo:()=>Si,SignerMultisig:()=>bi,SignerMultisigCkbPrivateKey:()=>ji,SignerMultisigCkbReadonly:()=>Ai,SignerMultisigNotEnoughSignaturesError:()=>xi,SignerNostr:()=>Bi,SignerNostrPrivateKey:()=>Hi,SignerNostrPublicKeyReadonly:()=>Vi,SignerOpenLink:()=>Li,SignerSignType:()=>_i,SignerType:()=>vi,Since:()=>t.g,Transaction:()=>t._,WitnessArgs:()=>t.v,Zero:()=>t.or,apply:()=>t.Et,btcEcdsaPublicKeyHash:()=>ti,btcP2pkhAddressFromPublicKey:()=>ni,btcPublicKeyFromP2pkhAddress:()=>ri,btcVarLengthBytesFrom:()=>$r,buildNostrEventFromMessage:()=>mi,bytesConcat:()=>t.Kr,bytesConcatTo:()=>t.qr,bytesEq:()=>t.Jr,bytesFrom:()=>t.Yr,bytesLen:()=>t._r,bytesLenUnsafe:()=>t.vr,bytesTo:()=>t.Xr,calcDaoClaimEpoch:()=>t.y,calcDaoProfit:()=>t.b,codec:()=>t.ur,codecPadding:()=>t.Kn,codecUint:()=>t.qn,codecUintNumber:()=>t.Jn,depTypeFrom:()=>t.x,depTypeFromBytes:()=>t.S,depTypeToBytes:()=>t.C,epochFrom:()=>t.St,epochFromHex:()=>t.Ct,epochToHex:()=>t.wt,fixedPointFrom:()=>t.sr,fixedPointToString:()=>t.cr,gcd:()=>t.Dt,hashCkb:()=>t.mr,hashCkbShort:()=>t.hr,hashTypeFrom:()=>t.F,hashTypeFromBytes:()=>t.I,hashTypeId:()=>se,hashTypeToBytes:()=>t.L,hexFrom:()=>t.yr,isDaoOutputLimitExceeded:()=>t.w,isWebview:()=>t.Ot,keystoreDecrypt:()=>et,keystoreEncrypt:()=>$e,messageHashBtcEcdsa:()=>ei,messageHashCkbSecp256k1:()=>ci,messageHashDogeEcdsa:()=>di,mol:()=>j,nostrEventHash:()=>hi,numBeFromBytes:()=>t.Yn,numBeToBytes:()=>t.Xn,numFrom:()=>t.Zn,numFromBytes:()=>t.Qn,numLeFromBytes:()=>t.$n,numLeToBytes:()=>t.er,numMax:()=>t.tr,numMin:()=>t.nr,numToBytes:()=>t.rr,numToHex:()=>t.ir,recoverMessageSecp256k1:()=>si,reduceAsync:()=>t.kt,signMessageSecp256k1:()=>ai,sleep:()=>t.At,stringify:()=>t.jt,udtBalanceFrom:()=>t.T,verifyMessageBtcEcdsa:()=>ii,verifyMessageCkbSecp256k1:()=>li,verifyMessageDogeEcdsa:()=>fi,verifyMessageEvmPersonal:()=>pi,verifyMessageJoyId:()=>ui,verifyMessageNostrEvent:()=>gi,verifyMessageSecp256k1:()=>oi});Object.defineProperty(exports,"$",{enumerable:!0,get:function(){return se}}),Object.defineProperty(exports,"A",{enumerable:!0,get:function(){return hi}}),Object.defineProperty(exports,"B",{enumerable:!0,get:function(){return li}}),Object.defineProperty(exports,"C",{enumerable:!0,get:function(){return Q}}),Object.defineProperty(exports,"D",{enumerable:!0,get:function(){return _i}}),Object.defineProperty(exports,"E",{enumerable:!0,get:function(){return xi}}),Object.defineProperty(exports,"F",{enumerable:!0,get:function(){return ui}}),Object.defineProperty(exports,"G",{enumerable:!0,get:function(){return $r}}),Object.defineProperty(exports,"H",{enumerable:!0,get:function(){return ti}}),Object.defineProperty(exports,"I",{enumerable:!0,get:function(){return 65}}),Object.defineProperty(exports,"J",{enumerable:!0,get:function(){return nt}}),Object.defineProperty(exports,"K",{enumerable:!0,get:function(){return ei}}),Object.defineProperty(exports,"L",{enumerable:!0,get:function(){return ci}}),Object.defineProperty(exports,"M",{enumerable:!0,get:function(){return pi}}),Object.defineProperty(exports,"N",{enumerable:!0,get:function(){return di}}),Object.defineProperty(exports,"O",{enumerable:!0,get:function(){return vi}}),Object.defineProperty(exports,"P",{enumerable:!0,get:function(){return fi}}),Object.defineProperty(exports,"Q",{enumerable:!0,get:function(){return L}}),Object.defineProperty(exports,"R",{enumerable:!0,get:function(){return si}}),Object.defineProperty(exports,"S",{enumerable:!0,get:function(){return yi}}),Object.defineProperty(exports,"T",{enumerable:!0,get:function(){return bi}}),Object.defineProperty(exports,"U",{enumerable:!0,get:function(){return ni}}),Object.defineProperty(exports,"V",{enumerable:!0,get:function(){return oi}}),Object.defineProperty(exports,"W",{enumerable:!0,get:function(){return ri}}),Object.defineProperty(exports,"X",{enumerable:!0,get:function(){return et}}),Object.defineProperty(exports,"Y",{enumerable:!0,get:function(){return tt}}),Object.defineProperty(exports,"Z",{enumerable:!0,get:function(){return $e}}),Object.defineProperty(exports,"_",{enumerable:!0,get:function(){return Di}}),Object.defineProperty(exports,"a",{enumerable:!0,get:function(){return zi}}),Object.defineProperty(exports,"at",{enumerable:!0,get:function(){return P}}),Object.defineProperty(exports,"b",{enumerable:!0,get:function(){return wi}}),Object.defineProperty(exports,"c",{enumerable:!0,get:function(){return Ii}}),Object.defineProperty(exports,"ct",{enumerable:!0,get:function(){return j}}),Object.defineProperty(exports,"d",{enumerable:!0,get:function(){return Ni}}),Object.defineProperty(exports,"et",{enumerable:!0,get:function(){return oe}}),Object.defineProperty(exports,"f",{enumerable:!0,get:function(){return Mi}}),Object.defineProperty(exports,"g",{enumerable:!0,get:function(){return Oi}}),Object.defineProperty(exports,"h",{enumerable:!0,get:function(){return Ai}}),Object.defineProperty(exports,"i",{enumerable:!0,get:function(){return Bi}}),Object.defineProperty(exports,"it",{enumerable:!0,get:function(){return F}}),Object.defineProperty(exports,"j",{enumerable:!0,get:function(){return gi}}),Object.defineProperty(exports,"k",{enumerable:!0,get:function(){return mi}}),Object.defineProperty(exports,"l",{enumerable:!0,get:function(){return Fi}}),Object.defineProperty(exports,"lt",{enumerable:!0,get:function(){return A}}),Object.defineProperty(exports,"m",{enumerable:!0,get:function(){return $}}),Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return Hi}}),Object.defineProperty(exports,"nt",{enumerable:!0,get:function(){return ie}}),Object.defineProperty(exports,"o",{enumerable:!0,get:function(){return Ri}}),Object.defineProperty(exports,"ot",{enumerable:!0,get:function(){return N}}),Object.defineProperty(exports,"p",{enumerable:!0,get:function(){return ji}}),Object.defineProperty(exports,"q",{enumerable:!0,get:function(){return ii}}),Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return Vi}}),Object.defineProperty(exports,"rt",{enumerable:!0,get:function(){return ne}}),Object.defineProperty(exports,"s",{enumerable:!0,get:function(){return Li}}),Object.defineProperty(exports,"st",{enumerable:!0,get:function(){return M}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return Ui}}),Object.defineProperty(exports,"tt",{enumerable:!0,get:function(){return ae}}),Object.defineProperty(exports,"u",{enumerable:!0,get:function(){return Pi}}),Object.defineProperty(exports,"v",{enumerable:!0,get:function(){return Ei}}),Object.defineProperty(exports,"w",{enumerable:!0,get:function(){return Si}}),Object.defineProperty(exports,"x",{enumerable:!0,get:function(){return Ci}}),Object.defineProperty(exports,"y",{enumerable:!0,get:function(){return Ti}}),Object.defineProperty(exports,"z",{enumerable:!0,get:function(){return ai}});
+//# sourceMappingURL=barrel-D8_wJLfr.js.map