@ckb-ccc/core 1.19.1 → 1.20.1

package/{dist/advancedBarrel-BwJIDnvL.d.mts → dist.commonjs/advancedBarrel-B57gAzdK.d.ts}

@@ -1,9 +1,10 @@
+//#endregion
 //#region src/bytes/advanced.d.ts
 /**
  * Represents the possible encoding formats for converting bytes.
  * @public
  */
-type BytesFromEncoding = "utf8" | "utf16le" | "latin1" | "base64" | "base64url" | "hex" | "ascii" | "binary" | "ucs2";
+type BytesFromEncoding = "utf8" | "base64" | "base64url" | "hex";
 //#endregion
 //#region src/bytes/index.d.ts
 /**
@@ -525,10 +526,192 @@ declare function numLeFromBytes(val: BytesLike): Num;
  */
 declare function numBeFromBytes(val: BytesLike): Num;
 //#endregion
+//#region src/utils/abortSignal.d.ts
+/**
+ * Creates a signal that aborts when any of the input signals aborts.
+ *
+ * Uses the native `AbortSignal.any` when available and falls back to an
+ * `AbortController` implementation for older runtimes.
+ *
+ * @public
+ */
+declare function abortSignalAny(signals: readonly AbortSignal[]): AbortSignal;
+//#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/owner/owner.d.ts
+/**
+ * An ownership claim moved out of an {@link Owner}.
+ *
+ * @public
+ */
+declare class OwnerMoved<T> {
+  /** The owned value. */
+  readonly value: T;
+  private readonly disposer;
+  private disposing?;
+  constructor(
+  /** The owned value. */
+  value: T, disposer: (value: T) => PromiseLike<void> | void);
+  /** Disposes this ownership claim. */
+  dispose(): Promise<void>;
+}
+declare const ownerId: unique symbol;
+/**
+ * Owns the lifecycle of a value.
+ *
+ * @example
+ * ```ts
+ * class ConnectionOwner extends Owner<Connection> {
+ *   constructor(protected readonly value_: Connection) {
+ *     super();
+ *   }
+ *
+ *   protected release(connection: Connection): Promise<void> {
+ *     return connection.close();
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+declare abstract class Owner<T> {
+  protected abstract readonly value_: T;
+  private readonly [ownerId];
+  private disposing?;
+  /** Whether this ownership claim has not been moved or disposed. */
+  get isValid(): boolean;
+  /** Returns whether a value implements CCC Owner semantics. */
+  static is(value: unknown): value is Owner<unknown>;
+  /**
+   * The owned value.
+   *
+   * @throws If this ownership has been moved or disposed.
+   */
+  get value(): T;
+  /**
+   * Releases this ownership claim.
+   *
+   * Implementations decide whether this disposes the value immediately or,
+   * for example, only decrements a reference count.
+   */
+  protected abstract release(value: T): PromiseLike<void> | void;
+  /**
+   * Disposes this ownership claim. Repeated calls are safe.
+   */
+  dispose(): Promise<void>;
+  /**
+   * Maps the owned value while transferring this ownership claim.
+   *
+   * The mapper runs before the claim is moved, so a mapper failure leaves this
+   * Owner active. After a successful mapping, this Owner is invalidated and the
+   * returned Owner retains its release semantics.
+   */
+  map<U>(mapper: (value: T) => U): Owner<U>;
+  /**
+   * Moves the ownership claim out of this owner without disposing it.
+   *
+   * Access is invalidated synchronously and the moved claim retains this
+   * Owner's release semantics.
+   *
+   * @throws If this owner no longer has an ownership claim.
+   */
+  protected move(): OwnerMoved<T>;
+  /**
+   * Moves an ownership claim between Owner implementations.
+   *
+   * @throws If the source owner has already been moved or disposed.
+   */
+  protected static moveFrom<T>(owner: Owner<T>): OwnerMoved<T>;
+}
+//#endregion
+//#region src/utils/owner/aggregated.d.ts
+type Owners = readonly Owner<any>[];
+type OwnerValues<T extends Owners> = { [K in keyof T]: T[K] extends Owner<infer U> ? U : never; };
+/**
+ * An Owner that aggregates multiple ownership claims.
+ *
+ * Disposing it attempts to release every claim and aggregates any failures.
+ *
+ * @public
+ */
+declare class OwnerAggregated<T extends readonly unknown[]> extends Owner<T> {
+  protected readonly value_: T;
+  private readonly owners;
+  private constructor();
+  /** Moves multiple ownership claims into one Owner. */
+  static from<const TOwners extends Owners>(owners: TOwners): OwnerAggregated<OwnerValues<TOwners>>;
+  protected release(): Promise<void>;
+}
+//#endregion
+//#region src/utils/owner/refCount.d.ts
+/**
+ * A reference-counted Owner for a shared value.
+ *
+ * The source ownership is disposed after the final OwnerRefCount is disposed.
+ * Each clone owns one reference and can be disposed independently.
+ *
+ * @example
+ * ```ts
+ * const controller = new AbortController();
+ * const first = OwnerRefCount.new(
+ *   controller,
+ *   (controller) => controller.abort(),
+ * );
+ * const second = first.clone();
+ *
+ * await first.dispose();
+ * console.log(controller.signal.aborted); // false
+ *
+ * await second.dispose();
+ * console.log(controller.signal.aborted); // true
+ * ```
+ *
+ * @public
+ */
+declare class OwnerRefCount<T> extends Owner<T> {
+  private readonly state;
+  private constructor();
+  protected get value_(): T;
+  /** Creates the first reference-counted Owner for a value. */
+  static new<T>(value: T, disposer: (value: T) => PromiseLike<void> | void): OwnerRefCount<T>;
+  /**
+   * Moves an ownership claim into a new reference-counted Owner.
+   *
+   * @throws If the source Owner has already been moved or disposed.
+   */
+  static from<T>(owner: Owner<T>): OwnerRefCount<T>;
+  /** Creates another Owner for the same shared value. */
+  clone(): OwnerRefCount<T>;
+  protected release(): Promise<void> | void;
+}
+//#endregion
+//#region src/utils/owner/unique.d.ts
+/**
+ * An Owner with a single, transferable ownership claim.
+ *
+ * @example
+ * ```ts
+ * const owner = new OwnerUnique(
+ *   new AbortController(),
+ *   (controller) => controller.abort(),
+ * );
+ *
+ * const signal = owner.value.signal;
+ * await owner.dispose();
+ * ```
+ *
+ * @public
+ */
+declare class OwnerUnique<T> extends Owner<T> {
+  protected readonly value_: T;
+  private readonly disposer;
+  constructor(value_: T, disposer: (value: T) => PromiseLike<void> | void);
+  protected release(value: T): void | PromiseLike<void>;
+}
+//#endregion
 //#region src/utils/proxy.d.ts
 /**
  * Utilities for creating composition wrappers.
@@ -1349,62 +1532,89 @@ declare class HasherKeecak256 implements Hasher {
 }
 //#endregion
 //#region src/jsonRpc/transports/transport.d.ts
+type JsonRpcId = string | number;
 type JsonRpcPayload = {
-  id: number;
+  id: JsonRpcId;
   jsonrpc: "2.0";
   method: string;
   params: unknown[] | Record<string, unknown>;
 };
-interface Transport {
+type JsonRpcErrorLike<Data = unknown> = {
+  code: number;
+  message: string;
+  data?: Data;
+};
+declare class JsonRpcError<Data = unknown> extends Error {
+  readonly code: number;
+  readonly data?: Data;
+  constructor(error: JsonRpcErrorLike<Data>);
+}
+type JsonRpcResponse<Result = unknown, ErrorData = unknown> = {
+  id: JsonRpcId;
+  jsonrpc: "2.0";
+} & ({
+  result: Result;
+  error?: never;
+} | {
+  result?: never;
+  error: JsonRpcErrorLike<ErrorData>;
+});
+interface JsonRpcTransport {
   /**
    * Sends a JSON-RPC request to the server.
    *
    * @param payload - The JSON-RPC payload to send.
-   * @returns The result of the JSON-RPC request.
-   *
-   * @throws Will throw an error if the response ID does not match the request ID, or if the response contains an error.
+   * @returns The JSON-RPC response.
    */
-  request(data: JsonRpcPayload): Promise<unknown>;
+  request(payload: JsonRpcPayload): Promise<JsonRpcResponse>;
+}
+//#endregion
+//#region src/jsonRpc/transports/fallback.d.ts
+declare class JsonRpcTransportFallback implements JsonRpcTransport {
+  private readonly transports;
+  private i;
+  constructor(transports: JsonRpcTransport[]);
+  request(data: JsonRpcPayload): Promise<JsonRpcResponse>;
 }
 //#endregion
 //#region src/jsonRpc/transports/http.d.ts
-declare class TransportHttp implements Transport {
+declare class JsonRpcTransportHttp implements JsonRpcTransport {
   private readonly url;
   private readonly timeout;
   constructor(url: string, timeout?: number);
-  request(payload: JsonRpcPayload): Promise<any>;
+  request(payload: JsonRpcPayload): Promise<JsonRpcResponse>;
 }
 //#endregion
 //#region src/jsonRpc/transports/webSocket.d.ts
-declare class TransportWebSocket implements Transport {
+declare class JsonRpcTransportWebSocket implements JsonRpcTransport {
   private readonly url;
   private readonly timeout;
   private ongoing;
+  private disposed;
   private socket?;
   private openSocket?;
+  /**
+   * @deprecated Use {@link JsonRpcTransportWebSocket.open} to make lifecycle
+   * ownership explicit. This constructor will become private in a future
+   * release.
+   */
   constructor(url: string, timeout?: number);
-  request(data: JsonRpcPayload): Promise<unknown>;
-}
-//#endregion
-//#region src/jsonRpc/transports/factory.d.ts
-declare function transportFromUri(uri: string, config?: {
-  timeout?: number;
-}): TransportWebSocket | TransportHttp;
-//#endregion
-//#region src/jsonRpc/transports/fallback.d.ts
-declare class TransportFallback implements Transport {
-  private readonly transports;
-  private i;
-  constructor(transports: Transport[]);
-  request(data: JsonRpcPayload): Promise<unknown>;
+  /** Opens an owned WebSocket transport. */
+  static open(url: string, timeout?: number): OwnerUnique<JsonRpcTransportWebSocket>;
+  request(data: JsonRpcPayload): Promise<JsonRpcResponse>;
+  private dispose;
 }
 //#endregion
 //#region src/jsonRpc/requestor.d.ts
+/**
+ * @deprecated Used only by the legacy positional constructor. Use the static
+ * {@link RequestorJsonRpc.new} or {@link RequestorJsonRpc.open} methods.
+ */
 type RequestorJsonRpcConfig = {
   fallbacks?: string[];
   timeout?: number;
   maxConcurrent?: number;
-  transport?: Transport;
+  transport?: JsonRpcTransport;
 };
 declare class RequestorJsonRpc {
   private readonly url_;
@@ -1412,19 +1622,36 @@ declare class RequestorJsonRpc {
   readonly maxConcurrent?: number;
   private concurrent;
   private readonly pending;
-  readonly transport: Transport;
+  readonly transport: JsonRpcTransport;
   private id;
   /**
-   * Creates an instance of ClientJsonRpc.
+   * Creates a Requestor using legacy positional arguments.
    *
    * @param url_ - The URL of the JSON-RPC server.
    * @param timeout - The timeout for requests in milliseconds
+   * @deprecated Use {@link RequestorJsonRpc.new} with a borrowed Transport or
+   * {@link RequestorJsonRpc.open} when creating Transports.
    */
   constructor(url_: string, config?: RequestorJsonRpcConfig, onError?: ((err: unknown) => Promise<void> | void) | undefined);
+  /** Creates a Requestor that borrows an existing Transport. */
+  static new({ transport, maxConcurrent, onError }: {
+    transport: JsonRpcTransport;
+    maxConcurrent?: number;
+    onError?: (err: unknown) => Promise<void> | void;
+  }): RequestorJsonRpc;
+  /** Opens a Requestor with ownership of its default transports. */
+  static open({ urls: [url, ...fallbacks], onError, ...config }: {
+    urls: readonly [string, ...string[]];
+    timeout?: number;
+    maxConcurrent?: number;
+    onError?: (err: unknown) => Promise<void> | void;
+  }): Owner<RequestorJsonRpc>;
   /**
    * Returns the URL of the JSON-RPC server.
    *
    * @returns The URL of the JSON-RPC server.
+   * @deprecated URL belongs to Transport construction and is unavailable for
+   * Requestors created with {@link RequestorJsonRpc.new}.
    */
   get url(): string;
   /**
@@ -2874,6 +3101,94 @@ declare class SignerEvmAddressReadonly extends SignerEvm {
  */
 declare function verifyMessageEvmPersonal(message: string | BytesLike, signature: string, address: string): boolean;
 //#endregion
+//#region src/signer/jsonRpc/transformers.d.ts
+type SignerJsonRpcInfo = {
+  type: SignerType;
+  signType: SignerSignType;
+  name?: string;
+  icon?: string;
+};
+type SignerJsonRpcInfoPayload = {
+  type: SignerType;
+  sign_type: SignerSignType;
+  name?: string;
+  icon?: string;
+};
+type SignerJsonRpcMessageToSign = {
+  type: "string";
+  value: string;
+} | {
+  type: "bytes";
+  value: Hex;
+};
+declare class SignerJsonRpcTransformers {
+  static infoFrom(info: SignerJsonRpcInfo): SignerJsonRpcInfoPayload;
+  static infoTo(info: SignerJsonRpcInfoPayload): SignerJsonRpcInfo;
+  static messageFrom(message: string | BytesLike): SignerJsonRpcMessageToSign;
+  static messageTo(message: unknown): string | Uint8Array;
+}
+//#endregion
+//#region src/signer/jsonRpc/handler.d.ts
+type SignerJsonRpcConfirmation = {
+  method: "connect";
+  networkId: string;
+} | {
+  method: "sign_message";
+  message: SignerJsonRpcMessageToSign;
+} | {
+  method: "sign_transaction";
+  transaction: Transaction;
+};
+type SignerJsonRpcHandlerConfig = {
+  getSigner: () => Signer | undefined;
+  getSignerMetadata?: () => Pick<SignerJsonRpcInfo, "name" | "icon">;
+  /** Connects the requested network and returns its connected Signer. */
+  connect: (networkId: string) => Promise<Signer>;
+  confirmRequest: (request: SignerJsonRpcConfirmation) => Promise<boolean>;
+};
+type SignerJsonRpcHandler = (payload: JsonRpcPayload) => unknown;
+declare function buildSignerJsonRpcHandler({ connect, confirmRequest, getSigner, getSignerMetadata }: SignerJsonRpcHandlerConfig): SignerJsonRpcHandler;
+//#endregion
+//#region src/signer/jsonRpc/signer.d.ts
+type SignerJsonRpcConfig = Omit<Parameters<typeof RequestorJsonRpc.new>[0], "onError"> & {
+  /** Cleans up integration-owned resources before replacement is announced. */
+  disconnectHandler?: () => PromiseLike<void> | void;
+};
+declare class SignerJsonRpc extends Signer {
+  readonly requestor: RequestorJsonRpc;
+  private info;
+  private readonly disconnectHandler?;
+  private connecting?;
+  private disconnecting?;
+  private scriptsPromise?;
+  private internalAddressPromise?;
+  private identityPromise?;
+  private readonly replacedListeners;
+  private constructor();
+  /** Creates a Signer that borrows an existing Transport. */
+  static new(client: Client, config: SignerJsonRpcConfig): Promise<SignerJsonRpc>;
+  get type(): SignerType;
+  get signType(): SignerSignType;
+  get url(): string;
+  get name(): string | undefined;
+  get icon(): string | undefined;
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  onReplaced(listener: () => void): () => boolean;
+  replace(): void;
+  isConnected(): Promise<boolean>;
+  getScripts(): Promise<Script[]>;
+  getAddressObjs(): Promise<Address[]>;
+  getInternalAddress(): Promise<string>;
+  getIdentity(): Promise<string>;
+  signMessageRaw: Signer["signMessageRaw"];
+  prepareTransaction: Signer["prepareTransaction"];
+  signOnlyTransaction: Signer["signOnlyTransaction"];
+  buildSender(rpcMethod: Parameters<RequestorJsonRpc["request"]>[0], inTransformers?: Parameters<RequestorJsonRpc["request"]>[2], outTransformer?: Parameters<RequestorJsonRpc["request"]>[3]): (...request: unknown[]) => Promise<unknown>;
+  private clearReadCache;
+  private requestConnect;
+}
+//#endregion
 //#region src/signer/nostr/signerNostr.d.ts
 /**
  * @public
@@ -2974,7 +3289,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 { 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 };
+  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, ClientConfig, 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, JsonRpcError, JsonRpcErrorLike, JsonRpcId, JsonRpcPayload, JsonRpcResponse, JsonRpcTransport, JsonRpcTransportFallback, JsonRpcTransportHttp, JsonRpcTransportWebSocket, KnownScript, LumosTransactionSkeletonType, MultisigCkbWitness, MultisigCkbWitnessLike, NetworkPreference, NostrEvent, Num, NumLike, One, OutPoint, OutPointLike, OutputsValidator, Owner, OwnerAggregated, OwnerMoved, OwnerRefCount, OwnerUnique, 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, SignerJsonRpc, SignerJsonRpcConfig, SignerJsonRpcConfirmation, SignerJsonRpcHandler, SignerJsonRpcHandlerConfig, SignerMultisig, SignerMultisigCkbPrivateKey, SignerMultisigCkbReadonly, SignerMultisigNotEnoughSignaturesError, SignerNostr, SignerNostrPrivateKey, SignerNostrPublicKeyReadonly, SignerOpenLink, SignerSignType, SignerType, Since, SinceLike, Transaction, TransactionLike, TransactionStatus, Wallet, WitnessArgs, WitnessArgsLike, Zero, abortSignalAny, apply, btcEcdsaPublicKeyHash, btcP2pkhAddressFromPublicKey, btcPublicKeyFromP2pkhAddress, btcVarLengthBytesFrom, buildNostrEventFromMessage, buildSignerJsonRpcHandler, 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
@@ -3727,830 +4042,599 @@ declare enum KnownScript {
   TimeLock = "TimeLock"
 }
 //#endregion
-//#region src/ckb/script.d.ts
-declare const HashTypeCodec: Codec<HashTypeLike, HashType>;
-/**
- * @public
- */
-type HashTypeLike = string | number | bigint;
-/**
- * @public
- */
-type HashType = "type" | "data" | "data1" | "data2";
-/**
- * Converts a HashTypeLike value to a HashType.
- * @public
- *
- * @param val - The value to convert, which can be a string, number, or bigint.
- * @returns The corresponding HashType.
- *
- * @throws Will throw an error if the input value is not a valid hash type.
- *
- * @example
- * ```typescript
- * const hashType = hashTypeFrom(1); // Outputs "data"
- * const hashType = hashTypeFrom("type"); // Outputs "type"
- * ```
- */
-declare function hashTypeFrom(val: HashTypeLike): HashType;
-/**
- * Converts a HashTypeLike value to its corresponding byte representation.
- * @public
- *
- * @param hashType - The hash type value to convert.
- * @returns A Uint8Array containing the byte representation of the hash type.
- *
- * @example
- * ```typescript
- * const hashTypeBytes = hashTypeToBytes("type"); // Outputs Uint8Array [0]
- * ```
- */
-declare function hashTypeToBytes(hashType: HashTypeLike): Bytes$1;
-/**
- * Converts a byte-like value to a HashType.
- * @public
- *
- * @param bytes - The byte-like value to convert.
- * @returns The corresponding HashType.
- *
- * @throws Will throw an error if the input bytes do not correspond to a valid hash type.
- *
- * @example
- * ```typescript
- * const hashType = hashTypeFromBytes(new Uint8Array([0])); // Outputs "type"
- * ```
- */
-declare function hashTypeFromBytes(bytes: BytesLike): HashType;
+//#region src/client/client.d.ts
+type ClientConfig = {
+  cache?: ClientCache;
+  scripts?: Partial<Record<KnownScript, ScriptInfoLike>>;
+};
 /**
  * @public
  */
-type ScriptLike = {
-  codeHash: BytesLike;
-  hashType: HashTypeLike;
-  args: BytesLike;
-};
-declare const Script_base: (abstract new () => {
-  toBytes(): Bytes$1;
-  clone(): Script;
-  eq(other: ScriptLike): boolean;
-  hash(): Hex;
-  toHex(): Hex;
-}) & {
-  byteLength?: number;
-  encode(_: ScriptLike): Bytes$1;
-  decode(_: BytesLike): Script;
-  fromBytes(_bytes: BytesLike): Script;
-  from(_: ScriptLike): Script;
-  Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
-    toBytes(): Bytes$1;
-    clone(): SubType;
-    eq(other: SubTypeLike): boolean;
-    hash(): Hex;
-    toHex(): Hex;
-  }) & {
-    byteLength?: number;
-    encode(_: SubTypeLike): Bytes$1;
-    decode(_: BytesLike): SubType;
-    fromBytes(_bytes: BytesLike): SubType;
-    from(_: SubTypeLike): SubType;
-    Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new (inner: DecodedType<CodecType>) => {
-      readonly inner: DecodedType<CodecType>;
-      match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
-        _?: undefined | null;
-      }): Result;
-      match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
-        _: (inner: DecodedType<CodecType>) => Result;
-      }): Result;
-      toBytes(): Bytes$1;
-      clone(): SubType_1;
-      eq(other: SubTypeLike_1): boolean;
-      hash(): Hex;
-      toHex(): Hex;
-    }) & {
-      byteLength?: number;
-      encode(_: SubTypeLike_1): Bytes$1;
-      decode(_: BytesLike): SubType_1;
-      fromBytes(_bytes: BytesLike): SubType_1;
-      from(_: SubTypeLike_1): SubType_1;
-      Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
-    };
-  };
-  BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): (abstract new (inner: DecodedType<CodecType>) => {
-    readonly inner: DecodedType<CodecType>;
-    match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
-      _?: undefined | null;
-    }): Result;
-    match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
-      _: (inner: DecodedType<CodecType>) => Result;
-    }): Result;
-    toBytes(): Bytes$1;
-    clone(): SubType;
-    eq(other: SubTypeLike): boolean;
-    hash(): Hex;
-    toHex(): Hex;
-  }) & {
-    byteLength?: number;
-    encode(_: SubTypeLike): Bytes$1;
-    decode(_: BytesLike): SubType;
-    fromBytes(_bytes: BytesLike): SubType;
-    from(_: SubTypeLike): SubType;
-    Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new () => {
-      toBytes(): Bytes$1;
-      clone(): SubType_1;
-      eq(other: SubTypeLike_1): boolean;
-      hash(): Hex;
-      toHex(): Hex;
-    }) & {
-      byteLength?: number;
-      encode(_: SubTypeLike_1): Bytes$1;
-      decode(_: BytesLike): SubType_1;
-      fromBytes(_bytes: BytesLike): SubType_1;
-      from(_: SubTypeLike_1): SubType_1;
-      Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
-      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-    };
-    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-  };
-};
-/**
- * @public
- */
-declare class Script extends Script_base {
-  codeHash: Hex;
-  hashType: HashType;
-  args: Hex;
+declare abstract class Client {
+  cache: ClientCache;
+  private readonly scripts;
+  constructor(config?: ClientConfig);
   /**
-   * Creates an instance of Script.
+   * The legacy primary URL associated with this Client.
    *
-   * @param codeHash - The code hash of the script.
-   * @param hashType - The hash type of the script.
-   * @param args - The arguments for the script.
+   * @deprecated A Client may use multiple endpoints or a Transport without a
+   * URL, so this value does not reliably identify its connection.
    */
-  constructor(codeHash: Hex, hashType: HashType, args: Hex);
-  get occupiedSize(): number;
+  abstract get url(): string;
+  abstract get addressPrefix(): string;
   /**
-   * Clone a script.
+   * Get the deployment info for a well-known CKB script.
+   * Returns the cell deps and type script info needed to use the script.
    *
-   * @returns A cloned Script instance.
+   * @param script - The KnownScript enum value.
+   * @returns Script info including cellDeps and type hash.
    *
    * @example
    * ```typescript
-   * const script1 = script0.clone();
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   *
+   * // Get xUDT script deployment info
+   * const xudtInfo = await client.getKnownScript(ccc.KnownScript.XUdt);
+   * console.log(`xUDT cellDeps:`, xudtInfo.cellDeps);
+   *
+   * // Build an xUDT type script
+   * const xudtType = await ccc.Script.fromKnownScript(
+   *   client,
+   *   ccc.KnownScript.XUdt,
+   *   "0xOWNER_LOCK_HASH...",
+   * );
    * ```
    */
-  clone(): Script;
+  getKnownScript(script: KnownScript): Promise<ScriptInfo>;
+  abstract getFeeRateStatistics(blockRange?: NumLike): Promise<{
+    mean: Num;
+    median: Num;
+  }>;
   /**
-   * Check if the script is equal to another script.
-   * @public
-   * @param other - The other script to compare with
-   * @returns True if the scripts are equal, false otherwise
+   * Get the recommended transaction fee rate based on recent blocks.
+   * Returns the median fee rate, clamped between min and max fee rates.
+   *
+   * @param blockRange - Number of recent blocks to analyze.
+   * @param options - Optional max fee rate cap.
+   * @returns The recommended fee rate in Shannons per KB.
    *
    * @example
    * ```typescript
-   * const isEqual = script0.eq(script1);
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const feeRate = await client.getFeeRate();
+   * console.log(`Current fee rate: ${feeRate} Shannons/KB`);
    * ```
    */
-  eq(other: ScriptLike): boolean;
+  getFeeRate(blockRange?: NumLike, options?: {
+    maxFeeRate?: NumLike;
+  }): Promise<Num>;
   /**
-   * Creates a Script instance from a ScriptLike object.
+   * Get the latest block number (tip) of the chain.
    *
-   * @param script - A ScriptLike object or an instance of Script.
-   * @returns A Script instance.
+   * @returns The current tip block number.
    *
    * @example
    * ```typescript
-   * const script = Script.from({
-   *   codeHash: "0x1234...",
-   *   hashType: "type",
-   *   args: "0xabcd..."
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const tipBlockNumber = await client.getTip();
+   * console.log(`Current block height: ${tipBlockNumber}`);
+   * ```
+   */
+  abstract getTip(): Promise<Num>;
+  /**
+   * Get the header of the latest block.
+   *
+   * @param verbosity - Verbosity level (0 for hex, 1 for object).
+   * @returns The tip block header.
+   *
+   * @example
+   * ```typescript
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const header = await client.getTipHeader();
+   * console.log(`Block #${header.number}, hash: ${header.hash}`);
+   * ```
+   */
+  abstract getTipHeader(verbosity?: number | null): Promise<ClientBlockHeader>;
+  abstract getBlockByNumberNoCache(blockNumber: NumLike, verbosity?: number | null, withCycles?: boolean | null): Promise<ClientBlock | undefined>;
+  abstract getBlockByHashNoCache(blockHash: HexLike, verbosity?: number | null, withCycles?: boolean | null): Promise<ClientBlock | undefined>;
+  abstract getHeaderByNumberNoCache(blockNumber: NumLike, verbosity?: number | null): Promise<ClientBlockHeader | undefined>;
+  abstract getHeaderByHashNoCache(blockHash: HexLike, verbosity?: number | null): Promise<ClientBlockHeader | undefined>;
+  getBlockByNumber(blockNumber: NumLike, verbosity?: number | null, withCycles?: boolean | null): Promise<ClientBlock | undefined>;
+  getBlockByHash(blockHash: HexLike, verbosity?: number | null, withCycles?: boolean | null): Promise<ClientBlock | undefined>;
+  getHeaderByNumber(blockNumber: NumLike, verbosity?: number | null): Promise<ClientBlockHeader | undefined>;
+  getHeaderByHash(blockHash: HexLike, verbosity?: number | null): Promise<ClientBlockHeader | undefined>;
+  abstract estimateCycles(transaction: TransactionLike): Promise<Num>;
+  abstract sendTransactionDry(transaction: TransactionLike, validator?: OutputsValidator): Promise<Num>;
+  abstract sendTransactionNoCache(transaction: TransactionLike, validator?: OutputsValidator): Promise<Hex>;
+  abstract getTransactionNoCache(txHash: HexLike): Promise<ClientTransactionResponse | undefined>;
+  /**
+   * Get a cell by its out point.
+   * The cell will be cached if it is found.
+   *
+   * @param outPointLike - The out point of the cell to get.
+   * @returns The cell if it exists, otherwise undefined.
+   *
+   * @example
+   * ```typescript
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const cell = await client.getCell({
+   *   txHash: "0xTX_HASH...",
+   *   index: 0,
    * });
+   * if (cell) {
+   *   console.log(`Capacity: ${ccc.fixedPointToString(cell.cellOutput.capacity)} CKB`);
+   *   console.log(`Lock: ${cell.cellOutput.lock.codeHash}`);
+   *   console.log(`Data: ${cell.outputData}`);
+   * }
    * ```
    */
-  static from(script: ScriptLike): Script;
+  getCell(outPointLike: OutPointLike): Promise<Cell | undefined>;
+  getCellWithHeader(outPointLike: OutPointLike): Promise<{
+    cell: Cell;
+    header?: ClientBlockHeader;
+  } | undefined>;
+  abstract getCellLiveNoCache(outPointLike: OutPointLike, withData?: boolean | null, includeTxPool?: boolean | null): Promise<Cell | undefined>;
   /**
-   * Creates a Script instance from client and known script.
+   * Get a live (unspent) cell by its out point.
+   * Unlike getCell(), this verifies the cell is still live on-chain.
    *
-   * @param knownScript - A KnownScript enum.
-   * @param args - Args for the script.
-   * @param client - A ScriptLike object or an instance of Script.
-   * @returns A promise that resolves to the script instance.
+   * @param outPointLike - The out point of the cell.
+   * @param withData - Whether to include cell data.
+   * @param includeTxPool - Whether to include cells in the transaction pool.
+   * @returns The live cell, or undefined if spent or not found.
    *
    * @example
    * ```typescript
-   * const script = await Script.fromKnownScript(
-   *   client,
-   *   KnownScript.XUdt,
-   *   args: "0xabcd..."
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const cell = await client.getCellLive(
+   *   { txHash: "0xTX_HASH...", index: 0 },
+   *   true,  // include data
+   *   true,  // include tx pool
    * );
+   * if (cell) {
+   *   console.log("Cell is still live!");
+   * } else {
+   *   console.log("Cell has been spent or does not exist.");
+   * }
    * ```
    */
-  static fromKnownScript(client: Client, knownScript: KnownScript, args: HexLike): Promise<Script>;
-}
-declare const ScriptOpt: Codec<ScriptLike | null | undefined, Script | undefined>;
-declare const ScriptVec: Codec<ScriptLike[], Script[]>;
-//#endregion
-//#region src/ckb/transactionLumos.d.ts
-interface LumosTransactionSkeletonType {
-  cellDeps: {
-    toArray(): CellDepLike[];
-  };
-  headerDeps: {
-    toArray(): HexLike[];
-  };
-  inputs: {
-    toArray(): {
-      outPoint?: OutPointLike;
-      cellOutput: CellOutputLike;
-      data: HexLike;
-    }[];
-  };
-  inputSinces: {
-    get(i: number, defaultVal: string): HexLike;
-  };
-  outputs: {
-    toArray(): {
-      cellOutput: CellOutputLike;
-      data: HexLike;
-    }[];
-  };
-  witnesses: {
-    toArray(): HexLike[];
-  };
-}
-//#endregion
-//#region src/ckb/transaction.d.ts
-declare const DepTypeCodec: Codec<DepTypeLike, DepType>;
-/**
- * @public
- */
-type DepTypeLike = string | number | bigint;
-/**
- * @public
- */
-type DepType = "depGroup" | "code";
-/**
- * Converts a DepTypeLike value to a DepType.
- * @public
- *
- * @param val - The value to convert, which can be a string, number, or bigint.
- * @returns The corresponding DepType.
- *
- * @throws Will throw an error if the input value is not a valid dep type.
- *
- * @example
- * ```typescript
- * const depType = depTypeFrom(1); // Outputs "code"
- * const depType = depTypeFrom("depGroup"); // Outputs "depGroup"
- * ```
- */
-declare function depTypeFrom(val: DepTypeLike): DepType;
-/**
- * Converts a DepTypeLike value to its corresponding byte representation.
- * @public
- *
- * @param depType - The dep type value to convert.
- * @returns A Uint8Array containing the byte representation of the dep type.
- *
- * @example
- * ```typescript
- * const depTypeBytes = depTypeToBytes("code"); // Outputs Uint8Array [1]
- * ```
- */
-declare function depTypeToBytes(depType: DepTypeLike): Bytes$1;
-/**
- * Converts a byte-like value to a DepType.
- * @public
- *
- * @param bytes - The byte-like value to convert.
- * @returns The corresponding DepType.
- *
- * @throws Will throw an error if the input bytes do not correspond to a valid dep type.
- *
- * @example
- * ```typescript
- * const depType = depTypeFromBytes(new Uint8Array([1])); // Outputs "code"
- * ```
- */
-declare function depTypeFromBytes(bytes: BytesLike): DepType;
-/**
- * @public
- */
-type OutPointLike = {
-  txHash: HexLike;
-  index: NumLike;
-};
-declare const OutPoint_base: (abstract new () => {
-  toBytes(): Bytes$1;
-  clone(): OutPoint;
-  eq(other: OutPointLike): boolean;
-  hash(): Hex;
-  toHex(): Hex;
-}) & {
-  byteLength?: number;
-  encode(_: OutPointLike): Bytes$1;
-  decode(_: BytesLike): OutPoint;
-  fromBytes(_bytes: BytesLike): OutPoint;
-  from(_: OutPointLike): OutPoint;
-  Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
-    toBytes(): Bytes$1;
-    clone(): SubType;
-    eq(other: SubTypeLike): boolean;
-    hash(): Hex;
-    toHex(): Hex;
-  }) & {
-    byteLength?: number;
-    encode(_: SubTypeLike): Bytes$1;
-    decode(_: BytesLike): SubType;
-    fromBytes(_bytes: BytesLike): SubType;
-    from(_: SubTypeLike): SubType;
-    Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new (inner: DecodedType<CodecType>) => {
-      readonly inner: DecodedType<CodecType>;
-      match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
-        _?: undefined | null;
-      }): Result;
-      match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
-        _: (inner: DecodedType<CodecType>) => Result;
-      }): Result;
-      toBytes(): Bytes$1;
-      clone(): SubType_1;
-      eq(other: SubTypeLike_1): boolean;
-      hash(): Hex;
-      toHex(): Hex;
-    }) & {
-      byteLength?: number;
-      encode(_: SubTypeLike_1): Bytes$1;
-      decode(_: BytesLike): SubType_1;
-      fromBytes(_bytes: BytesLike): SubType_1;
-      from(_: SubTypeLike_1): SubType_1;
-      Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
-    };
-  };
-  BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): (abstract new (inner: DecodedType<CodecType>) => {
-    readonly inner: DecodedType<CodecType>;
-    match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
-      _?: undefined | null;
-    }): Result;
-    match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
-      _: (inner: DecodedType<CodecType>) => Result;
-    }): Result;
-    toBytes(): Bytes$1;
-    clone(): SubType;
-    eq(other: SubTypeLike): boolean;
-    hash(): Hex;
-    toHex(): Hex;
-  }) & {
-    byteLength?: number;
-    encode(_: SubTypeLike): Bytes$1;
-    decode(_: BytesLike): SubType;
-    fromBytes(_bytes: BytesLike): SubType;
-    from(_: SubTypeLike): SubType;
-    Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new () => {
-      toBytes(): Bytes$1;
-      clone(): SubType_1;
-      eq(other: SubTypeLike_1): boolean;
-      hash(): Hex;
-      toHex(): Hex;
-    }) & {
-      byteLength?: number;
-      encode(_: SubTypeLike_1): Bytes$1;
-      decode(_: BytesLike): SubType_1;
-      fromBytes(_bytes: BytesLike): SubType_1;
-      from(_: SubTypeLike_1): SubType_1;
-      Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
-      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-    };
-    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-  };
-};
-/**
- * @public
- */
-declare class OutPoint extends OutPoint_base {
-  txHash: Hex;
-  index: Num;
+  getCellLive(outPointLike: OutPointLike, withData?: boolean | null, includeTxPool?: boolean | null): Promise<Cell | undefined>;
+  abstract findCellsPagedNoCache(key: ClientIndexerSearchKeyLike, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindCellsResponse>;
   /**
-   * Creates an instance of OutPoint.
+   * Find cells with pagination support.
+   * Returns one page of results at a time with a cursor for the next page.
    *
-   * @param txHash - The transaction hash.
-   * @param index - The index of the output in the transaction.
+   * @param key - The indexer search key.
+   * @param order - Sort order ("asc" or "desc").
+   * @param limit - Maximum cells per page.
+   * @param after - Cursor from previous page for pagination.
+   * @returns A page of cells with a cursor for the next page.
+   *
+   * @example
+   * ```typescript
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const { script: lock } = await ccc.Address.fromString("ckt1q...", client);
+   *
+   * // Get first page of cells
+   * const page1 = await client.findCellsPaged({
+   *   script: lock,
+   *   scriptType: "lock",
+   * }, "asc", 20);
+   * console.log(`Found ${page1.cells.length} cells`);
+   *
+   * // Get next page
+   * if (page1.cells.length === 20) {
+   *   const page2 = await client.findCellsPaged(
+   *     { script: lock, scriptType: "lock" },
+   *     "asc", 20, page1.lastCursor,
+   *   );
+   * }
+   * ```
    */
-  constructor(txHash: Hex, index: Num);
+  findCellsPaged(key: ClientIndexerSearchKeyLike, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindCellsResponse>;
+  findCellsOnChain(key: ClientIndexerSearchKeyLike, order?: "asc" | "desc", limit?: number): AsyncGenerator<Cell>;
   /**
-   * Creates an OutPoint instance from an OutPointLike object.
+   * Find cells by search key designed for collectable cells.
+   * The result also includes cached cells, the order param only works for cells fetched from RPC.
    *
-   * @param outPoint - An OutPointLike object or an instance of OutPoint.
-   * @returns An OutPoint instance.
+   * @param keyLike - The search key.
+   * @returns A async generator for yielding cells.
    *
    * @example
    * ```typescript
-   * const outPoint = OutPoint.from({ txHash: "0x...", index: 0 });
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const { script: lock } = await ccc.Address.fromString("ckt1q...", client);
+   *
+   * // Find all cells owned by a lock script
+   * for await (const cell of client.findCells({
+   *   script: lock,
+   *   scriptType: "lock",
+   *   scriptSearchMode: "exact",
+   *   withData: true,
+   * })) {
+   *   console.log(`Cell: ${cell.outPoint.txHash}:${cell.outPoint.index}`);
+   *   console.log(`Capacity: ${ccc.fixedPointToString(cell.cellOutput.capacity)} CKB`);
+   * }
    * ```
    */
-  static from(outPoint: OutPointLike): OutPoint;
+  findCells(keyLike: ClientCollectableSearchKeyLike, order?: "asc" | "desc", limit?: number): AsyncGenerator<Cell>;
   /**
-   * Clone a OutPoint.
+   * Find cells by lock script, optionally filtered by type script.
    *
-   * @returns A cloned OutPoint instance.
+   * @param lock - The lock script to search by.
+   * @param type - Optional type script filter.
+   * @param withData - Whether to include cell data (default: true).
+   * @param order - Sort order by block number ("asc" or "desc").
+   * @param limit - Page size for each RPC call (default: 10).
+   * @returns An async generator yielding matching cells.
    *
    * @example
    * ```typescript
-   * const outPoint1 = outPoint0.clone();
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const { script: lock } = await ccc.Address.fromString("ckt1q...", client);
+   *
+   * // Find all cells belonging to this address
+   * for await (const cell of client.findCellsByLock(lock)) {
+   *   console.log(`${ccc.fixedPointToString(cell.cellOutput.capacity)} CKB`);
+   * }
+   *
+   * // Find only xUDT cells belonging to this address
+   * const xudtType = await ccc.Script.fromKnownScript(
+   *   client, ccc.KnownScript.XUdt, "0xOWNER_LOCK_HASH...",
+   * );
+   * for await (const cell of client.findCellsByLock(lock, xudtType)) {
+   *   console.log(`UDT cell found`);
+   * }
    * ```
    */
-  clone(): OutPoint;
+  findCellsByLock(lock: ScriptLike, type?: ScriptLike | null, withData?: boolean, order?: "asc" | "desc", limit?: number): AsyncGenerator<Cell>;
   /**
-   * Check if the OutPoint is equal to another OutPoint.
-   * @public
-   * @param other - The other OutPoint to compare with
-   * @returns True if the OutPoints are equal, false otherwise
+   * Find cells by type script.
+   *
+   * @param type - The type script to search by.
+   * @param withData - Whether to include cell data (default: true).
+   * @param order - Sort order by block number.
+   * @param limit - Page size for each RPC call (default: 10).
+   * @returns An async generator yielding matching cells.
    *
    * @example
    * ```typescript
-   * const isEqual = outPoint0.eq(outPoint1);
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * // Find all xUDT cells of a specific token
+   * const xudtType = await ccc.Script.fromKnownScript(
+   *   client, ccc.KnownScript.XUdt, "0xOWNER_LOCK_HASH...",
+   * );
+   * for await (const cell of client.findCellsByType(xudtType)) {
+   *   console.log(`Token cell: ${cell.outPoint.txHash}:${cell.outPoint.index}`);
+   * }
    * ```
    */
-  eq(other: OutPointLike): boolean;
-}
-/**
- * @public
- */
-type CellOutputLike = {
-  capacity?: NumLike | null;
-  lock: ScriptLike;
-  type?: ScriptLike | null;
-};
-declare const CellOutput_base: (abstract new () => {
-  toBytes(): Bytes$1;
-  clone(): CellOutput;
-  eq(other: CellOutputLike): boolean;
-  hash(): Hex;
-  toHex(): Hex;
-}) & {
-  byteLength?: number;
-  encode(_: CellOutputLike): Bytes$1;
-  decode(_: BytesLike): CellOutput;
-  fromBytes(_bytes: BytesLike): CellOutput;
-  from(_: CellOutputLike): CellOutput;
-  Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
-    toBytes(): Bytes$1;
-    clone(): SubType;
-    eq(other: SubTypeLike): boolean;
-    hash(): Hex;
-    toHex(): Hex;
-  }) & {
-    byteLength?: number;
-    encode(_: SubTypeLike): Bytes$1;
-    decode(_: BytesLike): SubType;
-    fromBytes(_bytes: BytesLike): SubType;
-    from(_: SubTypeLike): SubType;
-    Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new (inner: DecodedType<CodecType>) => {
-      readonly inner: DecodedType<CodecType>;
-      match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
-        _?: undefined | null;
-      }): Result;
-      match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
-        _: (inner: DecodedType<CodecType>) => Result;
-      }): Result;
-      toBytes(): Bytes$1;
-      clone(): SubType_1;
-      eq(other: SubTypeLike_1): boolean;
-      hash(): Hex;
-      toHex(): Hex;
-    }) & {
-      byteLength?: number;
-      encode(_: SubTypeLike_1): Bytes$1;
-      decode(_: BytesLike): SubType_1;
-      fromBytes(_bytes: BytesLike): SubType_1;
-      from(_: SubTypeLike_1): SubType_1;
-      Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
-    };
-  };
-  BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): (abstract new (inner: DecodedType<CodecType>) => {
-    readonly inner: DecodedType<CodecType>;
-    match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
-      _?: undefined | null;
-    }): Result;
-    match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
-      _: (inner: DecodedType<CodecType>) => Result;
-    }): Result;
-    toBytes(): Bytes$1;
-    clone(): SubType;
-    eq(other: SubTypeLike): boolean;
-    hash(): Hex;
-    toHex(): Hex;
-  }) & {
-    byteLength?: number;
-    encode(_: SubTypeLike): Bytes$1;
-    decode(_: BytesLike): SubType;
-    fromBytes(_bytes: BytesLike): SubType;
-    from(_: SubTypeLike): SubType;
-    Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new () => {
-      toBytes(): Bytes$1;
-      clone(): SubType_1;
-      eq(other: SubTypeLike_1): boolean;
-      hash(): Hex;
-      toHex(): Hex;
-    }) & {
-      byteLength?: number;
-      encode(_: SubTypeLike_1): Bytes$1;
-      decode(_: BytesLike): SubType_1;
-      fromBytes(_bytes: BytesLike): SubType_1;
-      from(_: SubTypeLike_1): SubType_1;
-      Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
-      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-    };
-    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
-  };
-};
-/**
- * @public
- */
-declare class CellOutput extends CellOutput_base {
-  capacity: Num;
-  lock: Script;
-  type?: Script | undefined;
-  /**
-   * Creates an instance of CellOutput.
-   *
-   * @param capacity - The capacity of the cell.
-   * @param lock - The lock script of the cell.
-   * @param type - The optional type script of the cell.
-   */
-  constructor(capacity: Num, lock: Script, type?: Script | undefined);
-  get occupiedSize(): number;
+  findCellsByType(type: ScriptLike, withData?: boolean, order?: "asc" | "desc", limit?: number): AsyncGenerator<Cell>;
+  findSingletonCellByType(type: ScriptLike, withData?: boolean): Promise<Cell | undefined>;
   /**
-   * Creates a CellOutput instance from a CellOutputLike object.
-   * This method supports automatic capacity calculation when outputData is provided and capacity is 0 or omitted.
+   * Resolve cell dependency info into concrete CellDep objects.
+   * If a CellDepInfo specifies a type script, the actual deployed cell is located on-chain.
    *
-   * @param cellOutput - A CellOutputLike object or an instance of CellOutput.
-   * @param outputData - Optional output data used for automatic capacity calculation.
-   *                     When provided and capacity is 0, the capacity will be calculated
-   *                     as occupiedSize + outputData.length.
-   * @returns A CellOutput instance.
+   * @param cellDepsInfoLike - One or more CellDepInfo or arrays of CellDepInfo.
+   * @returns Resolved CellDep array ready to be added to a transaction.
    *
    * @example
    * ```typescript
-   * // Basic usage with explicit capacity
-   * const cellOutput1 = CellOutput.from({
-   *   capacity: 1000n,
-   *   lock: { codeHash: "0x...", hashType: "type", args: "0x..." },
-   *   type: { codeHash: "0x...", hashType: "type", args: "0x..." }
-   * });
+   * import { ccc } from "@ckb-ccc/core";
    *
-   * // Automatic capacity calculation
-   * const cellOutput2 = CellOutput.from({
-   *   lock: { codeHash: "0x...", hashType: "type", args: "0x..." }
-   * }, "0x1234"); // Capacity will be calculated automatically
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const xudtInfo = await client.getKnownScript(ccc.KnownScript.XUdt);
+   * const cellDeps = await client.getCellDeps(xudtInfo.cellDeps);
+   * // cellDeps can be added to a transaction:
+   * // tx.cellDeps.push(...cellDeps);
    * ```
    */
-  static from(cellOutput: CellOutputLike, outputData?: HexLike | null): CellOutput;
+  getCellDeps(...cellDepsInfoLike: (CellDepInfoLike | CellDepInfoLike[])[]): Promise<CellDep[]>;
+  abstract findTransactionsPaged(key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
+    groupByTransaction: true;
+  }, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindTransactionsGroupedResponse>;
+  abstract findTransactionsPaged(key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
+    groupByTransaction?: false | null;
+  }, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindTransactionsResponse>;
+  abstract findTransactionsPaged(key: ClientIndexerSearchKeyTransactionLike, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindTransactionsResponse | ClientFindTransactionsGroupedResponse>;
+  findTransactions(key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
+    groupByTransaction: true;
+  }, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsGroupedResponse["transactions"][0]>;
+  findTransactions(key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
+    groupByTransaction?: false | null;
+  }, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0]>;
+  findTransactions(key: ClientIndexerSearchKeyTransactionLike, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0] | ClientFindTransactionsGroupedResponse["transactions"][0]>;
   /**
-   * Clone a CellOutput.
+   * Find transactions related to a lock script, optionally filtered by type script.
    *
-   * @returns A cloned CellOutput instance.
+   * @param lock - The lock script to search by.
+   * @param type - Optional type script filter.
+   * @param groupByTransaction - If true, group results by transaction.
+   * @param order - Sort order by block number.
+   * @param limit - Page size per RPC call.
+   * @returns An async generator yielding transaction records.
    *
    * @example
    * ```typescript
-   * const cellOutput1 = cellOutput0.clone();
-   * ```
-   */
-  clone(): CellOutput;
-}
-declare const CellOutputVec: Codec<CellOutputLike[], CellOutput[]>;
-/**
- * @public
- * Represents a cell-like object that may or may not be on-chain.
- * It can optionally have an `outPoint` (or `previousOutput`).
- * This is used as a flexible input for creating `CellAny` instances.
- * @see CellAny
- */
-type CellAnyLike = {
-  outPoint?: OutPointLike | null;
-  previousOutput?: OutPointLike | null;
-  cellOutput: CellOutputLike;
-  outputData?: HexLike | null;
-};
-/**
- * Represents a CKB cell that can be either on-chain (with an `outPoint`) or off-chain (without an `outPoint`).
- * This class provides a unified interface for handling cells before they are included in a transaction,
- * or for cells that are already part of the blockchain state.
- *
- * @public
- */
-declare class CellAny {
-  cellOutput: CellOutput;
-  outputData: Hex;
-  outPoint: OutPoint | undefined;
-  /**
-   * Creates an instance of CellAny.
+   * import { ccc } from "@ckb-ccc/core";
    *
-   * @param cellOutput - The cell output of the cell.
-   * @param outputData - The output data of the cell.
-   * @param outPoint - The optional output point of the cell. If provided, the cell is considered on-chain.
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const { script: lock } = await ccc.Address.fromString("ckt1q...", client);
+   *
+   * // List all transactions related to an address (grouped)
+   * for await (const txRecord of client.findTransactionsByLock(lock, null, true)) {
+   *   console.log(`TX: ${txRecord.txHash}, Block: ${txRecord.blockNumber}`);
+   * }
+   * ```
    */
-  constructor(cellOutput: CellOutput, outputData: Hex, outPoint?: OutPoint);
+  findTransactionsByLock(lock: ScriptLike, type: ScriptLike | undefined | null, groupByTransaction: true, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsGroupedResponse["transactions"][0]>;
+  findTransactionsByLock(lock: ScriptLike, type?: ScriptLike | null, groupByTransaction?: false | null, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0]>;
+  findTransactionsByLock(lock: ScriptLike, type?: ScriptLike | null, groupByTransaction?: boolean | null, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0] | ClientFindTransactionsGroupedResponse["transactions"][0]>;
+  findTransactionsByType(type: ScriptLike, groupByTransaction: true, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsGroupedResponse["transactions"][0]>;
+  findTransactionsByType(type: ScriptLike, groupByTransaction?: false | null, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0]>;
+  findTransactionsByType(type: ScriptLike, groupByTransaction?: boolean | null, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0] | ClientFindTransactionsGroupedResponse["transactions"][0]>;
+  abstract getCellsCapacity(key: ClientIndexerSearchKeyLike): Promise<Num>;
   /**
-   * Creates a `CellAny` instance from a `CellAnyLike` object.
-   * This factory method provides a convenient way to create `CellAny` instances
-   * from plain objects, automatically handling the optional `outPoint` or `previousOutput`.
+   * Get the total CKB balance of a single lock script.
+   * Only counts cells with no type script and no data (pure CKB capacity cells).
    *
-   * @param cell - A `CellAnyLike` object.
-   * @returns A new `CellAny` instance.
+   * @param lock - The lock script to query balance for.
+   * @returns The total capacity in Shannons as a bigint.
    *
    * @example
    * ```typescript
-   * // Create an off-chain cell (e.g., a new output)
-   * const offChainCell = CellAny.from({
-   *   cellOutput: { capacity: 1000n, lock: lockScript },
-   *   outputData: "0x"
-   * });
+   * import { ccc } from "@ckb-ccc/core";
    *
-   * // Create an on-chain cell from an input
-   * const onChainCell = CellAny.from({
-   *   outPoint: { txHash: "0x...", index: 0 },
-   *   cellOutput: { capacity: 2000n, lock: lockScript },
-   *   outputData: "0x1234"
-   * });
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const { script: lock } = await ccc.Address.fromString(
+   *   "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq...",
+   *   client,
+   * );
+   * const balance = await client.getBalanceSingle(lock);
+   * console.log(`Balance: ${ccc.fixedPointToString(balance)} CKB`);
    * ```
    */
-  static from(cell: CellAnyLike): CellAny;
+  getBalanceSingle(lock: ScriptLike): Promise<Num>;
   /**
-   * Calculates the total occupied size of the cell in bytes.
-   * This includes the size of the `CellOutput` structure plus the size of the `outputData`.
+   * Get the total CKB balance across multiple lock scripts.
+   * Sums the balance from each lock script.
    *
-   * @returns The total occupied size in bytes.
-   */
-  get occupiedSize(): number;
-  /**
-   * Calculates the free capacity of the cell.
-   * Free capacity is the total capacity minus the capacity occupied by the cell's structure and data.
+   * @param locks - An array of lock scripts to query.
+   * @returns The combined total capacity in Shannons as a bigint.
    *
-   * @returns The free capacity in shannons as a `Num`.
-   */
-  get capacityFree(): bigint;
-  /**
-   * Checks if the cell is a Nervos DAO cell and optionally checks its phase.
+   * @example
+   * ```typescript
+   * import { ccc } from "@ckb-ccc/core";
    *
-   * @param client - A CKB client instance to fetch known script information.
-   * @param phase - Optional phase to check: "deposited" or "withdrew".
-   *                If omitted, it checks if the cell is a DAO cell regardless of phase.
-   * @returns A promise that resolves to `true` if the cell is a matching Nervos DAO cell, `false` otherwise.
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const signer = new ccc.SignerCkbPrivateKey(client, "0x...");
+   * await signer.connect();
+   *
+   * const locks = await signer.getRecommendedAddressObj()
+   *   .then(({ script }) => [script]);
+   * const totalBalance = await client.getBalance(locks);
+   * console.log(`Total: ${ccc.fixedPointToString(totalBalance)} CKB`);
+   * ```
    */
-  isNervosDao(client: Client, phase?: "deposited" | "withdrew"): Promise<boolean>;
+  getBalance(locks: ScriptLike[]): Promise<Num>;
   /**
-   * Clones the `CellAny` instance.
+   * Send a signed transaction to the CKB network.
+   * Validates the fee rate against the maximum before sending.
    *
-   * @returns A new `CellAny` instance that is a deep copy of the current one.
+   * @param transaction - The transaction to send.
+   * @param validator - Optional outputs validator ("passthrough" or "well_known_scripts_only").
+   * @param options - Optional configuration including maxFeeRate.
+   * @returns The transaction hash.
    *
    * @example
    * ```typescript
-   * const clonedCell = cellAny.clone();
-   * ```
-   */
-  clone(): CellAny;
-}
-/**
- * Represents a cell-like object that is guaranteed to be on-chain.
- * It must have an `outPoint` (or its alias `previousOutput`).
- * This is used as a type constraint for creating `Cell` instances.
- * @see Cell
- * @public
- */
-type CellLike = CellAnyLike & ({
-  outPoint: OutPointLike;
-  previousOutput?: undefined | null;
-} | {
-  outPoint?: undefined | null;
-  previousOutput: OutPointLike;
-});
-/**
- * Represents an on-chain CKB cell, which is a `CellAny` that is guaranteed to have an `outPoint`.
- * This class is typically used for cells that are already part of the blockchain state, such as transaction inputs.
- * @public
- */
-declare class Cell extends CellAny {
-  outPoint: OutPoint;
-  /**
-   * Creates an instance of an on-chain Cell.
-   *
-   * @param outPoint - The output point of the cell.
-   * @param cellOutput - The cell output of the cell.
-   * @param outputData - The output data of the cell.
-   */
-  constructor(outPoint: OutPoint, cellOutput: CellOutput, outputData: Hex);
-  /**
-   * Creates a Cell instance from a CellLike object.
-   * This method accepts either `outPoint` or `previousOutput` to specify the cell's location,
-   * and supports automatic capacity calculation for the cell output.
+   * import { ccc } from "@ckb-ccc/core";
    *
-   * @param cell - A CellLike object or an instance of Cell. The object can use either:
-   *               - `outPoint`: For referencing a cell output
-   *               - `previousOutput`: For referencing a cell input (alternative name for outPoint)
-   *               The cellOutput can omit capacity for automatic calculation.
-   * @returns A Cell instance.
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const signer = new ccc.SignerCkbPrivateKey(client, "0x...");
+   * await signer.connect();
    *
-   * @example
-   * ```typescript
-   * // Using outPoint with explicit capacity
-   * const cell1 = Cell.from({
-   *   outPoint: { txHash: "0x...", index: 0 },
-   *   cellOutput: {
-   *     capacity: 1000n,
-   *     lock: { codeHash: "0x...", hashType: "type", args: "0x..." }
-   *   },
-   *   outputData: "0x"
+   * const tx = ccc.Transaction.from({
+   *   outputs: [{ capacity: ccc.fixedPointFrom(100), lock: receiverLock }],
    * });
+   * await tx.completeInputsByCapacity(signer);
+   * await tx.completeFeeBy(signer);
    *
-   * // Using previousOutput with automatic capacity calculation
-   * const cell2 = Cell.from({
-   *   previousOutput: { txHash: "0x...", index: 0 },
-   *   cellOutput: {
-   *     lock: { codeHash: "0x...", hashType: "type", args: "0x..." }
-   *     // capacity will be calculated automatically
-   *   },
-   *   outputData: "0x1234"
-   * });
+   * // Usually you call signer.sendTransaction(tx) which signs then sends.
+   * // client.sendTransaction expects an already-signed transaction.
+   * const txHash = await client.sendTransaction(tx);
    * ```
    */
-  static from(cell: CellLike): Cell;
+  sendTransaction(transaction: TransactionLike, validator?: OutputsValidator, options?: {
+    maxFeeRate?: NumLike;
+  }): Promise<Hex>;
   /**
-   * Gets confirmed Nervos DAO profit of a Cell
-   * It returns non-zero value only when the cell is in withdrawal phase 2
-   * See https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0023-dao-deposit-withdraw/0023-dao-deposit-withdraw.md
+   * Get a transaction by its hash, including its status and block info.
    *
-   * @param client - A client for searching DAO related headers
-   * @returns Profit
+   * @param txHashLike - The transaction hash to look up.
+   * @returns The transaction response with status, or undefined if not found.
    *
    * @example
    * ```typescript
-   * const profit = await cell.getDaoProfit(client);
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * const txResponse = await client.getTransaction("0xTX_HASH...");
+   * if (txResponse) {
+   *   console.log(`Status: ${txResponse.status}`);
+   *   console.log(`Block: ${txResponse.blockNumber}`);
+   *   console.log(`Outputs: ${txResponse.transaction.outputs.length}`);
+   * }
    * ```
    */
-  getDaoProfit(client: Client): Promise<Num>;
+  getTransaction(txHashLike: HexLike): Promise<ClientTransactionResponse | undefined>;
   /**
-   * Retrieves detailed information about a Nervos DAO cell, including its deposit and withdrawal headers.
-   *
-   * @param client - A CKB client instance to fetch cell and header data.
-   * @returns A promise that resolves to an object containing header information.
-   *          - If not a DAO cell, returns `{}`.
-   *          - If a deposited DAO cell, returns `{ depositHeader }`.
-   *          - If a withdrawn DAO cell, returns `{ depositHeader, withdrawHeader }`.
-   *
-   * @throws If the cell is a DAO cell but its corresponding headers cannot be fetched.
-   *
-   * @example
-   * ```typescript
-   * const daoInfo = await cell.getNervosDaoInfo(client);
-   * ```
+   * This method gets specified transaction with its block header (if existed).
+   * This is mainly for caching because we need the header to test if we can safely trust the cached tx status.
+   * @param txHashLike
    */
-  getNervosDaoInfo(client: Client): Promise<{
-    depositHeader?: undefined;
-    withdrawHeader?: undefined;
-  } | {
-    depositHeader: ClientBlockHeader;
-    withdrawHeader?: undefined;
-  } | {
-    depositHeader: ClientBlockHeader;
-    withdrawHeader: ClientBlockHeader;
-  }>;
+  getTransactionWithHeader(txHashLike: HexLike): Promise<{
+    transaction: ClientTransactionResponse;
+    header?: ClientBlockHeader;
+  } | undefined>;
   /**
-   * Clone a Cell
+   * Wait for a transaction to be confirmed on-chain.
+   * Polls the node until the transaction reaches the specified confirmation depth.
    *
-   * @returns A cloned Cell instance.
+   * @param txHash - The transaction hash to wait for.
+   * @param confirmations - Number of block confirmations to wait for (default: 0 = committed).
+   * @param timeout - Maximum wait time in milliseconds (default: 60000).
+   * @param interval - Polling interval in milliseconds (default: 2000).
+   * @returns The transaction response once confirmed, or throws on timeout.
    *
    * @example
    * ```typescript
-   * const cell1 = cell0.clone();
+   * import { ccc } from "@ckb-ccc/core";
+   *
+   * const clientOwner = ccc.ClientPublicTestnet.open();
+   * const client = clientOwner.value;
+   * // Call `await clientOwner.dispose()` when the client is no longer needed.
+   * // Wait for transaction to be committed (0 confirmations)
+   * const tx = await client.waitTransaction("0xTX_HASH...");
+   * console.log(`Confirmed in block: ${tx?.blockNumber}`);
+   *
+   * // Wait for 4 confirmations with 2 minute timeout
+   * const confirmedTx = await client.waitTransaction(
+   *   "0xTX_HASH...",
+   *   4,       // confirmations
+   *   120000,  // timeout: 2 minutes
+   * );
    * ```
    */
-  clone(): Cell;
+  waitTransaction(txHash: HexLike, confirmations?: number, timeout?: number, interval?: number): Promise<ClientTransactionResponse | undefined>;
 }
+//#endregion
+//#region src/ckb/script.d.ts
+declare const HashTypeCodec: Codec<HashTypeLike, HashType>;
 /**
  * @public
  */
-type SinceLike = {
-  relative: "absolute" | "relative";
-  metric: "blockNumber" | "epoch" | "timestamp";
-  value: NumLike;
-} | NumLike;
-declare const Since_base: (abstract new () => {
+type HashTypeLike = string | number | bigint;
+/**
+ * @public
+ */
+type HashType = "type" | "data" | "data1" | "data2";
+/**
+ * Converts a HashTypeLike value to a HashType.
+ * @public
+ *
+ * @param val - The value to convert, which can be a string, number, or bigint.
+ * @returns The corresponding HashType.
+ *
+ * @throws Will throw an error if the input value is not a valid hash type.
+ *
+ * @example
+ * ```typescript
+ * const hashType = hashTypeFrom(1); // Outputs "data"
+ * const hashType = hashTypeFrom("type"); // Outputs "type"
+ * ```
+ */
+declare function hashTypeFrom(val: HashTypeLike): HashType;
+/**
+ * Converts a HashTypeLike value to its corresponding byte representation.
+ * @public
+ *
+ * @param hashType - The hash type value to convert.
+ * @returns A Uint8Array containing the byte representation of the hash type.
+ *
+ * @example
+ * ```typescript
+ * const hashTypeBytes = hashTypeToBytes("type"); // Outputs Uint8Array [0]
+ * ```
+ */
+declare function hashTypeToBytes(hashType: HashTypeLike): Bytes$1;
+/**
+ * Converts a byte-like value to a HashType.
+ * @public
+ *
+ * @param bytes - The byte-like value to convert.
+ * @returns The corresponding HashType.
+ *
+ * @throws Will throw an error if the input bytes do not correspond to a valid hash type.
+ *
+ * @example
+ * ```typescript
+ * const hashType = hashTypeFromBytes(new Uint8Array([0])); // Outputs "type"
+ * ```
+ */
+declare function hashTypeFromBytes(bytes: BytesLike): HashType;
+/**
+ * @public
+ */
+type ScriptLike = {
+  codeHash: BytesLike;
+  hashType: HashTypeLike;
+  args: BytesLike;
+};
+declare const Script_base: (abstract new () => {
   toBytes(): Bytes$1;
-  clone(): Since;
-  eq(other: SinceLike): boolean;
+  clone(): Script;
+  eq(other: ScriptLike): boolean;
   hash(): Hex;
   toHex(): Hex;
 }) & {
   byteLength?: number;
-  encode(_: SinceLike): Bytes$1;
-  decode(_: BytesLike): Since;
-  fromBytes(_bytes: BytesLike): Since;
-  from(_: SinceLike): Since;
+  encode(_: ScriptLike): Bytes$1;
+  decode(_: BytesLike): Script;
+  fromBytes(_bytes: BytesLike): Script;
+  from(_: ScriptLike): Script;
   Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
     toBytes(): Bytes$1;
     clone(): SubType;
@@ -4627,89 +4711,182 @@ declare const Since_base: (abstract new () => {
 /**
  * @public
  */
-declare class Since extends Since_base {
-  relative: "absolute" | "relative";
-  metric: "blockNumber" | "epoch" | "timestamp";
-  value: Num;
+declare class Script extends Script_base {
+  codeHash: Hex;
+  hashType: HashType;
+  args: Hex;
   /**
-   * Creates an instance of Since.
+   * Creates an instance of Script.
    *
-   * @param relative - Absolute or relative
-   * @param metric - The metric of since
-   * @param value - The value of since
+   * @param codeHash - The code hash of the script.
+   * @param hashType - The hash type of the script.
+   * @param args - The arguments for the script.
    */
-  constructor(relative: "absolute" | "relative", metric: "blockNumber" | "epoch" | "timestamp", value: Num);
+  constructor(codeHash: Hex, hashType: HashType, args: Hex);
+  get occupiedSize(): number;
   /**
-   * Clone a Since.
+   * Clone a script.
    *
-   * @returns A cloned Since instance.
+   * @returns A cloned Script instance.
    *
    * @example
    * ```typescript
-   * const since1 = since0.clone();
+   * const script1 = script0.clone();
    * ```
    */
-  clone(): Since;
+  clone(): Script;
   /**
-   * Creates a Since instance from a SinceLike object.
-   *
-   * @param since - A SinceLike object or an instance of Since.
-   * @returns A Since instance.
+   * Check if the script is equal to another script.
+   * @public
+   * @param other - The other script to compare with
+   * @returns True if the scripts are equal, false otherwise
    *
    * @example
    * ```typescript
-   * const since = Since.from("0x1234567812345678");
+   * const isEqual = script0.eq(script1);
    * ```
    */
-  static from(since: SinceLike): Since;
+  eq(other: ScriptLike): boolean;
   /**
-   * Converts the Since instance to num.
+   * Creates a Script instance from a ScriptLike object.
    *
-   * @returns A num
+   * @param script - A ScriptLike object or an instance of Script.
+   * @returns A Script instance.
    *
    * @example
    * ```typescript
-   * const num = since.toNum();
+   * const script = Script.from({
+   *   codeHash: "0x1234...",
+   *   hashType: "type",
+   *   args: "0xabcd..."
+   * });
    * ```
    */
-  toNum(): Num;
+  static from(script: ScriptLike): Script;
   /**
-   * Creates a Since instance from a num-like value.
+   * Creates a Script instance from client and known script.
    *
-   * @param numLike - The num-like value to convert.
-   * @returns A Since instance.
+   * @param knownScript - A KnownScript enum.
+   * @param args - Args for the script.
+   * @param client - A ScriptLike object or an instance of Script.
+   * @returns A promise that resolves to the script instance.
    *
    * @example
    * ```typescript
-   * const since = Since.fromNum("0x0");
+   * const script = await Script.fromKnownScript(
+   *   client,
+   *   KnownScript.XUdt,
+   *   args: "0xabcd..."
+   * );
    * ```
    */
-  static fromNum(numLike: NumLike): Since;
+  static fromKnownScript(client: Client, knownScript: KnownScript, args: HexLike): Promise<Script>;
+}
+declare const ScriptOpt: Codec<ScriptLike | null | undefined, Script | undefined>;
+declare const ScriptVec: Codec<ScriptLike[], Script[]>;
+//#endregion
+//#region src/ckb/transactionLumos.d.ts
+interface LumosTransactionSkeletonType {
+  cellDeps: {
+    toArray(): CellDepLike[];
+  };
+  headerDeps: {
+    toArray(): HexLike[];
+  };
+  inputs: {
+    toArray(): {
+      outPoint?: OutPointLike;
+      cellOutput: CellOutputLike;
+      data: HexLike;
+    }[];
+  };
+  inputSinces: {
+    get(i: number, defaultVal: string): HexLike;
+  };
+  outputs: {
+    toArray(): {
+      cellOutput: CellOutputLike;
+      data: HexLike;
+    }[];
+  };
+  witnesses: {
+    toArray(): HexLike[];
+  };
 }
+//#endregion
+//#region src/ckb/transaction.d.ts
+declare const DepTypeCodec: Codec<DepTypeLike, DepType>;
 /**
  * @public
  */
-type CellInputLike = ({
-  previousOutput: OutPointLike;
-} | {
-  outPoint: OutPointLike;
-}) & {
-  since?: SinceLike | NumLike | null;
-  cellOutput?: CellOutputLike | null;
-  outputData?: HexLike | null;
+type DepTypeLike = string | number | bigint;
+/**
+ * @public
+ */
+type DepType = "depGroup" | "code";
+/**
+ * Converts a DepTypeLike value to a DepType.
+ * @public
+ *
+ * @param val - The value to convert, which can be a string, number, or bigint.
+ * @returns The corresponding DepType.
+ *
+ * @throws Will throw an error if the input value is not a valid dep type.
+ *
+ * @example
+ * ```typescript
+ * const depType = depTypeFrom(1); // Outputs "code"
+ * const depType = depTypeFrom("depGroup"); // Outputs "depGroup"
+ * ```
+ */
+declare function depTypeFrom(val: DepTypeLike): DepType;
+/**
+ * Converts a DepTypeLike value to its corresponding byte representation.
+ * @public
+ *
+ * @param depType - The dep type value to convert.
+ * @returns A Uint8Array containing the byte representation of the dep type.
+ *
+ * @example
+ * ```typescript
+ * const depTypeBytes = depTypeToBytes("code"); // Outputs Uint8Array [1]
+ * ```
+ */
+declare function depTypeToBytes(depType: DepTypeLike): Bytes$1;
+/**
+ * Converts a byte-like value to a DepType.
+ * @public
+ *
+ * @param bytes - The byte-like value to convert.
+ * @returns The corresponding DepType.
+ *
+ * @throws Will throw an error if the input bytes do not correspond to a valid dep type.
+ *
+ * @example
+ * ```typescript
+ * const depType = depTypeFromBytes(new Uint8Array([1])); // Outputs "code"
+ * ```
+ */
+declare function depTypeFromBytes(bytes: BytesLike): DepType;
+/**
+ * @public
+ */
+type OutPointLike = {
+  txHash: HexLike;
+  index: NumLike;
 };
-declare const CellInput_base: (abstract new () => {
+declare const OutPoint_base: (abstract new () => {
   toBytes(): Bytes$1;
-  clone(): CellInput;
-  eq(other: CellInputLike): boolean;
+  clone(): OutPoint;
+  eq(other: OutPointLike): boolean;
   hash(): Hex;
   toHex(): Hex;
 }) & {
   byteLength?: number;
-  encode(_: CellInputLike): Bytes$1;
-  decode(_: BytesLike): CellInput;
-  fromBytes(_bytes: BytesLike): CellInput;
-  from(_: CellInputLike): CellInput;
+  encode(_: OutPointLike): Bytes$1;
+  decode(_: BytesLike): OutPoint;
+  fromBytes(_bytes: BytesLike): OutPoint;
+  from(_: OutPointLike): OutPoint;
   Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
     toBytes(): Bytes$1;
     clone(): SubType;
@@ -4786,87 +4963,72 @@ declare const CellInput_base: (abstract new () => {
 /**
  * @public
  */
-declare class CellInput extends CellInput_base {
-  previousOutput: OutPoint;
-  since: Num;
-  cellOutput?: CellOutput | undefined;
-  outputData?: Hex | undefined;
+declare class OutPoint extends OutPoint_base {
+  txHash: Hex;
+  index: Num;
   /**
-   * Creates an instance of CellInput.
+   * Creates an instance of OutPoint.
    *
-   * @param previousOutput - The previous outpoint of the cell.
-   * @param since - The since value of the cell input.
-   * @param cellOutput - The optional cell output associated with the cell input.
-   * @param outputData - The optional output data associated with the cell input.
+   * @param txHash - The transaction hash.
+   * @param index - The index of the output in the transaction.
    */
-  constructor(previousOutput: OutPoint, since: Num, cellOutput?: CellOutput | undefined, outputData?: Hex | undefined);
+  constructor(txHash: Hex, index: Num);
   /**
-   * Creates a CellInput instance from a CellInputLike object.
+   * Creates an OutPoint instance from an OutPointLike object.
    *
-   * @param cellInput - A CellInputLike object or an instance of CellInput.
-   * @returns A CellInput instance.
+   * @param outPoint - An OutPointLike object or an instance of OutPoint.
+   * @returns An OutPoint instance.
    *
    * @example
    * ```typescript
-   * const cellInput = CellInput.from({
-   *   previousOutput: { txHash: "0x...", index: 0 },
-   *   since: 0n
-   * });
+   * const outPoint = OutPoint.from({ txHash: "0x...", index: 0 });
    * ```
    */
-  static from(cellInput: CellInputLike): CellInput;
-  getCell(client: Client): Promise<Cell>;
+  static from(outPoint: OutPointLike): OutPoint;
   /**
-   * Complete extra infos in the input. Including
-   * - Previous cell output
-   * - Previous cell data
-   * The instance will be modified.
+   * Clone a OutPoint.
+   *
+   * @returns A cloned OutPoint instance.
    *
-   * @returns true if succeed.
    * @example
    * ```typescript
-   * await cellInput.completeExtraInfos(client);
+   * const outPoint1 = outPoint0.clone();
    * ```
    */
-  completeExtraInfos(client: Client): Promise<void>;
-  /**
-   * The extra capacity created when consume this input.
-   * This is usually NervosDAO interest, see https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0023-dao-deposit-withdraw/0023-dao-deposit-withdraw.md.
-   * And it can also be miners' income. (But this is not implemented yet)
-   */
-  getExtraCapacity(client: Client): Promise<Num>;
+  clone(): OutPoint;
   /**
-   * Clone a CellInput.
-   *
-   * @returns A cloned CellInput instance.
+   * Check if the OutPoint is equal to another OutPoint.
+   * @public
+   * @param other - The other OutPoint to compare with
+   * @returns True if the OutPoints are equal, false otherwise
    *
    * @example
    * ```typescript
-   * const cellInput1 = cellInput0.clone();
+   * const isEqual = outPoint0.eq(outPoint1);
    * ```
    */
-  clone(): CellInput;
+  eq(other: OutPointLike): boolean;
 }
-declare const CellInputVec: Codec<CellInputLike[], CellInput[]>;
 /**
  * @public
  */
-type CellDepLike = {
-  outPoint: OutPointLike;
-  depType: DepTypeLike;
+type CellOutputLike = {
+  capacity?: NumLike | null;
+  lock: ScriptLike;
+  type?: ScriptLike | null;
 };
-declare const CellDep_base: (abstract new () => {
+declare const CellOutput_base: (abstract new () => {
   toBytes(): Bytes$1;
-  clone(): CellDep;
-  eq(other: CellDepLike): boolean;
+  clone(): CellOutput;
+  eq(other: CellOutputLike): boolean;
   hash(): Hex;
   toHex(): Hex;
 }) & {
   byteLength?: number;
-  encode(_: CellDepLike): Bytes$1;
-  decode(_: BytesLike): CellDep;
-  fromBytes(_bytes: BytesLike): CellDep;
-  from(_: CellDepLike): CellDep;
+  encode(_: CellOutputLike): Bytes$1;
+  decode(_: BytesLike): CellOutput;
+  fromBytes(_bytes: BytesLike): CellOutput;
+  from(_: CellOutputLike): CellOutput;
   Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
     toBytes(): Bytes$1;
     clone(): SubType;
@@ -4943,64 +5105,286 @@ declare const CellDep_base: (abstract new () => {
 /**
  * @public
  */
-declare class CellDep extends CellDep_base {
-  outPoint: OutPoint;
-  depType: DepType;
+declare class CellOutput extends CellOutput_base {
+  capacity: Num;
+  lock: Script;
+  type?: Script | undefined;
   /**
-   * Creates an instance of CellDep.
+   * Creates an instance of CellOutput.
    *
-   * @param outPoint - The outpoint of the cell dependency.
-   * @param depType - The dependency type.
+   * @param capacity - The capacity of the cell.
+   * @param lock - The lock script of the cell.
+   * @param type - The optional type script of the cell.
    */
-  constructor(outPoint: OutPoint, depType: DepType);
+  constructor(capacity: Num, lock: Script, type?: Script | undefined);
+  get occupiedSize(): number;
   /**
-   * Creates a CellDep instance from a CellDepLike object.
+   * Creates a CellOutput instance from a CellOutputLike object.
+   * This method supports automatic capacity calculation when outputData is provided and capacity is 0 or omitted.
    *
-   * @param cellDep - A CellDepLike object or an instance of CellDep.
-   * @returns A CellDep instance.
+   * @param cellOutput - A CellOutputLike object or an instance of CellOutput.
+   * @param outputData - Optional output data used for automatic capacity calculation.
+   *                     When provided and capacity is 0, the capacity will be calculated
+   *                     as occupiedSize + outputData.length.
+   * @returns A CellOutput instance.
    *
    * @example
    * ```typescript
-   * const cellDep = CellDep.from({
-   *   outPoint: { txHash: "0x...", index: 0 },
-   *   depType: "depGroup"
+   * // Basic usage with explicit capacity
+   * const cellOutput1 = CellOutput.from({
+   *   capacity: 1000n,
+   *   lock: { codeHash: "0x...", hashType: "type", args: "0x..." },
+   *   type: { codeHash: "0x...", hashType: "type", args: "0x..." }
    * });
+   *
+   * // Automatic capacity calculation
+   * const cellOutput2 = CellOutput.from({
+   *   lock: { codeHash: "0x...", hashType: "type", args: "0x..." }
+   * }, "0x1234"); // Capacity will be calculated automatically
    * ```
    */
-  static from(cellDep: CellDepLike): CellDep;
+  static from(cellOutput: CellOutputLike, outputData?: HexLike | null): CellOutput;
   /**
-   * Clone a CellDep.
+   * Clone a CellOutput.
    *
-   * @returns A cloned CellDep instance.
+   * @returns A cloned CellOutput instance.
    *
    * @example
    * ```typescript
-   * const cellDep1 = cellDep0.clone();
+   * const cellOutput1 = cellOutput0.clone();
    * ```
    */
-  clone(): CellDep;
+  clone(): CellOutput;
 }
-declare const CellDepVec: Codec<CellDepLike[], CellDep[]>;
+declare const CellOutputVec: Codec<CellOutputLike[], CellOutput[]>;
 /**
  * @public
+ * Represents a cell-like object that may or may not be on-chain.
+ * It can optionally have an `outPoint` (or `previousOutput`).
+ * This is used as a flexible input for creating `CellAny` instances.
+ * @see CellAny
  */
-type WitnessArgsLike = {
-  lock?: HexLike | null;
-  inputType?: HexLike | null;
-  outputType?: HexLike | null;
+type CellAnyLike = {
+  outPoint?: OutPointLike | null;
+  previousOutput?: OutPointLike | null;
+  cellOutput: CellOutputLike;
+  outputData?: HexLike | null;
 };
-declare const WitnessArgs_base: (abstract new () => {
+/**
+ * Represents a CKB cell that can be either on-chain (with an `outPoint`) or off-chain (without an `outPoint`).
+ * This class provides a unified interface for handling cells before they are included in a transaction,
+ * or for cells that are already part of the blockchain state.
+ *
+ * @public
+ */
+declare class CellAny {
+  cellOutput: CellOutput;
+  outputData: Hex;
+  outPoint: OutPoint | undefined;
+  /**
+   * Creates an instance of CellAny.
+   *
+   * @param cellOutput - The cell output of the cell.
+   * @param outputData - The output data of the cell.
+   * @param outPoint - The optional output point of the cell. If provided, the cell is considered on-chain.
+   */
+  constructor(cellOutput: CellOutput, outputData: Hex, outPoint?: OutPoint);
+  /**
+   * Creates a `CellAny` instance from a `CellAnyLike` object.
+   * This factory method provides a convenient way to create `CellAny` instances
+   * from plain objects, automatically handling the optional `outPoint` or `previousOutput`.
+   *
+   * @param cell - A `CellAnyLike` object.
+   * @returns A new `CellAny` instance.
+   *
+   * @example
+   * ```typescript
+   * // Create an off-chain cell (e.g., a new output)
+   * const offChainCell = CellAny.from({
+   *   cellOutput: { capacity: 1000n, lock: lockScript },
+   *   outputData: "0x"
+   * });
+   *
+   * // Create an on-chain cell from an input
+   * const onChainCell = CellAny.from({
+   *   outPoint: { txHash: "0x...", index: 0 },
+   *   cellOutput: { capacity: 2000n, lock: lockScript },
+   *   outputData: "0x1234"
+   * });
+   * ```
+   */
+  static from(cell: CellAnyLike): CellAny;
+  /**
+   * Calculates the total occupied size of the cell in bytes.
+   * This includes the size of the `CellOutput` structure plus the size of the `outputData`.
+   *
+   * @returns The total occupied size in bytes.
+   */
+  get occupiedSize(): number;
+  /**
+   * Calculates the free capacity of the cell.
+   * Free capacity is the total capacity minus the capacity occupied by the cell's structure and data.
+   *
+   * @returns The free capacity in shannons as a `Num`.
+   */
+  get capacityFree(): bigint;
+  /**
+   * Checks if the cell is a Nervos DAO cell and optionally checks its phase.
+   *
+   * @param client - A CKB client instance to fetch known script information.
+   * @param phase - Optional phase to check: "deposited" or "withdrew".
+   *                If omitted, it checks if the cell is a DAO cell regardless of phase.
+   * @returns A promise that resolves to `true` if the cell is a matching Nervos DAO cell, `false` otherwise.
+   */
+  isNervosDao(client: Client, phase?: "deposited" | "withdrew"): Promise<boolean>;
+  /**
+   * Clones the `CellAny` instance.
+   *
+   * @returns A new `CellAny` instance that is a deep copy of the current one.
+   *
+   * @example
+   * ```typescript
+   * const clonedCell = cellAny.clone();
+   * ```
+   */
+  clone(): CellAny;
+}
+/**
+ * Represents a cell-like object that is guaranteed to be on-chain.
+ * It must have an `outPoint` (or its alias `previousOutput`).
+ * This is used as a type constraint for creating `Cell` instances.
+ * @see Cell
+ * @public
+ */
+type CellLike = CellAnyLike & ({
+  outPoint: OutPointLike;
+  previousOutput?: undefined | null;
+} | {
+  outPoint?: undefined | null;
+  previousOutput: OutPointLike;
+});
+/**
+ * Represents an on-chain CKB cell, which is a `CellAny` that is guaranteed to have an `outPoint`.
+ * This class is typically used for cells that are already part of the blockchain state, such as transaction inputs.
+ * @public
+ */
+declare class Cell extends CellAny {
+  outPoint: OutPoint;
+  /**
+   * Creates an instance of an on-chain Cell.
+   *
+   * @param outPoint - The output point of the cell.
+   * @param cellOutput - The cell output of the cell.
+   * @param outputData - The output data of the cell.
+   */
+  constructor(outPoint: OutPoint, cellOutput: CellOutput, outputData: Hex);
+  /**
+   * Creates a Cell instance from a CellLike object.
+   * This method accepts either `outPoint` or `previousOutput` to specify the cell's location,
+   * and supports automatic capacity calculation for the cell output.
+   *
+   * @param cell - A CellLike object or an instance of Cell. The object can use either:
+   *               - `outPoint`: For referencing a cell output
+   *               - `previousOutput`: For referencing a cell input (alternative name for outPoint)
+   *               The cellOutput can omit capacity for automatic calculation.
+   * @returns A Cell instance.
+   *
+   * @example
+   * ```typescript
+   * // Using outPoint with explicit capacity
+   * const cell1 = Cell.from({
+   *   outPoint: { txHash: "0x...", index: 0 },
+   *   cellOutput: {
+   *     capacity: 1000n,
+   *     lock: { codeHash: "0x...", hashType: "type", args: "0x..." }
+   *   },
+   *   outputData: "0x"
+   * });
+   *
+   * // Using previousOutput with automatic capacity calculation
+   * const cell2 = Cell.from({
+   *   previousOutput: { txHash: "0x...", index: 0 },
+   *   cellOutput: {
+   *     lock: { codeHash: "0x...", hashType: "type", args: "0x..." }
+   *     // capacity will be calculated automatically
+   *   },
+   *   outputData: "0x1234"
+   * });
+   * ```
+   */
+  static from(cell: CellLike): Cell;
+  /**
+   * Gets confirmed Nervos DAO profit of a Cell
+   * It returns non-zero value only when the cell is in withdrawal phase 2
+   * See https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0023-dao-deposit-withdraw/0023-dao-deposit-withdraw.md
+   *
+   * @param client - A client for searching DAO related headers
+   * @returns Profit
+   *
+   * @example
+   * ```typescript
+   * const profit = await cell.getDaoProfit(client);
+   * ```
+   */
+  getDaoProfit(client: Client): Promise<Num>;
+  /**
+   * Retrieves detailed information about a Nervos DAO cell, including its deposit and withdrawal headers.
+   *
+   * @param client - A CKB client instance to fetch cell and header data.
+   * @returns A promise that resolves to an object containing header information.
+   *          - If not a DAO cell, returns `{}`.
+   *          - If a deposited DAO cell, returns `{ depositHeader }`.
+   *          - If a withdrawn DAO cell, returns `{ depositHeader, withdrawHeader }`.
+   *
+   * @throws If the cell is a DAO cell but its corresponding headers cannot be fetched.
+   *
+   * @example
+   * ```typescript
+   * const daoInfo = await cell.getNervosDaoInfo(client);
+   * ```
+   */
+  getNervosDaoInfo(client: Client): Promise<{
+    depositHeader?: undefined;
+    withdrawHeader?: undefined;
+  } | {
+    depositHeader: ClientBlockHeader;
+    withdrawHeader?: undefined;
+  } | {
+    depositHeader: ClientBlockHeader;
+    withdrawHeader: ClientBlockHeader;
+  }>;
+  /**
+   * Clone a Cell
+   *
+   * @returns A cloned Cell instance.
+   *
+   * @example
+   * ```typescript
+   * const cell1 = cell0.clone();
+   * ```
+   */
+  clone(): Cell;
+}
+/**
+ * @public
+ */
+type SinceLike = {
+  relative: "absolute" | "relative";
+  metric: "blockNumber" | "epoch" | "timestamp";
+  value: NumLike;
+} | NumLike;
+declare const Since_base: (abstract new () => {
   toBytes(): Bytes$1;
-  clone(): WitnessArgs;
-  eq(other: WitnessArgsLike): boolean;
+  clone(): Since;
+  eq(other: SinceLike): boolean;
   hash(): Hex;
   toHex(): Hex;
 }) & {
   byteLength?: number;
-  encode(_: WitnessArgsLike): Bytes$1;
-  decode(_: BytesLike): WitnessArgs;
-  fromBytes(_bytes: BytesLike): WitnessArgs;
-  from(_: WitnessArgsLike): WitnessArgs;
+  encode(_: SinceLike): Bytes$1;
+  decode(_: BytesLike): Since;
+  fromBytes(_bytes: BytesLike): Since;
+  from(_: SinceLike): Since;
   Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
     toBytes(): Bytes$1;
     clone(): SubType;
@@ -5077,80 +5461,89 @@ declare const WitnessArgs_base: (abstract new () => {
 /**
  * @public
  */
-declare class WitnessArgs extends WitnessArgs_base {
-  lock?: Hex | undefined;
-  inputType?: Hex | undefined;
-  outputType?: Hex | undefined;
+declare class Since extends Since_base {
+  relative: "absolute" | "relative";
+  metric: "blockNumber" | "epoch" | "timestamp";
+  value: Num;
   /**
-   * Creates an instance of WitnessArgs.
+   * Creates an instance of Since.
    *
-   * @param lock - The optional lock field of the witness.
-   * @param inputType - The optional input type field of the witness.
-   * @param outputType - The optional output type field of the witness.
+   * @param relative - Absolute or relative
+   * @param metric - The metric of since
+   * @param value - The value of since
    */
-  constructor(lock?: Hex | undefined, inputType?: Hex | undefined, outputType?: Hex | undefined);
+  constructor(relative: "absolute" | "relative", metric: "blockNumber" | "epoch" | "timestamp", value: Num);
   /**
-   * Creates a WitnessArgs instance from a WitnessArgsLike object.
+   * Clone a Since.
    *
-   * @param witnessArgs - A WitnessArgsLike object or an instance of WitnessArgs.
-   * @returns A WitnessArgs instance.
+   * @returns A cloned Since instance.
    *
    * @example
    * ```typescript
-   * const witnessArgs = WitnessArgs.from({
-   *   lock: "0x...",
-   *   inputType: "0x...",
-   *   outputType: "0x..."
-   * });
+   * const since1 = since0.clone();
    * ```
    */
-  static from(witnessArgs: WitnessArgsLike): WitnessArgs;
+  clone(): Since;
+  /**
+   * Creates a Since instance from a SinceLike object.
+   *
+   * @param since - A SinceLike object or an instance of Since.
+   * @returns A Since instance.
+   *
+   * @example
+   * ```typescript
+   * const since = Since.from("0x1234567812345678");
+   * ```
+   */
+  static from(since: SinceLike): Since;
+  /**
+   * Converts the Since instance to num.
+   *
+   * @returns A num
+   *
+   * @example
+   * ```typescript
+   * const num = since.toNum();
+   * ```
+   */
+  toNum(): Num;
+  /**
+   * Creates a Since instance from a num-like value.
+   *
+   * @param numLike - The num-like value to convert.
+   * @returns A Since instance.
+   *
+   * @example
+   * ```typescript
+   * const since = Since.fromNum("0x0");
+   * ```
+   */
+  static fromNum(numLike: NumLike): Since;
 }
-/**
- * Convert a bytes to a num.
- *
- * @public
- */
-declare function udtBalanceFrom(dataLike: BytesLike): Num;
-declare const RawTransaction: Codec<EncodableRecord<{
-  version: Codec<NumLike, number>;
-  cellDeps: Codec<CellDepLike[], CellDep[]>;
-  headerDeps: Codec<BytesLike[], `0x${string}`[]>;
-  inputs: Codec<CellInputLike[], CellInput[]>;
-  outputs: Codec<CellOutputLike[], CellOutput[]>;
-  outputsData: Codec<BytesLike[], `0x${string}`[]>;
-}>, DecodedRecord<{
-  version: Codec<NumLike, number>;
-  cellDeps: Codec<CellDepLike[], CellDep[]>;
-  headerDeps: Codec<BytesLike[], `0x${string}`[]>;
-  inputs: Codec<CellInputLike[], CellInput[]>;
-  outputs: Codec<CellOutputLike[], CellOutput[]>;
-  outputsData: Codec<BytesLike[], `0x${string}`[]>;
-}>>;
 /**
  * @public
  */
-type TransactionLike = {
-  version?: NumLike | null;
-  cellDeps?: CellDepLike[] | null;
-  headerDeps?: HexLike[] | null;
-  inputs?: CellInputLike[] | null;
-  outputs?: (Omit<CellOutputLike, "capacity"> & Partial<Pick<CellOutputLike, "capacity">>)[] | null;
-  outputsData?: HexLike[] | null;
-  witnesses?: HexLike[] | null;
+type CellInputLike = ({
+  previousOutput: OutPointLike;
+} | {
+  outPoint: OutPointLike;
+}) & {
+  since?: SinceLike | NumLike | null;
+  cellOutput?: CellOutputLike | null;
+  outputData?: HexLike | null;
 };
-declare const Transaction_base: (abstract new () => {
+declare const CellInput_base: (abstract new () => {
   toBytes(): Bytes$1;
-  clone(): Transaction;
-  eq(other: TransactionLike): boolean;
+  clone(): CellInput;
+  eq(other: CellInputLike): boolean;
   hash(): Hex;
   toHex(): Hex;
 }) & {
   byteLength?: number;
-  encode(_: TransactionLike): Bytes$1;
-  decode(_: BytesLike): Transaction;
-  fromBytes(_bytes: BytesLike): Transaction;
-  from(_: TransactionLike): Transaction;
+  encode(_: CellInputLike): Bytes$1;
+  decode(_: BytesLike): CellInput;
+  fromBytes(_bytes: BytesLike): CellInput;
+  from(_: CellInputLike): CellInput;
   Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
     toBytes(): Bytes$1;
     clone(): SubType;
@@ -5227,269 +5620,710 @@ declare const Transaction_base: (abstract new () => {
 /**
  * @public
  */
-declare class Transaction extends Transaction_base {
-  version: Num;
-  cellDeps: CellDep[];
-  headerDeps: Hex[];
-  inputs: CellInput[];
-  outputs: CellOutput[];
-  outputsData: Hex[];
-  witnesses: Hex[];
-  /**
-   * Creates an instance of Transaction.
-   *
-   * @param version - The version of the transaction.
-   * @param cellDeps - The cell dependencies of the transaction.
-   * @param headerDeps - The header dependencies of the transaction.
-   * @param inputs - The inputs of the transaction.
-   * @param outputs - The outputs of the transaction.
-   * @param outputsData - The data associated with the outputs.
-   * @param witnesses - The witnesses of the transaction.
-   */
-  constructor(version: Num, cellDeps: CellDep[], headerDeps: Hex[], inputs: CellInput[], outputs: CellOutput[], outputsData: Hex[], witnesses: Hex[]);
-  /**
-   * Creates a default Transaction instance with empty fields.
-   *
-   * @returns A default Transaction instance.
-   *
-   * @example
-   * ```typescript
-   * const defaultTx = Transaction.default();
-   * ```
-   */
-  static default(): Transaction;
-  /**
-   * Copy every properties from another transaction.
-   * This method replaces all properties of the current transaction with those from the provided transaction.
-   *
-   * @param txLike - The transaction-like object to copy properties from.
-   *
-   * @example
-   * ```typescript
-   * this.copy(Transaction.default());
-   * ```
-   */
-  copy(txLike: TransactionLike): void;
+declare class CellInput extends CellInput_base {
+  previousOutput: OutPoint;
+  since: Num;
+  cellOutput?: CellOutput | undefined;
+  outputData?: Hex | undefined;
   /**
-   * Creates a deep copy of the transaction.
-   * This method creates a new Transaction instance with all nested objects cloned,
-   * ensuring that modifications to the cloned transaction do not affect the original.
-   *
-   * @returns A new Transaction instance that is a deep copy of the current transaction.
-   *
-   * @example
-   * ```typescript
-   * const originalTx = Transaction.from({
-   *   version: 0,
-   *   inputs: [{ previousOutput: { txHash: "0x...", index: 0 } }],
-   *   outputs: [{ capacity: 1000n, lock: lockScript }],
-   *   outputsData: ["0x"],
-   *   witnesses: ["0x"]
-   * });
-   *
-   * const clonedTx = originalTx.clone();
-   *
-   * // Modifications to clonedTx won't affect originalTx
-   * clonedTx.addOutput({ capacity: 2000n, lock: anotherLockScript });
-   * console.log(originalTx.outputs.length); // Still 1
-   * console.log(clonedTx.outputs.length);   // Now 2
-   * ```
-   *
-   * @remarks
-   * The clone operation performs deep copying for:
-   * - Cell dependencies (cellDeps) - each CellDep is cloned
-   * - Inputs - each CellInput is cloned
-   * - Outputs - each CellOutput is cloned
+   * Creates an instance of CellInput.
    *
-   * The following are shallow copied (references to immutable data):
-   * - Header dependencies (headerDeps) - Hex strings are immutable
-   * - Output data (outputsData) - Hex strings are immutable
-   * - Witnesses - Hex strings are immutable
-   * - Version - bigint is immutable
+   * @param previousOutput - The previous outpoint of the cell.
+   * @param since - The since value of the cell input.
+   * @param cellOutput - The optional cell output associated with the cell input.
+   * @param outputData - The optional output data associated with the cell input.
    */
-  clone(): Transaction;
+  constructor(previousOutput: OutPoint, since: Num, cellOutput?: CellOutput | undefined, outputData?: Hex | undefined);
   /**
-   * Creates a Transaction instance from a TransactionLike object.
+   * Creates a CellInput instance from a CellInputLike object.
    *
-   * @param tx - A TransactionLike object or an instance of Transaction.
-   * @returns A Transaction instance.
+   * @param cellInput - A CellInputLike object or an instance of CellInput.
+   * @returns A CellInput instance.
    *
    * @example
    * ```typescript
-   * const transaction = Transaction.from({
-   *   version: 0,
-   *   cellDeps: [],
-   *   headerDeps: [],
-   *   inputs: [],
-   *   outputs: [],
-   *   outputsData: [],
-   *   witnesses: []
+   * const cellInput = CellInput.from({
+   *   previousOutput: { txHash: "0x...", index: 0 },
+   *   since: 0n
    * });
    * ```
    */
-  static from(tx: TransactionLike): Transaction;
+  static from(cellInput: CellInputLike): CellInput;
+  getCell(client: Client): Promise<Cell>;
   /**
-   * Creates a Transaction instance from a Lumos skeleton.
-   *
-   * @param skeleton - The Lumos transaction skeleton.
-   * @returns A Transaction instance.
-   *
-   * @throws Will throw an error if an input's outPoint is missing.
+   * Complete extra infos in the input. Including
+   * - Previous cell output
+   * - Previous cell data
+   * The instance will be modified.
    *
+   * @returns true if succeed.
    * @example
    * ```typescript
-   * const transaction = Transaction.fromLumosSkeleton(skeleton);
+   * await cellInput.completeExtraInfos(client);
    * ```
    */
-  static fromLumosSkeleton(skeleton: LumosTransactionSkeletonType): Transaction;
+  completeExtraInfos(client: Client): Promise<void>;
   /**
-   * @deprecated
-   * Use ccc.stringify instead.
-   * stringify the tx to JSON string.
+   * The extra capacity created when consume this input.
+   * This is usually NervosDAO interest, see https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0023-dao-deposit-withdraw/0023-dao-deposit-withdraw.md.
+   * And it can also be miners' income. (But this is not implemented yet)
    */
-  stringify(): string;
+  getExtraCapacity(client: Client): Promise<Num>;
   /**
-   * Converts the raw transaction data to bytes.
+   * Clone a CellInput.
    *
-   * @returns A Uint8Array containing the raw transaction bytes.
+   * @returns A cloned CellInput instance.
    *
    * @example
    * ```typescript
-   * const rawTxBytes = transaction.rawToBytes();
+   * const cellInput1 = cellInput0.clone();
    * ```
    */
-  rawToBytes(): Bytes$1;
-  /**
-   * Calculates the hash of the transaction without witnesses. This is the transaction hash in the usual sense.
-   * To calculate the hash of the whole transaction including the witnesses, use transaction.hashFull() instead.
-   *
-   * @returns The hash of the transaction.
+  clone(): CellInput;
+}
+declare const CellInputVec: Codec<CellInputLike[], CellInput[]>;
+/**
+ * @public
+ */
+type CellDepLike = {
+  outPoint: OutPointLike;
+  depType: DepTypeLike;
+};
+declare const CellDep_base: (abstract new () => {
+  toBytes(): Bytes$1;
+  clone(): CellDep;
+  eq(other: CellDepLike): boolean;
+  hash(): Hex;
+  toHex(): Hex;
+}) & {
+  byteLength?: number;
+  encode(_: CellDepLike): Bytes$1;
+  decode(_: BytesLike): CellDep;
+  fromBytes(_bytes: BytesLike): CellDep;
+  from(_: CellDepLike): CellDep;
+  Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
+    toBytes(): Bytes$1;
+    clone(): SubType;
+    eq(other: SubTypeLike): boolean;
+    hash(): Hex;
+    toHex(): Hex;
+  }) & {
+    byteLength?: number;
+    encode(_: SubTypeLike): Bytes$1;
+    decode(_: BytesLike): SubType;
+    fromBytes(_bytes: BytesLike): SubType;
+    from(_: SubTypeLike): SubType;
+    Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new (inner: DecodedType<CodecType>) => {
+      readonly inner: DecodedType<CodecType>;
+      match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
+        _?: undefined | null;
+      }): Result;
+      match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
+        _: (inner: DecodedType<CodecType>) => Result;
+      }): Result;
+      toBytes(): Bytes$1;
+      clone(): SubType_1;
+      eq(other: SubTypeLike_1): boolean;
+      hash(): Hex;
+      toHex(): Hex;
+    }) & {
+      byteLength?: number;
+      encode(_: SubTypeLike_1): Bytes$1;
+      decode(_: BytesLike): SubType_1;
+      fromBytes(_bytes: BytesLike): SubType_1;
+      from(_: SubTypeLike_1): SubType_1;
+      Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
+    };
+  };
+  BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): (abstract new (inner: DecodedType<CodecType>) => {
+    readonly inner: DecodedType<CodecType>;
+    match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
+      _?: undefined | null;
+    }): Result;
+    match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
+      _: (inner: DecodedType<CodecType>) => Result;
+    }): Result;
+    toBytes(): Bytes$1;
+    clone(): SubType;
+    eq(other: SubTypeLike): boolean;
+    hash(): Hex;
+    toHex(): Hex;
+  }) & {
+    byteLength?: number;
+    encode(_: SubTypeLike): Bytes$1;
+    decode(_: BytesLike): SubType;
+    fromBytes(_bytes: BytesLike): SubType;
+    from(_: SubTypeLike): SubType;
+    Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new () => {
+      toBytes(): Bytes$1;
+      clone(): SubType_1;
+      eq(other: SubTypeLike_1): boolean;
+      hash(): Hex;
+      toHex(): Hex;
+    }) & {
+      byteLength?: number;
+      encode(_: SubTypeLike_1): Bytes$1;
+      decode(_: BytesLike): SubType_1;
+      fromBytes(_bytes: BytesLike): SubType_1;
+      from(_: SubTypeLike_1): SubType_1;
+      Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
+      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+    };
+    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+  };
+};
+/**
+ * @public
+ */
+declare class CellDep extends CellDep_base {
+  outPoint: OutPoint;
+  depType: DepType;
+  /**
+   * Creates an instance of CellDep.
    *
-   * @example
-   * ```typescript
-   * const txHash = transaction.hash();
-   * ```
+   * @param outPoint - The outpoint of the cell dependency.
+   * @param depType - The dependency type.
    */
-  hash(): Hex;
+  constructor(outPoint: OutPoint, depType: DepType);
   /**
-   * Calculates the hash of the transaction with witnesses.
+   * Creates a CellDep instance from a CellDepLike object.
    *
-   * @returns The hash of the transaction with witnesses.
+   * @param cellDep - A CellDepLike object or an instance of CellDep.
+   * @returns A CellDep instance.
    *
    * @example
    * ```typescript
-   * const txFullHash = transaction.hashFull();
+   * const cellDep = CellDep.from({
+   *   outPoint: { txHash: "0x...", index: 0 },
+   *   depType: "depGroup"
+   * });
    * ```
    */
-  hashFull(): Hex;
+  static from(cellDep: CellDepLike): CellDep;
   /**
-   * Hashes a witness and updates the hasher.
+   * Clone a CellDep.
    *
-   * @param witness - The witness to hash.
-   * @param hasher - The hasher instance to update.
+   * @returns A cloned CellDep instance.
    *
    * @example
    * ```typescript
-   * Transaction.hashWitnessToHasher("0x...", hasher);
+   * const cellDep1 = cellDep0.clone();
    * ```
    */
-  static hashWitnessToHasher(witness: HexLike, hasher: Hasher): void;
+  clone(): CellDep;
+}
+declare const CellDepVec: Codec<CellDepLike[], CellDep[]>;
+/**
+ * @public
+ */
+type WitnessArgsLike = {
+  lock?: HexLike | null;
+  inputType?: HexLike | null;
+  outputType?: HexLike | null;
+};
+declare const WitnessArgs_base: (abstract new () => {
+  toBytes(): Bytes$1;
+  clone(): WitnessArgs;
+  eq(other: WitnessArgsLike): boolean;
+  hash(): Hex;
+  toHex(): Hex;
+}) & {
+  byteLength?: number;
+  encode(_: WitnessArgsLike): Bytes$1;
+  decode(_: BytesLike): WitnessArgs;
+  fromBytes(_bytes: BytesLike): WitnessArgs;
+  from(_: WitnessArgsLike): WitnessArgs;
+  Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
+    toBytes(): Bytes$1;
+    clone(): SubType;
+    eq(other: SubTypeLike): boolean;
+    hash(): Hex;
+    toHex(): Hex;
+  }) & {
+    byteLength?: number;
+    encode(_: SubTypeLike): Bytes$1;
+    decode(_: BytesLike): SubType;
+    fromBytes(_bytes: BytesLike): SubType;
+    from(_: SubTypeLike): SubType;
+    Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new (inner: DecodedType<CodecType>) => {
+      readonly inner: DecodedType<CodecType>;
+      match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
+        _?: undefined | null;
+      }): Result;
+      match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
+        _: (inner: DecodedType<CodecType>) => Result;
+      }): Result;
+      toBytes(): Bytes$1;
+      clone(): SubType_1;
+      eq(other: SubTypeLike_1): boolean;
+      hash(): Hex;
+      toHex(): Hex;
+    }) & {
+      byteLength?: number;
+      encode(_: SubTypeLike_1): Bytes$1;
+      decode(_: BytesLike): SubType_1;
+      fromBytes(_bytes: BytesLike): SubType_1;
+      from(_: SubTypeLike_1): SubType_1;
+      Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
+    };
+  };
+  BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): (abstract new (inner: DecodedType<CodecType>) => {
+    readonly inner: DecodedType<CodecType>;
+    match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
+      _?: undefined | null;
+    }): Result;
+    match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
+      _: (inner: DecodedType<CodecType>) => Result;
+    }): Result;
+    toBytes(): Bytes$1;
+    clone(): SubType;
+    eq(other: SubTypeLike): boolean;
+    hash(): Hex;
+    toHex(): Hex;
+  }) & {
+    byteLength?: number;
+    encode(_: SubTypeLike): Bytes$1;
+    decode(_: BytesLike): SubType;
+    fromBytes(_bytes: BytesLike): SubType;
+    from(_: SubTypeLike): SubType;
+    Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new () => {
+      toBytes(): Bytes$1;
+      clone(): SubType_1;
+      eq(other: SubTypeLike_1): boolean;
+      hash(): Hex;
+      toHex(): Hex;
+    }) & {
+      byteLength?: number;
+      encode(_: SubTypeLike_1): Bytes$1;
+      decode(_: BytesLike): SubType_1;
+      fromBytes(_bytes: BytesLike): SubType_1;
+      from(_: SubTypeLike_1): SubType_1;
+      Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
+      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+    };
+    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+  };
+};
+/**
+ * @public
+ */
+declare class WitnessArgs extends WitnessArgs_base {
+  lock?: Hex | undefined;
+  inputType?: Hex | undefined;
+  outputType?: Hex | undefined;
   /**
-   * Computes the signing hash information for a given script.
+   * Creates an instance of WitnessArgs.
    *
-   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
-   * @param client - The client for complete extra infos in the transaction.
-   * @returns A promise that resolves to an object containing the signing message and the witness position,
-   *          or undefined if no matching input is found.
+   * @param lock - The optional lock field of the witness.
+   * @param inputType - The optional input type field of the witness.
+   * @param outputType - The optional output type field of the witness.
+   */
+  constructor(lock?: Hex | undefined, inputType?: Hex | undefined, outputType?: Hex | undefined);
+  /**
+   * Creates a WitnessArgs instance from a WitnessArgsLike object.
+   *
+   * @param witnessArgs - A WitnessArgsLike object or an instance of WitnessArgs.
+   * @returns A WitnessArgs instance.
    *
    * @example
    * ```typescript
-   * const signHashInfo = await tx.getSignHashInfo(scriptLike, client);
-   * if (signHashInfo) {
-   *   console.log(signHashInfo.message); // Outputs the signing message
-   *   console.log(signHashInfo.position); // Outputs the witness position
-   * }
+   * const witnessArgs = WitnessArgs.from({
+   *   lock: "0x...",
+   *   inputType: "0x...",
+   *   outputType: "0x..."
+   * });
    * ```
    */
-  getSignHashInfo(scriptLike: ScriptLike, client: Client, hasher?: Hasher): Promise<{
-    message: Hex;
-    position: number;
-  } | undefined>;
+  static from(witnessArgs: WitnessArgsLike): WitnessArgs;
+}
+/**
+ * Convert a bytes to a num.
+ *
+ * @public
+ */
+declare function udtBalanceFrom(dataLike: BytesLike): Num;
+declare const RawTransaction: Codec<EncodableRecord<{
+  version: Codec<NumLike, number>;
+  cellDeps: Codec<CellDepLike[], CellDep[]>;
+  headerDeps: Codec<BytesLike[], `0x${string}`[]>;
+  inputs: Codec<CellInputLike[], CellInput[]>;
+  outputs: Codec<CellOutputLike[], CellOutput[]>;
+  outputsData: Codec<BytesLike[], `0x${string}`[]>;
+}>, DecodedRecord<{
+  version: Codec<NumLike, number>;
+  cellDeps: Codec<CellDepLike[], CellDep[]>;
+  headerDeps: Codec<BytesLike[], `0x${string}`[]>;
+  inputs: Codec<CellInputLike[], CellInput[]>;
+  outputs: Codec<CellOutputLike[], CellOutput[]>;
+  outputsData: Codec<BytesLike[], `0x${string}`[]>;
+}>>;
+/**
+ * @public
+ */
+type TransactionLike = {
+  version?: NumLike | null;
+  cellDeps?: CellDepLike[] | null;
+  headerDeps?: HexLike[] | null;
+  inputs?: CellInputLike[] | null;
+  outputs?: (Omit<CellOutputLike, "capacity"> & Partial<Pick<CellOutputLike, "capacity">>)[] | null;
+  outputsData?: HexLike[] | null;
+  witnesses?: HexLike[] | null;
+};
+declare const Transaction_base: (abstract new () => {
+  toBytes(): Bytes$1;
+  clone(): Transaction;
+  eq(other: TransactionLike): boolean;
+  hash(): Hex;
+  toHex(): Hex;
+}) & {
+  byteLength?: number;
+  encode(_: TransactionLike): Bytes$1;
+  decode(_: BytesLike): Transaction;
+  fromBytes(_bytes: BytesLike): Transaction;
+  from(_: TransactionLike): Transaction;
+  Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
+    toBytes(): Bytes$1;
+    clone(): SubType;
+    eq(other: SubTypeLike): boolean;
+    hash(): Hex;
+    toHex(): Hex;
+  }) & {
+    byteLength?: number;
+    encode(_: SubTypeLike): Bytes$1;
+    decode(_: BytesLike): SubType;
+    fromBytes(_bytes: BytesLike): SubType;
+    from(_: SubTypeLike): SubType;
+    Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new (inner: DecodedType<CodecType>) => {
+      readonly inner: DecodedType<CodecType>;
+      match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
+        _?: undefined | null;
+      }): Result;
+      match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
+        _: (inner: DecodedType<CodecType>) => Result;
+      }): Result;
+      toBytes(): Bytes$1;
+      clone(): SubType_1;
+      eq(other: SubTypeLike_1): boolean;
+      hash(): Hex;
+      toHex(): Hex;
+    }) & {
+      byteLength?: number;
+      encode(_: SubTypeLike_1): Bytes$1;
+      decode(_: BytesLike): SubType_1;
+      fromBytes(_bytes: BytesLike): SubType_1;
+      from(_: SubTypeLike_1): SubType_1;
+      Base<SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
+    };
+  };
+  BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): (abstract new (inner: DecodedType<CodecType>) => {
+    readonly inner: DecodedType<CodecType>;
+    match<Result>(handlers: UnionMatchHandlers<CodecType, Result> & {
+      _?: undefined | null;
+    }): Result;
+    match<Result>(handlers: Partial<UnionMatchHandlers<CodecType, Result>> & {
+      _: (inner: DecodedType<CodecType>) => Result;
+    }): Result;
+    toBytes(): Bytes$1;
+    clone(): SubType;
+    eq(other: SubTypeLike): boolean;
+    hash(): Hex;
+    toHex(): Hex;
+  }) & {
+    byteLength?: number;
+    encode(_: SubTypeLike): Bytes$1;
+    decode(_: BytesLike): SubType;
+    fromBytes(_bytes: BytesLike): SubType;
+    from(_: SubTypeLike): SubType;
+    Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): (abstract new () => {
+      toBytes(): Bytes$1;
+      clone(): SubType_1;
+      eq(other: SubTypeLike_1): boolean;
+      hash(): Hex;
+      toHex(): Hex;
+    }) & {
+      byteLength?: number;
+      encode(_: SubTypeLike_1): Bytes$1;
+      decode(_: BytesLike): SubType_1;
+      fromBytes(_bytes: BytesLike): SubType_1;
+      from(_: SubTypeLike_1): SubType_1;
+      Base<SubTypeLike_1, SubType_1 = SubTypeLike_1>(): /*elided*/ any;
+      BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+    };
+    BaseUnion<CodecType extends CodecLike<any, UnionDecoded<any, any>>, SubTypeLike, SubType = SubTypeLike>(): /*elided*/ any;
+  };
+};
+/**
+ * @public
+ */
+declare class Transaction extends Transaction_base {
+  version: Num;
+  cellDeps: CellDep[];
+  headerDeps: Hex[];
+  inputs: CellInput[];
+  outputs: CellOutput[];
+  outputsData: Hex[];
+  witnesses: Hex[];
   /**
-   * Find the first occurrence of a input with the specified lock id
+   * Creates an instance of Transaction.
    *
-   * @param scriptIdLike - The script associated with the transaction, represented as a ScriptLike object without args.
-   * @param client - The client for complete extra infos in the transaction.
-   * @returns A promise that resolves to the found index
+   * @param version - The version of the transaction.
+   * @param cellDeps - The cell dependencies of the transaction.
+   * @param headerDeps - The header dependencies of the transaction.
+   * @param inputs - The inputs of the transaction.
+   * @param outputs - The outputs of the transaction.
+   * @param outputsData - The data associated with the outputs.
+   * @param witnesses - The witnesses of the transaction.
+   */
+  constructor(version: Num, cellDeps: CellDep[], headerDeps: Hex[], inputs: CellInput[], outputs: CellOutput[], outputsData: Hex[], witnesses: Hex[]);
+  /**
+   * Creates a default Transaction instance with empty fields.
+   *
+   * @returns A default Transaction instance.
    *
    * @example
    * ```typescript
-   * const index = await tx.findInputIndexByLockId(scriptIdLike, client);
+   * const defaultTx = Transaction.default();
    * ```
    */
-  findInputIndexByLockId(scriptIdLike: Pick<ScriptLike, "codeHash" | "hashType">, client: Client): Promise<number | undefined>;
+  static default(): Transaction;
   /**
-   * Find the first occurrence of a input with the specified lock
+   * Copy every properties from another transaction.
+   * This method replaces all properties of the current transaction with those from the provided transaction.
    *
-   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
-   * @param client - The client for complete extra infos in the transaction.
-   * @returns A promise that resolves to the found index, or undefined if no matching input is found.
+   * @param txLike - The transaction-like object to copy properties from.
    *
    * @example
    * ```typescript
-   * const index = await tx.findInputIndexByLock(scriptLike, client);
+   * this.copy(Transaction.default());
    * ```
    */
-  findInputIndexByLock(scriptLike: ScriptLike, client: Client): Promise<number | undefined>;
+  copy(txLike: TransactionLike): void;
   /**
-   * Find the last occurrence of a input with the specified lock
+   * Creates a deep copy of the transaction.
+   * This method creates a new Transaction instance with all nested objects cloned,
+   * ensuring that modifications to the cloned transaction do not affect the original.
    *
-   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
-   * @param client - The client for complete extra infos in the transaction.
-   * @returns A promise that resolves to the found index, or undefined if no matching input is found.
+   * @returns A new Transaction instance that is a deep copy of the current transaction.
    *
    * @example
    * ```typescript
-   * const index = await tx.findLastInputIndexByLock(scriptLike, client);
+   * const originalTx = Transaction.from({
+   *   version: 0,
+   *   inputs: [{ previousOutput: { txHash: "0x...", index: 0 } }],
+   *   outputs: [{ capacity: 1000n, lock: lockScript }],
+   *   outputsData: ["0x"],
+   *   witnesses: ["0x"]
+   * });
+   *
+   * const clonedTx = originalTx.clone();
+   *
+   * // Modifications to clonedTx won't affect originalTx
+   * clonedTx.addOutput({ capacity: 2000n, lock: anotherLockScript });
+   * console.log(originalTx.outputs.length); // Still 1
+   * console.log(clonedTx.outputs.length);   // Now 2
    * ```
+   *
+   * @remarks
+   * The clone operation performs deep copying for:
+   * - Cell dependencies (cellDeps) - each CellDep is cloned
+   * - Inputs - each CellInput is cloned
+   * - Outputs - each CellOutput is cloned
+   *
+   * The following are shallow copied (references to immutable data):
+   * - Header dependencies (headerDeps) - Hex strings are immutable
+   * - Output data (outputsData) - Hex strings are immutable
+   * - Witnesses - Hex strings are immutable
+   * - Version - bigint is immutable
    */
-  findLastInputIndexByLock(scriptLike: ScriptLike, client: Client): Promise<number | undefined>;
+  clone(): Transaction;
   /**
-   * Add cell deps if they are not existed
+   * Creates a Transaction instance from a TransactionLike object.
    *
-   * @param cellDepLikes - The cell deps to add
+   * @param tx - A TransactionLike object or an instance of Transaction.
+   * @returns A Transaction instance.
    *
    * @example
    * ```typescript
-   * tx.addCellDeps(cellDep);
+   * const transaction = Transaction.from({
+   *   version: 0,
+   *   cellDeps: [],
+   *   headerDeps: [],
+   *   inputs: [],
+   *   outputs: [],
+   *   outputsData: [],
+   *   witnesses: []
+   * });
    * ```
    */
-  addCellDeps(...cellDepLikes: (CellDepLike | CellDepLike[])[]): void;
+  static from(tx: TransactionLike): Transaction;
   /**
-   * Add cell deps at the start if they are not existed
+   * Creates a Transaction instance from a Lumos skeleton.
    *
-   * @param cellDepLikes - The cell deps to add
+   * @param skeleton - The Lumos transaction skeleton.
+   * @returns A Transaction instance.
+   *
+   * @throws Will throw an error if an input's outPoint is missing.
    *
    * @example
    * ```typescript
-   * tx.addCellDepsAtBegin(cellDep);
+   * const transaction = Transaction.fromLumosSkeleton(skeleton);
    * ```
    */
-  addCellDepsAtStart(...cellDepLikes: (CellDepLike | CellDepLike[])[]): void;
+  static fromLumosSkeleton(skeleton: LumosTransactionSkeletonType): Transaction;
   /**
-   * Add cell dep from infos if they are not existed
+   * @deprecated
+   * Use ccc.stringify instead.
+   * stringify the tx to JSON string.
+   */
+  stringify(): string;
+  /**
+   * Converts the raw transaction data to bytes.
    *
-   * @param client - A client for searching cell deps
-   * @param cellDepInfoLikes - The cell dep infos to add
+   * @returns A Uint8Array containing the raw transaction bytes.
    *
    * @example
    * ```typescript
-   * tx.addCellDepInfos(client, cellDepInfos);
+   * const rawTxBytes = transaction.rawToBytes();
    * ```
    */
-  addCellDepInfos(client: Client, ...cellDepInfoLikes: (CellDepInfoLike | CellDepInfoLike[])[]): Promise<void>;
+  rawToBytes(): Bytes$1;
   /**
-   * Add cell deps from known script
+   * Calculates the hash of the transaction without witnesses. This is the transaction hash in the usual sense.
+   * To calculate the hash of the whole transaction including the witnesses, use transaction.hashFull() instead.
+   *
+   * @returns The hash of the transaction.
+   *
+   * @example
+   * ```typescript
+   * const txHash = transaction.hash();
+   * ```
+   */
+  hash(): Hex;
+  /**
+   * Calculates the hash of the transaction with witnesses.
+   *
+   * @returns The hash of the transaction with witnesses.
+   *
+   * @example
+   * ```typescript
+   * const txFullHash = transaction.hashFull();
+   * ```
+   */
+  hashFull(): Hex;
+  /**
+   * Hashes a witness and updates the hasher.
+   *
+   * @param witness - The witness to hash.
+   * @param hasher - The hasher instance to update.
+   *
+   * @example
+   * ```typescript
+   * Transaction.hashWitnessToHasher("0x...", hasher);
+   * ```
+   */
+  static hashWitnessToHasher(witness: HexLike, hasher: Hasher): void;
+  /**
+   * Computes the signing hash information for a given script.
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to an object containing the signing message and the witness position,
+   *          or undefined if no matching input is found.
+   *
+   * @example
+   * ```typescript
+   * const signHashInfo = await tx.getSignHashInfo(scriptLike, client);
+   * if (signHashInfo) {
+   *   console.log(signHashInfo.message); // Outputs the signing message
+   *   console.log(signHashInfo.position); // Outputs the witness position
+   * }
+   * ```
+   */
+  getSignHashInfo(scriptLike: ScriptLike, client: Client, hasher?: Hasher): Promise<{
+    message: Hex;
+    position: number;
+  } | undefined>;
+  /**
+   * Find the first occurrence of a input with the specified lock id
+   *
+   * @param scriptIdLike - The script associated with the transaction, represented as a ScriptLike object without args.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to the found index
+   *
+   * @example
+   * ```typescript
+   * const index = await tx.findInputIndexByLockId(scriptIdLike, client);
+   * ```
+   */
+  findInputIndexByLockId(scriptIdLike: Pick<ScriptLike, "codeHash" | "hashType">, client: Client): Promise<number | undefined>;
+  /**
+   * Find the first occurrence of a input with the specified lock
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to the found index, or undefined if no matching input is found.
+   *
+   * @example
+   * ```typescript
+   * const index = await tx.findInputIndexByLock(scriptLike, client);
+   * ```
+   */
+  findInputIndexByLock(scriptLike: ScriptLike, client: Client): Promise<number | undefined>;
+  /**
+   * Find the last occurrence of a input with the specified lock
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to the found index, or undefined if no matching input is found.
+   *
+   * @example
+   * ```typescript
+   * const index = await tx.findLastInputIndexByLock(scriptLike, client);
+   * ```
+   */
+  findLastInputIndexByLock(scriptLike: ScriptLike, client: Client): Promise<number | undefined>;
+  /**
+   * Add cell deps if they are not existed
+   *
+   * @param cellDepLikes - The cell deps to add
+   *
+   * @example
+   * ```typescript
+   * tx.addCellDeps(cellDep);
+   * ```
+   */
+  addCellDeps(...cellDepLikes: (CellDepLike | CellDepLike[])[]): void;
+  /**
+   * Add cell deps at the start if they are not existed
+   *
+   * @param cellDepLikes - The cell deps to add
+   *
+   * @example
+   * ```typescript
+   * tx.addCellDepsAtBegin(cellDep);
+   * ```
+   */
+  addCellDepsAtStart(...cellDepLikes: (CellDepLike | CellDepLike[])[]): void;
+  /**
+   * Add cell dep from infos if they are not existed
+   *
+   * @param client - A client for searching cell deps
+   * @param cellDepInfoLikes - The cell dep infos to add
+   *
+   * @example
+   * ```typescript
+   * tx.addCellDepInfos(client, cellDepInfos);
+   * ```
+   */
+  addCellDepInfos(client: Client, ...cellDepInfoLikes: (CellDepInfoLike | CellDepInfoLike[])[]): Promise<void>;
+  /**
+   * Add cell deps from known script
    *
    * @param client - The client for searching known script and cell deps
    * @param scripts - The known scripts to add
@@ -6081,571 +6915,98 @@ declare abstract class ClientCache {
    */
   recordHeaders(..._headers: (ClientBlockHeaderLike | ClientBlockHeaderLike[])[]): Promise<void>;
   /**
-   * Get a known block header by hash
-   * Implement this method to enable block headers query caching
-   * @param _hash
-   */
-  getHeaderByHash(_hash: HexLike): Promise<ClientBlockHeader | undefined>;
-  /**
-   * Get a known block header by number
-   * Implement this method to enable block headers query caching
-   * @param _number
-   */
-  getHeaderByNumber(_number: NumLike): Promise<ClientBlockHeader | undefined>;
-  /**
-   * Record known blocks.
-   * Implement this method to enable blocks query caching
-   * @param _blocks
-   */
-  recordBlocks(..._blocks: (ClientBlockLike | ClientBlockLike[])[]): Promise<void>;
-  /**
-   * Get a known block header by hash
-   * Implement this method to enable block headers query caching
-   * @param _hash
-   */
-  getBlockByHash(_hash: HexLike): Promise<ClientBlock | undefined>;
-  /**
-   * Get a known block header by number
-   * Implement this method to enable block headers query caching
-   * @param _number
-   */
-  getBlockByNumber(_number: NumLike): Promise<ClientBlock | undefined>;
-  /**
-   * Checks if a block header is considered confirmed.
-   * The default implementation compares the header's timestamp against the current time
-   * and a configured confirmation time. Override this method for custom confirmation logic.
-   * @param header
-   */
-  hasHeaderConfirmed(header: ClientBlockHeader): boolean;
-}
-//#endregion
-//#region src/client/cache/memory.d.ts
-declare class ClientCacheMemory extends ClientCache {
-  private readonly maxCells;
-  private readonly maxTxs;
-  private readonly maxBlocks;
-  /**
-   * OutPoint => [isLive, Cell | OutPoint]
-   */
-  private readonly cells;
-  /**
-   * TX Hash => Transaction Response
-   */
-  private readonly knownTransactions;
-  /**
-   * Block Number => Block Hash
-   */
-  private readonly knownBlockHashes;
-  /**
-   * Block Hash => Block Header / Full Block
-   */
-  private readonly knownBlocks;
-  private readonly confirmedBlockTime;
-  /**
-   * @param maxCells - Maximum number of cells to store in the cache. Defaults to 512.
-   * @param maxTxs - Maximum number of transactions to store in the cache. Defaults to 256.
-   * @param maxBlocks - Maximum number of blocks to store in the cache. Defaults to 128.
-   * @param confirmedBlockTimeLike - Time in milliseconds after which a block is considered confirmed.
-   *                                 Defaults to DEFAULT_CONFIRMED_BLOCK_TIME (50 blocks * 10s).
-   */
-  constructor(maxCells?: number, maxTxs?: number, maxBlocks?: number, confirmedBlockTimeLike?: NumLike);
-  markUsableNoCache(...cellLikes: (CellLike | CellLike[])[]): Promise<void>;
-  markUnusable(...outPointLikes: (OutPointLike | OutPointLike[])[]): Promise<void>;
-  clear(): Promise<void>;
-  findCells(keyLike: ClientCollectableSearchKeyLike): AsyncGenerator<Cell>;
-  isUnusable(outPointLike: OutPointLike): Promise<boolean>;
-  recordCells(...cells: (CellLike | CellLike[])[]): Promise<void>;
-  getCell(outPointLike: OutPointLike): Promise<Cell | undefined>;
-  recordTransactionResponses(...transactions: (ClientTransactionResponseLike | ClientTransactionResponseLike[])[]): Promise<void>;
-  getTransactionResponse(txHashLike: HexLike): Promise<ClientTransactionResponse | undefined>;
-  recordHeaders(...headers: (ClientBlockHeaderLike | ClientBlockHeaderLike[])[]): Promise<void>;
-  getHeaderByHash(hashLike: HexLike): Promise<ClientBlockHeader | undefined>;
-  getHeaderByNumber(numberLike: NumLike): Promise<ClientBlockHeader | undefined>;
-  recordBlocks(...blocks: (ClientBlockLike | ClientBlockLike[])[]): Promise<void>;
-  getBlockByHash(hashLike: HexLike): Promise<ClientBlock | undefined>;
-  getBlockByNumber(numberLike: NumLike): Promise<ClientBlock | undefined>;
-  hasHeaderConfirmed(header: ClientBlockHeader): boolean;
-}
-//#endregion
-//#region src/client/client.d.ts
-/**
- * @public
- */
-declare abstract class Client {
-  cache: ClientCache;
-  constructor(config?: {
-    cache?: ClientCache;
-  });
-  abstract get url(): string;
-  abstract get addressPrefix(): string;
-  /**
-   * Get the deployment info for a well-known CKB script.
-   * Returns the cell deps and type script info needed to use the script.
-   *
-   * @param script - The KnownScript enum value.
-   * @returns Script info including cellDeps and type hash.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   *
-   * // Get xUDT script deployment info
-   * const xudtInfo = await client.getKnownScript(ccc.KnownScript.XUdt);
-   * console.log(`xUDT cellDeps:`, xudtInfo.cellDeps);
-   *
-   * // Build an xUDT type script
-   * const xudtType = await ccc.Script.fromKnownScript(
-   *   client,
-   *   ccc.KnownScript.XUdt,
-   *   "0xOWNER_LOCK_HASH...",
-   * );
-   * ```
-   */
-  abstract getKnownScript(script: KnownScript): Promise<ScriptInfo>;
-  abstract getFeeRateStatistics(blockRange?: NumLike): Promise<{
-    mean: Num;
-    median: Num;
-  }>;
-  /**
-   * Get the recommended transaction fee rate based on recent blocks.
-   * Returns the median fee rate, clamped between min and max fee rates.
-   *
-   * @param blockRange - Number of recent blocks to analyze.
-   * @param options - Optional max fee rate cap.
-   * @returns The recommended fee rate in Shannons per KB.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const feeRate = await client.getFeeRate();
-   * console.log(`Current fee rate: ${feeRate} Shannons/KB`);
-   * ```
-   */
-  getFeeRate(blockRange?: NumLike, options?: {
-    maxFeeRate?: NumLike;
-  }): Promise<Num>;
-  /**
-   * Get the latest block number (tip) of the chain.
-   *
-   * @returns The current tip block number.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const tipBlockNumber = await client.getTip();
-   * console.log(`Current block height: ${tipBlockNumber}`);
-   * ```
-   */
-  abstract getTip(): Promise<Num>;
-  /**
-   * Get the header of the latest block.
-   *
-   * @param verbosity - Verbosity level (0 for hex, 1 for object).
-   * @returns The tip block header.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const header = await client.getTipHeader();
-   * console.log(`Block #${header.number}, hash: ${header.hash}`);
-   * ```
-   */
-  abstract getTipHeader(verbosity?: number | null): Promise<ClientBlockHeader>;
-  abstract getBlockByNumberNoCache(blockNumber: NumLike, verbosity?: number | null, withCycles?: boolean | null): Promise<ClientBlock | undefined>;
-  abstract getBlockByHashNoCache(blockHash: HexLike, verbosity?: number | null, withCycles?: boolean | null): Promise<ClientBlock | undefined>;
-  abstract getHeaderByNumberNoCache(blockNumber: NumLike, verbosity?: number | null): Promise<ClientBlockHeader | undefined>;
-  abstract getHeaderByHashNoCache(blockHash: HexLike, verbosity?: number | null): Promise<ClientBlockHeader | undefined>;
-  getBlockByNumber(blockNumber: NumLike, verbosity?: number | null, withCycles?: boolean | null): Promise<ClientBlock | undefined>;
-  getBlockByHash(blockHash: HexLike, verbosity?: number | null, withCycles?: boolean | null): Promise<ClientBlock | undefined>;
-  getHeaderByNumber(blockNumber: NumLike, verbosity?: number | null): Promise<ClientBlockHeader | undefined>;
-  getHeaderByHash(blockHash: HexLike, verbosity?: number | null): Promise<ClientBlockHeader | undefined>;
-  abstract estimateCycles(transaction: TransactionLike): Promise<Num>;
-  abstract sendTransactionDry(transaction: TransactionLike, validator?: OutputsValidator): Promise<Num>;
-  abstract sendTransactionNoCache(transaction: TransactionLike, validator?: OutputsValidator): Promise<Hex>;
-  abstract getTransactionNoCache(txHash: HexLike): Promise<ClientTransactionResponse | undefined>;
-  /**
-   * Get a cell by its out point.
-   * The cell will be cached if it is found.
-   *
-   * @param outPointLike - The out point of the cell to get.
-   * @returns The cell if it exists, otherwise undefined.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const cell = await client.getCell({
-   *   txHash: "0xTX_HASH...",
-   *   index: 0,
-   * });
-   * if (cell) {
-   *   console.log(`Capacity: ${ccc.fixedPointToString(cell.cellOutput.capacity)} CKB`);
-   *   console.log(`Lock: ${cell.cellOutput.lock.codeHash}`);
-   *   console.log(`Data: ${cell.outputData}`);
-   * }
-   * ```
-   */
-  getCell(outPointLike: OutPointLike): Promise<Cell | undefined>;
-  getCellWithHeader(outPointLike: OutPointLike): Promise<{
-    cell: Cell;
-    header?: ClientBlockHeader;
-  } | undefined>;
-  abstract getCellLiveNoCache(outPointLike: OutPointLike, withData?: boolean | null, includeTxPool?: boolean | null): Promise<Cell | undefined>;
-  /**
-   * Get a live (unspent) cell by its out point.
-   * Unlike getCell(), this verifies the cell is still live on-chain.
-   *
-   * @param outPointLike - The out point of the cell.
-   * @param withData - Whether to include cell data.
-   * @param includeTxPool - Whether to include cells in the transaction pool.
-   * @returns The live cell, or undefined if spent or not found.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const cell = await client.getCellLive(
-   *   { txHash: "0xTX_HASH...", index: 0 },
-   *   true,  // include data
-   *   true,  // include tx pool
-   * );
-   * if (cell) {
-   *   console.log("Cell is still live!");
-   * } else {
-   *   console.log("Cell has been spent or does not exist.");
-   * }
-   * ```
-   */
-  getCellLive(outPointLike: OutPointLike, withData?: boolean | null, includeTxPool?: boolean | null): Promise<Cell | undefined>;
-  abstract findCellsPagedNoCache(key: ClientIndexerSearchKeyLike, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindCellsResponse>;
-  /**
-   * Find cells with pagination support.
-   * Returns one page of results at a time with a cursor for the next page.
-   *
-   * @param key - The indexer search key.
-   * @param order - Sort order ("asc" or "desc").
-   * @param limit - Maximum cells per page.
-   * @param after - Cursor from previous page for pagination.
-   * @returns A page of cells with a cursor for the next page.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const { script: lock } = await ccc.Address.fromString("ckt1q...", client);
-   *
-   * // Get first page of cells
-   * const page1 = await client.findCellsPaged({
-   *   script: lock,
-   *   scriptType: "lock",
-   * }, "asc", 20);
-   * console.log(`Found ${page1.cells.length} cells`);
-   *
-   * // Get next page
-   * if (page1.cells.length === 20) {
-   *   const page2 = await client.findCellsPaged(
-   *     { script: lock, scriptType: "lock" },
-   *     "asc", 20, page1.lastCursor,
-   *   );
-   * }
-   * ```
-   */
-  findCellsPaged(key: ClientIndexerSearchKeyLike, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindCellsResponse>;
-  findCellsOnChain(key: ClientIndexerSearchKeyLike, order?: "asc" | "desc", limit?: number): AsyncGenerator<Cell>;
-  /**
-   * Find cells by search key designed for collectable cells.
-   * The result also includes cached cells, the order param only works for cells fetched from RPC.
-   *
-   * @param keyLike - The search key.
-   * @returns A async generator for yielding cells.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const { script: lock } = await ccc.Address.fromString("ckt1q...", client);
-   *
-   * // Find all cells owned by a lock script
-   * for await (const cell of client.findCells({
-   *   script: lock,
-   *   scriptType: "lock",
-   *   scriptSearchMode: "exact",
-   *   withData: true,
-   * })) {
-   *   console.log(`Cell: ${cell.outPoint.txHash}:${cell.outPoint.index}`);
-   *   console.log(`Capacity: ${ccc.fixedPointToString(cell.cellOutput.capacity)} CKB`);
-   * }
-   * ```
-   */
-  findCells(keyLike: ClientCollectableSearchKeyLike, order?: "asc" | "desc", limit?: number): AsyncGenerator<Cell>;
-  /**
-   * Find cells by lock script, optionally filtered by type script.
-   *
-   * @param lock - The lock script to search by.
-   * @param type - Optional type script filter.
-   * @param withData - Whether to include cell data (default: true).
-   * @param order - Sort order by block number ("asc" or "desc").
-   * @param limit - Page size for each RPC call (default: 10).
-   * @returns An async generator yielding matching cells.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const { script: lock } = await ccc.Address.fromString("ckt1q...", client);
-   *
-   * // Find all cells belonging to this address
-   * for await (const cell of client.findCellsByLock(lock)) {
-   *   console.log(`${ccc.fixedPointToString(cell.cellOutput.capacity)} CKB`);
-   * }
-   *
-   * // Find only xUDT cells belonging to this address
-   * const xudtType = await ccc.Script.fromKnownScript(
-   *   client, ccc.KnownScript.XUdt, "0xOWNER_LOCK_HASH...",
-   * );
-   * for await (const cell of client.findCellsByLock(lock, xudtType)) {
-   *   console.log(`UDT cell found`);
-   * }
-   * ```
-   */
-  findCellsByLock(lock: ScriptLike, type?: ScriptLike | null, withData?: boolean, order?: "asc" | "desc", limit?: number): AsyncGenerator<Cell>;
-  /**
-   * Find cells by type script.
-   *
-   * @param type - The type script to search by.
-   * @param withData - Whether to include cell data (default: true).
-   * @param order - Sort order by block number.
-   * @param limit - Page size for each RPC call (default: 10).
-   * @returns An async generator yielding matching cells.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * // Find all xUDT cells of a specific token
-   * const xudtType = await ccc.Script.fromKnownScript(
-   *   client, ccc.KnownScript.XUdt, "0xOWNER_LOCK_HASH...",
-   * );
-   * for await (const cell of client.findCellsByType(xudtType)) {
-   *   console.log(`Token cell: ${cell.outPoint.txHash}:${cell.outPoint.index}`);
-   * }
-   * ```
+   * Get a known block header by hash
+   * Implement this method to enable block headers query caching
+   * @param _hash
    */
-  findCellsByType(type: ScriptLike, withData?: boolean, order?: "asc" | "desc", limit?: number): AsyncGenerator<Cell>;
-  findSingletonCellByType(type: ScriptLike, withData?: boolean): Promise<Cell | undefined>;
+  getHeaderByHash(_hash: HexLike): Promise<ClientBlockHeader | undefined>;
   /**
-   * Resolve cell dependency info into concrete CellDep objects.
-   * If a CellDepInfo specifies a type script, the actual deployed cell is located on-chain.
-   *
-   * @param cellDepsInfoLike - One or more CellDepInfo or arrays of CellDepInfo.
-   * @returns Resolved CellDep array ready to be added to a transaction.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const xudtInfo = await client.getKnownScript(ccc.KnownScript.XUdt);
-   * const cellDeps = await client.getCellDeps(xudtInfo.cellDeps);
-   * // cellDeps can be added to a transaction:
-   * // tx.cellDeps.push(...cellDeps);
-   * ```
+   * Get a known block header by number
+   * Implement this method to enable block headers query caching
+   * @param _number
    */
-  getCellDeps(...cellDepsInfoLike: (CellDepInfoLike | CellDepInfoLike[])[]): Promise<CellDep[]>;
-  abstract findTransactionsPaged(key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
-    groupByTransaction: true;
-  }, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindTransactionsGroupedResponse>;
-  abstract findTransactionsPaged(key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
-    groupByTransaction?: false | null;
-  }, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindTransactionsResponse>;
-  abstract findTransactionsPaged(key: ClientIndexerSearchKeyTransactionLike, order?: "asc" | "desc", limit?: NumLike, after?: string): Promise<ClientFindTransactionsResponse | ClientFindTransactionsGroupedResponse>;
-  findTransactions(key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
-    groupByTransaction: true;
-  }, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsGroupedResponse["transactions"][0]>;
-  findTransactions(key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
-    groupByTransaction?: false | null;
-  }, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0]>;
-  findTransactions(key: ClientIndexerSearchKeyTransactionLike, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0] | ClientFindTransactionsGroupedResponse["transactions"][0]>;
+  getHeaderByNumber(_number: NumLike): Promise<ClientBlockHeader | undefined>;
   /**
-   * Find transactions related to a lock script, optionally filtered by type script.
-   *
-   * @param lock - The lock script to search by.
-   * @param type - Optional type script filter.
-   * @param groupByTransaction - If true, group results by transaction.
-   * @param order - Sort order by block number.
-   * @param limit - Page size per RPC call.
-   * @returns An async generator yielding transaction records.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const { script: lock } = await ccc.Address.fromString("ckt1q...", client);
-   *
-   * // List all transactions related to an address (grouped)
-   * for await (const txRecord of client.findTransactionsByLock(lock, null, true)) {
-   *   console.log(`TX: ${txRecord.txHash}, Block: ${txRecord.blockNumber}`);
-   * }
-   * ```
+   * Record known blocks.
+   * Implement this method to enable blocks query caching
+   * @param _blocks
    */
-  findTransactionsByLock(lock: ScriptLike, type: ScriptLike | undefined | null, groupByTransaction: true, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsGroupedResponse["transactions"][0]>;
-  findTransactionsByLock(lock: ScriptLike, type?: ScriptLike | null, groupByTransaction?: false | null, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0]>;
-  findTransactionsByLock(lock: ScriptLike, type?: ScriptLike | null, groupByTransaction?: boolean | null, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0] | ClientFindTransactionsGroupedResponse["transactions"][0]>;
-  findTransactionsByType(type: ScriptLike, groupByTransaction: true, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsGroupedResponse["transactions"][0]>;
-  findTransactionsByType(type: ScriptLike, groupByTransaction?: false | null, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0]>;
-  findTransactionsByType(type: ScriptLike, groupByTransaction?: boolean | null, order?: "asc" | "desc", limit?: number): AsyncGenerator<ClientFindTransactionsResponse["transactions"][0] | ClientFindTransactionsGroupedResponse["transactions"][0]>;
-  abstract getCellsCapacity(key: ClientIndexerSearchKeyLike): Promise<Num>;
+  recordBlocks(..._blocks: (ClientBlockLike | ClientBlockLike[])[]): Promise<void>;
   /**
-   * Get the total CKB balance of a single lock script.
-   * Only counts cells with no type script and no data (pure CKB capacity cells).
-   *
-   * @param lock - The lock script to query balance for.
-   * @returns The total capacity in Shannons as a bigint.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const { script: lock } = await ccc.Address.fromString(
-   *   "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq...",
-   *   client,
-   * );
-   * const balance = await client.getBalanceSingle(lock);
-   * console.log(`Balance: ${ccc.fixedPointToString(balance)} CKB`);
-   * ```
+   * Get a known block header by hash
+   * Implement this method to enable block headers query caching
+   * @param _hash
    */
-  getBalanceSingle(lock: ScriptLike): Promise<Num>;
+  getBlockByHash(_hash: HexLike): Promise<ClientBlock | undefined>;
   /**
-   * Get the total CKB balance across multiple lock scripts.
-   * Sums the balance from each lock script.
-   *
-   * @param locks - An array of lock scripts to query.
-   * @returns The combined total capacity in Shannons as a bigint.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const signer = new ccc.SignerCkbPrivateKey(client, "0x...");
-   * await signer.connect();
-   *
-   * const locks = await signer.getRecommendedAddressObj()
-   *   .then(({ script }) => [script]);
-   * const totalBalance = await client.getBalance(locks);
-   * console.log(`Total: ${ccc.fixedPointToString(totalBalance)} CKB`);
-   * ```
+   * Get a known block header by number
+   * Implement this method to enable block headers query caching
+   * @param _number
    */
-  getBalance(locks: ScriptLike[]): Promise<Num>;
+  getBlockByNumber(_number: NumLike): Promise<ClientBlock | undefined>;
   /**
-   * Send a signed transaction to the CKB network.
-   * Validates the fee rate against the maximum before sending.
-   *
-   * @param transaction - The transaction to send.
-   * @param validator - Optional outputs validator ("passthrough" or "well_known_scripts_only").
-   * @param options - Optional configuration including maxFeeRate.
-   * @returns The transaction hash.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const signer = new ccc.SignerCkbPrivateKey(client, "0x...");
-   * await signer.connect();
-   *
-   * const tx = ccc.Transaction.from({
-   *   outputs: [{ capacity: ccc.fixedPointFrom(100), lock: receiverLock }],
-   * });
-   * await tx.completeInputsByCapacity(signer);
-   * await tx.completeFeeBy(signer);
-   *
-   * // Usually you call signer.sendTransaction(tx) which signs then sends.
-   * // client.sendTransaction expects an already-signed transaction.
-   * const txHash = await client.sendTransaction(tx);
-   * ```
+   * Checks if a block header is considered confirmed.
+   * The default implementation compares the header's timestamp against the current time
+   * and a configured confirmation time. Override this method for custom confirmation logic.
+   * @param header
    */
-  sendTransaction(transaction: TransactionLike, validator?: OutputsValidator, options?: {
-    maxFeeRate?: NumLike;
-  }): Promise<Hex>;
+  hasHeaderConfirmed(header: ClientBlockHeader): boolean;
+}
+//#endregion
+//#region src/client/cache/memory.d.ts
+declare class ClientCacheMemory extends ClientCache {
+  private readonly maxCells;
+  private readonly maxTxs;
+  private readonly maxBlocks;
   /**
-   * Get a transaction by its hash, including its status and block info.
-   *
-   * @param txHashLike - The transaction hash to look up.
-   * @returns The transaction response with status, or undefined if not found.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * const txResponse = await client.getTransaction("0xTX_HASH...");
-   * if (txResponse) {
-   *   console.log(`Status: ${txResponse.status}`);
-   *   console.log(`Block: ${txResponse.blockNumber}`);
-   *   console.log(`Outputs: ${txResponse.transaction.outputs.length}`);
-   * }
-   * ```
+   * OutPoint => [isLive, Cell | OutPoint]
    */
-  getTransaction(txHashLike: HexLike): Promise<ClientTransactionResponse | undefined>;
+  private readonly cells;
   /**
-   * This method gets specified transaction with its block header (if existed).
-   * This is mainly for caching because we need the header to test if we can safely trust the cached tx status.
-   * @param txHashLike
+   * TX Hash => Transaction Response
    */
-  getTransactionWithHeader(txHashLike: HexLike): Promise<{
-    transaction: ClientTransactionResponse;
-    header?: ClientBlockHeader;
-  } | undefined>;
+  private readonly knownTransactions;
   /**
-   * Wait for a transaction to be confirmed on-chain.
-   * Polls the node until the transaction reaches the specified confirmation depth.
-   *
-   * @param txHash - The transaction hash to wait for.
-   * @param confirmations - Number of block confirmations to wait for (default: 0 = committed).
-   * @param timeout - Maximum wait time in milliseconds (default: 60000).
-   * @param interval - Polling interval in milliseconds (default: 2000).
-   * @returns The transaction response once confirmed, or throws on timeout.
-   *
-   * @example
-   * ```typescript
-   * import { ccc } from "@ckb-ccc/core";
-   *
-   * const client = new ccc.ClientPublicTestnet();
-   * // Wait for transaction to be committed (0 confirmations)
-   * const tx = await client.waitTransaction("0xTX_HASH...");
-   * console.log(`Confirmed in block: ${tx?.blockNumber}`);
-   *
-   * // Wait for 4 confirmations with 2 minute timeout
-   * const confirmedTx = await client.waitTransaction(
-   *   "0xTX_HASH...",
-   *   4,       // confirmations
-   *   120000,  // timeout: 2 minutes
-   * );
-   * ```
+   * Block Number => Block Hash
    */
-  waitTransaction(txHash: HexLike, confirmations?: number, timeout?: number, interval?: number): Promise<ClientTransactionResponse | undefined>;
+  private readonly knownBlockHashes;
+  /**
+   * Block Hash => Block Header / Full Block
+   */
+  private readonly knownBlocks;
+  private readonly confirmedBlockTime;
+  /**
+   * @param maxCells - Maximum number of cells to store in the cache. Defaults to 512.
+   * @param maxTxs - Maximum number of transactions to store in the cache. Defaults to 256.
+   * @param maxBlocks - Maximum number of blocks to store in the cache. Defaults to 128.
+   * @param confirmedBlockTimeLike - Time in milliseconds after which a block is considered confirmed.
+   *                                 Defaults to DEFAULT_CONFIRMED_BLOCK_TIME (50 blocks * 10s).
+   */
+  constructor(maxCells?: number, maxTxs?: number, maxBlocks?: number, confirmedBlockTimeLike?: NumLike);
+  markUsableNoCache(...cellLikes: (CellLike | CellLike[])[]): Promise<void>;
+  markUnusable(...outPointLikes: (OutPointLike | OutPointLike[])[]): Promise<void>;
+  clear(): Promise<void>;
+  findCells(keyLike: ClientCollectableSearchKeyLike): AsyncGenerator<Cell>;
+  isUnusable(outPointLike: OutPointLike): Promise<boolean>;
+  recordCells(...cells: (CellLike | CellLike[])[]): Promise<void>;
+  getCell(outPointLike: OutPointLike): Promise<Cell | undefined>;
+  recordTransactionResponses(...transactions: (ClientTransactionResponseLike | ClientTransactionResponseLike[])[]): Promise<void>;
+  getTransactionResponse(txHashLike: HexLike): Promise<ClientTransactionResponse | undefined>;
+  recordHeaders(...headers: (ClientBlockHeaderLike | ClientBlockHeaderLike[])[]): Promise<void>;
+  getHeaderByHash(hashLike: HexLike): Promise<ClientBlockHeader | undefined>;
+  getHeaderByNumber(numberLike: NumLike): Promise<ClientBlockHeader | undefined>;
+  recordBlocks(...blocks: (ClientBlockLike | ClientBlockLike[])[]): Promise<void>;
+  getBlockByHash(hashLike: HexLike): Promise<ClientBlock | undefined>;
+  getBlockByNumber(numberLike: NumLike): Promise<ClientBlock | undefined>;
+  hasHeaderConfirmed(header: ClientBlockHeader): boolean;
 }
 //#endregion
 //#region src/client/jsonRpc/client.d.ts
-type ClientJsonRpcConfig = RequestorJsonRpcConfig & {
-  cache?: ClientCache;
+type ClientJsonRpcConfig = RequestorJsonRpcConfig & ClientConfig & {
+  /**
+   * @deprecated Requestor injection is supported only by legacy constructors.
+   * Use a borrowed Transport with `Client.new` or let `Client.open` create one.
+   */
   requestor?: RequestorJsonRpc;
 };
 /**
@@ -6653,18 +7014,26 @@ type ClientJsonRpcConfig = RequestorJsonRpcConfig & {
  * Provides methods for sending transactions and building JSON-RPC payloads.
  */
 declare abstract class ClientJsonRpc extends Client {
+  private readonly url_;
   readonly requestor: RequestorJsonRpc;
   /**
    * Creates an instance of ClientJsonRpc.
    *
    * @param url_ - The URL of the JSON-RPC server.
    * @param timeout - The timeout for requests in milliseconds
+   * @deprecated Use the concrete Client's `new` or `open` method.
    */
   constructor(url_: string, config?: ClientJsonRpcConfig);
+  /** Creates a Requestor that borrows an existing Transport. */
+  protected static newRequestor(config: Omit<Parameters<typeof RequestorJsonRpc.new>[0], "onError">): RequestorJsonRpc;
+  /** Opens a Requestor with ownership of its default Transport. */
+  protected static openRequestor(config: Omit<Parameters<typeof RequestorJsonRpc.open>[0], "onError">): Owner<RequestorJsonRpc>;
   /**
-   * Returns the URL of the JSON-RPC server.
+   * Returns the legacy primary URL of the JSON-RPC server.
    *
    * @returns The URL of the JSON-RPC server.
+   * @deprecated A Client may use multiple endpoints or a Transport without a
+   * URL, so this value does not reliably identify its connection.
    */
   get url(): string;
   /**
@@ -6802,14 +7171,23 @@ declare abstract class ClientJsonRpc extends Client {
  * @public
  */
 declare class ClientPublicMainnet extends ClientJsonRpc {
-  private readonly config?;
-  constructor(config?: (ClientJsonRpcConfig & {
+  private static defaultUrls;
+  private static resolveConfig;
+  /**
+   * @deprecated Use {@link ClientPublicMainnet.new} with a borrowed Transport or
+   * {@link ClientPublicMainnet.open} when creating Transports.
+   */
+  constructor(config?: ClientJsonRpcConfig & {
+    /** @deprecated URL belongs to Transport construction. */
     url?: string;
-    scripts?: Record<KnownScript, ScriptInfoLike | undefined>;
-  }) | undefined);
-  get scripts(): Record<KnownScript, ScriptInfoLike | undefined>;
+  });
+  /** Creates a Client that borrows an existing Transport. */
+  static new(config: Omit<Parameters<typeof RequestorJsonRpc.new>[0], "onError"> & ClientConfig): ClientPublicMainnet;
+  /** Opens a Client with explicit ownership of its default dependencies. */
+  static open(config?: Omit<Parameters<typeof RequestorJsonRpc.open>[0], "onError" | "urls"> & ClientConfig & {
+    urls?: Parameters<typeof RequestorJsonRpc.open>[0]["urls"];
+  }): Owner<ClientPublicMainnet>;
   get addressPrefix(): string;
-  getKnownScript(script: KnownScript): Promise<ScriptInfo>;
 }
 //#endregion
 //#region src/client/clientPublicTestnet.d.ts
@@ -6817,14 +7195,23 @@ declare class ClientPublicMainnet extends ClientJsonRpc {
  * @public
  */
 declare class ClientPublicTestnet extends ClientJsonRpc {
-  private readonly config?;
-  constructor(config?: (ClientJsonRpcConfig & {
+  private static defaultUrls;
+  private static resolveConfig;
+  /**
+   * @deprecated Use {@link ClientPublicTestnet.new} with a borrowed Transport or
+   * {@link ClientPublicTestnet.open} when creating Transports.
+   */
+  constructor(config?: ClientJsonRpcConfig & {
+    /** @deprecated URL belongs to Transport construction. */
     url?: string;
-    scripts?: Record<KnownScript, ScriptInfoLike | undefined>;
-  }) | undefined);
-  get scripts(): Record<KnownScript, ScriptInfoLike | undefined>;
+  });
+  /** Creates a Client that borrows an existing Transport. */
+  static new(config: Omit<Parameters<typeof RequestorJsonRpc.new>[0], "onError"> & ClientConfig): ClientPublicTestnet;
+  /** Opens a Client with explicit ownership of its default dependencies. */
+  static open(config?: Omit<Parameters<typeof RequestorJsonRpc.open>[0], "onError" | "urls"> & ClientConfig & {
+    urls?: Parameters<typeof RequestorJsonRpc.open>[0]["urls"];
+  }): Owner<ClientPublicTestnet>;
   get addressPrefix(): string;
-  getKnownScript(script: KnownScript): Promise<ScriptInfo>;
 }
 //#endregion
 //#region src/address/address.advanced.d.ts
@@ -7103,9 +7490,14 @@ declare class JsonRpcTransformers {
 //#endregion
 //#region src/hasher/advanced.d.ts
 declare const CKB_BLAKE2B_PERSONAL: Bytes$1;
+//#endregion
+//#region src/jsonRpc/transports/factory.d.ts
+declare function jsonRpcTransportFromUri(uri: string, config?: {
+  timeout?: number;
+}): OwnerUnique<JsonRpcTransportWebSocket> | OwnerUnique<JsonRpcTransportHttp>;
 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 };
+  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, JsonRpcScript, JsonRpcTransaction, JsonRpcTransformers, MAINNET_SCRIPTS, MapLru, NUM_TO_DEP_TYPE, NUM_TO_HASH_TYPE, SignerJsonRpcInfo, SignerJsonRpcInfoPayload, SignerJsonRpcMessageToSign, SignerJsonRpcTransformers, TESTNET_SCRIPTS, addressFromPayload, addressPayloadFromString, clientSearchKeyRangeFrom, filterCell, filterData, filterNumByRange, filterScript, filterScriptByLenRange, jsonRpcTransportFromUri };
 }
 //#endregion
-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-BwJIDnvL.d.mts.map
+export { CellDep as $, OwnerRefCount as $i, messageHashDogeEcdsa as $n, JsonRpcTransport as $r, ClientBlockUncle as $t, filterScriptByLenRange as A, BytesLike as Aa, CodecUint32 as Ai, buildNostrEventFromMessage as An, SignerInfo as Ar, HashTypeCodec as At, addressPayloadFromString as B, codecPadding as Bi, SignerJsonRpcHandler as Bn, barrel_d_exports$1 as Br, ClientConfig as Bt, CellRecord as C, AddressLike as Ca, CodecUint128LE as Ci, TransactionStatus as Cn, messageHashBtcEcdsa as Cr, depTypeFrom as Ct, filterData as D, bytesLenUnsafe as Da, CodecUint256 as Di, DEFAULT_MIN_FEE_RATE as Dn, NetworkPreference as Dr, udtBalanceFrom as Dt, filterCell as E, bytesLen as Ea, CodecUint16LE as Ei, DEFAULT_MAX_FEE_RATE as En, SignerBtc as Er, isDaoOutputLimitExceeded as Et, HASH_TYPE_TO_NUM as F, bytesTo as Fa, CodecUint512LE as Fi, NostrEvent as Fn, Wallet as Fr, ScriptVec as Ft, ClientCacheMemory as G, apply as Gi, SignerJsonRpcMessageToSign as Gn, JsonRpcTransportWebSocket as Gr, epochFromHex as Gt, ClientPublicMainnet as H, codecUintNumber as Hi, buildSignerJsonRpcHandler as Hn, keystoreEncrypt as Hr, Epoch as Ht, NUM_TO_HASH_TYPE as I, BytesFromEncoding as Ia, CodecUint64 as Ii, SignerNostr as In, InputToSign as Ir, hashTypeFrom as It, ErrorTransactionInsufficientCoin as J, reduceAsync as Ji, SignerEvmAddressReadonly as Jn, JsonRpcError as Jr, CellDepInfoLike as Jt, ClientCache as K, gcd as Ki, SignerJsonRpcTransformers as Kn, JsonRpcTransportHttp as Kr, epochToHex as Kt, ADDRESS_BECH32_LIMIT as L, CodecUint64BE as Li, SignerJsonRpc as Ln, InputToSignLike as Lr, hashTypeFromBytes as Lt, DEP_TYPE_TO_NUM as M, bytesConcatTo as Ma, CodecUint32LE as Mi, verifyMessageNostrEvent as Mn, SignerMultisigNotEnoughSignaturesError as Mr, Script as Mt, NUM_TO_DEP_TYPE as N, bytesEq as Na, CodecUint512 as Ni, SignerNostrPrivateKey as Nn, SignerSignType as Nr, ScriptLike as Nt, filterNumByRange as O, hexFrom as Oa, CodecUint256BE as Oi, clientSearchKeyRangeFrom as On, Signature as Or, LumosTransactionSkeletonType as Ot, HASH_TYPES as P, bytesFrom as Pa, CodecUint512BE as Pi, SignerNostrPublicKeyReadonly as Pn, SignerType as Pr, ScriptOpt as Pt, CellAnyLike as Q, OwnerUnique as Qi, SignerDummy as Qn, JsonRpcResponse as Qr, ClientBlockLike as Qt, AddressFormat as R, CodecUint64LE as Ri, SignerJsonRpcConfig as Rn, SignPsbtOptions as Rr, hashTypeToBytes as Rt, MAINNET_SCRIPTS as S, Address as Sa, CodecUint128BE as Si, ScriptInfoLike as Sn, btcVarLengthBytesFrom as Sr, calcDaoProfit as St, MapLru as T, HexLike as Ta, CodecUint16BE as Ti, ClientCollectableSearchKeyLike as Tn, SignerBtcPublicKeyReadonly as Tr, depTypeToBytes as Tt, ClientJsonRpc as U, Entity as Ui, SignerJsonRpcInfo as Un, RequestorJsonRpc as Ur, EpochLike as Ut, ClientPublicTestnet as V, codecUint as Vi, SignerJsonRpcHandlerConfig as Vn, keystoreDecrypt as Vr, KnownScript as Vt, ClientJsonRpcConfig as W, codec as Wi, SignerJsonRpcInfoPayload as Wn, RequestorJsonRpcConfig as Wr, epochFrom as Wt, Cell as X, stringify as Xi, SignerOpenLink as Xn, JsonRpcId as Xr, ClientBlockHeader as Xt, hashTypeId as Y, sleep as Yi, SignerEvm as Yn, JsonRpcErrorLike as Yr, ClientBlock as Yt, CellAny as Z, Proxy as Zi, SignerAlwaysError as Zn, JsonRpcPayload as Zr, ClientBlockHeaderLike as Zt, JsonRpcIndexerSearchKeyTransaction as _, numToHex as _a, CodecByte4 as _i, ErrorClientResolveUnknown as _n, verifyMessageCkbSecp256k1 as _r, Transaction as _t, JsonRpcBlock as a, abortSignalAny as aa, hashCkbShort as ai, ClientIndexerSearchKeyFilter as an, SignerMultisigCkbPrivateKey as ar, CellLike as at, JsonRpcTransaction as b, DecodedType as ba, CodecRaw as bi, OutputsValidator as bn, btcP2pkhAddressFromPublicKey as br, WitnessArgsLike as bt, JsonRpcCellDep as c, numBeFromBytes as ca, FixedPointLike as ci, ClientIndexerSearchKeyTransaction as cn, SignerMultisigCkbReadonly as cr, CellOutputVec as ct, JsonRpcDepType as d, numFromBytes as da, fixedPointFrom as di, ClientTransactionResponseLike as dn, SignerCkbPublicKey as dr, DepTypeLike as dt, OwnerAggregated as ea, HasherKeecak256 as ei, ClientBlockUncleLike as en, verifyMessageDogeEcdsa as er, CellDepLike as et, JsonRpcHashType as f, numLeFromBytes as fa, fixedPointToString as fi, ErrorClientBase as fn, SignerCkbAlwaysSuccess as fr, OutPoint as ft, JsonRpcIndexerSearchKeyFilter as g, numToBytes as ga, CodecByte32 as gi, ErrorClientRBFRejected as gn, signMessageSecp256k1 as gr, SinceLike as gt, JsonRpcIndexerSearchKey as h, numMin as ha, CodecByte16 as hi, ErrorClientMaxFeeRateExceeded as hn, recoverMessageSecp256k1 as hr, Since as ht, JsonRpcTransformers as i, Constructor as ia, hashCkb as ii, ClientIndexerSearchKey as in, verifyMessageJoyId as ir, CellInputVec as it, DEP_TYPES as j, bytesConcat as ja, CodecUint32BE as ji, nostrEventHash as jn, SignerMultisig as jr, HashTypeLike as jt, filterScript as k, Bytes$1 as ka, CodecUint256LE as ki, barrel_d_exports as kn, Signer as kr, HashType as kt, JsonRpcCellInput as l, numBeToBytes as la, One as li, ClientIndexerSearchKeyTransactionLike as ln, SignerCkbScriptReadonly as lr, DepType as lt, JsonRpcIndexerFindTransactionsResponse as m, numMax as ma, CodecByte as mi, ErrorClientDuplicatedTransaction as mn, messageHashCkbSecp256k1 as mr, RawTransaction as mt, jsonRpcTransportFromUri as n, OwnerMoved as na, HASH_CKB_SHORT_LENGTH as ni, ClientFindTransactionsGroupedResponse as nn, SignerDogeAddressReadonly as nr, CellInput as nt, JsonRpcBlockHeader as o, Num as oa, Hasher as oi, ClientIndexerSearchKeyFilterLike as on, MultisigCkbWitness as or, CellOutput as ot, JsonRpcIndexerFindTransactionsGroupedResponse as p, numLeToBytes as pa, CodecBool as pi, ErrorClientBaseLike as pn, SECP256K1_SIGNATURE_LENGTH as pr, OutPointLike as pt, ErrorTransactionInsufficientCapacity as q, isWebview as qi, verifyMessageEvmPersonal as qn, JsonRpcTransportFallback as qr, CellDepInfo as qt, CKB_BLAKE2B_PERSONAL as r, AbstractConstructor as ra, HasherCkb as ri, ClientFindTransactionsResponse as rn, SignerDoge as rr, CellInputLike as rt, JsonRpcBlockUncle as s, NumLike as sa, FixedPoint as si, ClientIndexerSearchKeyLike as sn, MultisigCkbWitnessLike as sr, CellOutputLike as st, advancedBarrel_d_exports as t, Owner as ta, HASH_CKB_LENGTH as ti, ClientFindCellsResponse as tn, SignerDogePrivateKey as tr, CellDepVec as tt, JsonRpcCellOutput as u, numFrom as ua, Zero as ui, ClientTransactionResponse as un, SignerCkbPrivateKey as ur, DepTypeCodec as ut, JsonRpcOutPoint as v, Codec as va, CodecByte8 as vi, ErrorClientVerification as vn, verifyMessageSecp256k1 as vr, TransactionLike as vt, DEFAULT_CONFIRMED_BLOCK_TIME as w, Hex as wa, CodecUint16 as wi, ClientCollectableSearchKeyFilterLike as wn, verifyMessageBtcEcdsa as wr, depTypeFromBytes as wt, TESTNET_SCRIPTS as x, EncodableType as xa, CodecUint128 as xi, ScriptInfo as xn, btcPublicKeyFromP2pkhAddress as xr, calcDaoClaimEpoch as xt, JsonRpcScript as y, CodecLike as ya, CodecBytes as yi, ErrorClientWaitTransactionTimeout as yn, btcEcdsaPublicKeyHash as yr, WitnessArgs as yt, addressFromPayload as z, CodecUint8 as zi, SignerJsonRpcConfirmation as zn, SignPsbtOptionsLike as zr, Client as zt };
+//# sourceMappingURL=advancedBarrel-B57gAzdK.d.ts.map