@ckb-ccc/core 0.0.5-alpha.8 → 0.0.7-alpha.0

package/dist/ckb/transaction.js

@@ -1,8 +1,9 @@
 import { bytesFrom } from "../bytes";
+import { Zero, fixedPointFrom } from "../fixedPoint";
 import { Hasher, ckbHash } from "../hasher";
 import { hexFrom } from "../hex";
 import { numFrom, numFromBytes, numToBytes, numToHex, } from "../num";
-import { apply } from "../utils";
+import { apply, reduceAsync } from "../utils";
 import * as mol from "./molecule.advanced";
 import { Script } from "./script";
 import { DEP_TYPE_TO_NUM, NUM_TO_DEP_TYPE } from "./transaction.advanced";
@@ -76,6 +77,19 @@ export class OutPoint {
         this.txHash = txHash;
         this.index = index;
     }
+    /**
+     * Clone an OutPoint.
+     *
+     * @returns A cloned OutPoint instance.
+     *
+     * @example
+     * ```typescript
+     * const outPoint1 = outPoint0.clone();
+     * ```
+     */
+    clone() {
+        return new OutPoint(this.txHash, this.index);
+    }
     /**
      * Creates an OutPoint instance from an OutPointLike object.
      *
@@ -111,10 +125,10 @@ export class OutPoint {
      *
      * @example
      * ```typescript
-     * const outPointBytes = outPoint.encode();
+     * const outPointBytes = outPoint.toBytes();
      * ```
      */
-    encode() {
+    toBytes() {
         return bytesFrom(mol.SerializeOutPoint(this._toMolData()));
     }
     /**
@@ -134,6 +148,21 @@ export class OutPoint {
             : new mol.OutPoint(bytesFrom(bytes));
         return new OutPoint(hexFrom(view.getTxHash().raw()), numFromBytes(view.getIndex().raw()));
     }
+    /**
+     * Compares the current OutPoint instance with another OutPointLike object for equality.
+     *
+     * @param val - The OutPointLike object to compare with.
+     * @returns True if the out points are equal, otherwise false.
+     *
+     * @example
+     * ```typescript
+     * const isEqual = outPoint.eq(anotherOutPoint);
+     * ```
+     */
+    eq(val) {
+        const outPoint = OutPoint.from(val);
+        return this.txHash === outPoint.txHash && this.index === outPoint.index;
+    }
 }
 export class CellOutput {
     /**
@@ -148,6 +177,22 @@ export class CellOutput {
         this.lock = lock;
         this.type = type;
     }
+    get occupiedSize() {
+        return 8 + this.lock.occupiedSize + (this.type?.occupiedSize ?? 0);
+    }
+    /**
+     * Clone a CellOutput.
+     *
+     * @returns A cloned CellOutput instance.
+     *
+     * @example
+     * ```typescript
+     * const cellOutput1 = cellOutput0.clone();
+     * ```
+     */
+    clone() {
+        return new CellOutput(this.capacity, this.lock.clone(), this.type?.clone());
+    }
     /**
      * Creates a CellOutput instance from a CellOutputLike object.
      *
@@ -219,13 +264,11 @@ export class 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.
-     * @param blockNumber - The block number of the cell.
      */
-    constructor(outPoint, cellOutput, outputData, blockNumber) {
+    constructor(outPoint, cellOutput, outputData) {
         this.outPoint = outPoint;
         this.cellOutput = cellOutput;
         this.outputData = outputData;
-        this.blockNumber = blockNumber;
     }
     /**
      * Creates a Cell instance from a CellLike object.
@@ -237,7 +280,20 @@ export class Cell {
         if (cell instanceof Cell) {
             return cell;
         }
-        return new Cell(OutPoint.from(cell.outPoint), CellOutput.from(cell.cellOutput), hexFrom(cell.outputData), numFrom(cell.blockNumber));
+        return new Cell(OutPoint.from(cell.outPoint), CellOutput.from(cell.cellOutput), hexFrom(cell.outputData));
+    }
+    /**
+     * Clone a Cell
+     *
+     * @returns A cloned Cell instance.
+     *
+     * @example
+     * ```typescript
+     * const cell1 = cell0.clone();
+     * ```
+     */
+    clone() {
+        return new Cell(this.outPoint.clone(), this.cellOutput.clone(), this.outputData);
     }
 }
 export class CellInput {
@@ -248,14 +304,25 @@ export class CellInput {
      * @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 blockNumber - The optional block number associated with the cell input.
      */
-    constructor(previousOutput, since, cellOutput, outputData, blockNumber) {
+    constructor(previousOutput, since, cellOutput, outputData) {
         this.previousOutput = previousOutput;
         this.since = since;
         this.cellOutput = cellOutput;
         this.outputData = outputData;
-        this.blockNumber = blockNumber;
+    }
+    /**
+     * Clone a CellInput.
+     *
+     * @returns A cloned CellInput instance.
+     *
+     * @example
+     * ```typescript
+     * const cellInput1 = cellInput0.clone();
+     * ```
+     */
+    clone() {
+        return new CellInput(this.previousOutput.clone(), this.since, this.cellOutput?.clone(), this.outputData);
     }
     /**
      * Creates a CellInput instance from a CellInputLike object.
@@ -275,31 +342,28 @@ export class CellInput {
         if (cellInput instanceof CellInput) {
             return cellInput;
         }
-        return new CellInput(OutPoint.from(cellInput.previousOutput), numFrom(cellInput.since), apply(CellOutput.from, cellInput.cellOutput), apply(hexFrom, cellInput.outputData), apply(numFrom, cellInput.blockNumber));
+        return new CellInput(OutPoint.from(cellInput.previousOutput), numFrom(cellInput.since ?? 0), apply(CellOutput.from, cellInput.cellOutput), apply(hexFrom, cellInput.outputData));
     }
     /**
      * Complete extra infos in the input. Like the output of the out point.
      * The instance will be modified.
      *
-     * @returns The completed instance.
+     * @returns true if succeed.
      * @example
      * ```typescript
-     * if (!cellInput.cellOutput) {
-     *   await cellInput.completeExtraInfos();
-     * }
+     * await cellInput.completeExtraInfos();
      * ```
      */
     async completeExtraInfos(client) {
-        if (this.cellOutput && this.outputData && this.blockNumber) {
-            return this;
+        if (this.cellOutput && this.outputData) {
+            return;
         }
         const cell = await client.getCell(this.previousOutput);
-        if (cell) {
-            this.cellOutput = cell.cellOutput;
-            this.outputData = cell.outputData;
-            this.blockNumber = cell.blockNumber;
+        if (!cell) {
+            return;
         }
-        return this;
+        this.cellOutput = cell.cellOutput;
+        this.outputData = cell.outputData;
     }
     /**
      * Converts the CellInput instance to molecule data format.
@@ -354,6 +418,19 @@ export class CellDep {
         this.outPoint = outPoint;
         this.depType = depType;
     }
+    /**
+     * Clone a CellDep.
+     *
+     * @returns A cloned CellDep instance.
+     *
+     * @example
+     * ```typescript
+     * const cellDep1 = cellDep0.clone();
+     * ```
+     */
+    clone() {
+        return new CellDep(this.outPoint.clone(), this.depType);
+    }
     /**
      * Creates a CellDep instance from a CellDepLike object.
      *
@@ -413,6 +490,21 @@ export class CellDep {
         const view = bytes instanceof mol.CellDep ? bytes : new mol.CellDep(bytesFrom(bytes));
         return new CellDep(OutPoint.fromBytes(view.getOutPoint()), depTypeFromBytes([view.getDepType()]));
     }
+    /**
+     * Compares the current CellDep instance with another CellDepLike object for equality.
+     *
+     * @param val - The CellDepLike object to compare with.
+     * @returns True if the cell deps are equal, otherwise false.
+     *
+     * @example
+     * ```typescript
+     * const isEqual = cellDep.eq(anotherCellDep);
+     * ```
+     */
+    eq(val) {
+        const cellDep = CellDep.from(val);
+        return (this.outPoint.eq(cellDep.outPoint) && this.depType === cellDep.depType);
+    }
 }
 export class WitnessArgs {
     /**
@@ -491,6 +583,13 @@ export class WitnessArgs {
         return new WitnessArgs(apply(hexFrom, mol.molOptional(view.getLock())?.raw()), apply(hexFrom, mol.molOptional(view.getInputType())?.raw()), apply(hexFrom, mol.molOptional(view.getOutputType())?.raw()));
     }
 }
+export function udtBalanceFrom(dataLike) {
+    const data = bytesFrom(dataLike).slice(0, 16);
+    if (data.length !== 16) {
+        throw new Error("Invalid UDT cell data");
+    }
+    return numFromBytes(data);
+}
 export class Transaction {
     /**
      * Creates an instance of Transaction.
@@ -525,6 +624,37 @@ export class Transaction {
     static default() {
         return new Transaction(0n, [], [], [], [], [], []);
     }
+    /**
+     * Copy every properties from another transaction.
+     *
+     * @example
+     * ```typescript
+     * this.copy(Transaction.default());
+     * ```
+     */
+    copy(txLike) {
+        const tx = Transaction.from(txLike);
+        this.version = tx.version;
+        this.cellDeps = tx.cellDeps;
+        this.headerDeps = tx.headerDeps;
+        this.inputs = tx.inputs;
+        this.outputs = tx.outputs;
+        this.outputsData = tx.outputsData;
+        this.witnesses = tx.witnesses;
+    }
+    /**
+     * Clone a Transaction.
+     *
+     * @returns A cloned instance
+     *
+     * @example
+     * ```typescript
+     * const tx1 = tx0.clone();
+     * ```
+     */
+    clone() {
+        return new Transaction(0n, this.cellDeps.map((c) => c.clone()), [...this.headerDeps], this.inputs.map((i) => i.clone()), this.outputs.map((o) => o.clone()), [...this.outputsData], [...this.witnesses]);
+    }
     /**
      * Creates a Transaction instance from a TransactionLike object.
      *
@@ -548,7 +678,20 @@ export class Transaction {
         if (tx instanceof Transaction) {
             return tx;
         }
-        return new Transaction(numFrom(tx.version), tx.cellDeps.map((cellDep) => CellDep.from(cellDep)), tx.headerDeps.map(hexFrom), tx.inputs.map((input) => CellInput.from(input)), tx.outputs.map((output) => CellOutput.from(output)), tx.outputsData.map(hexFrom), tx.witnesses.map(hexFrom));
+        const outputs = tx.outputs?.map((output, i) => {
+            const o = CellOutput.from({
+                ...output,
+                capacity: output.capacity ?? 0,
+            });
+            o.capacity = fixedPointFrom(o.occupiedSize + (apply(bytesFrom, tx.outputsData?.[i])?.length ?? 0));
+            return o;
+        }) ?? [];
+        const outputsData = outputs.map((_, i) => hexFrom(tx.outputsData?.[i] ?? "0x"));
+        if (tx.outputsData !== undefined &&
+            outputsData.length < tx.outputsData.length) {
+            outputsData.push(...tx.outputsData.slice(outputsData.length).map((d) => hexFrom(d)));
+        }
+        return new Transaction(numFrom(tx.version ?? 0), tx.cellDeps?.map((cellDep) => CellDep.from(cellDep)) ?? [], tx.headerDeps?.map(hexFrom) ?? [], tx.inputs?.map((input) => CellInput.from(input)) ?? [], outputs, outputsData, tx.witnesses?.map(hexFrom) ?? []);
     }
     /**
      * Creates a Transaction instance from a Lumos skeleton.
@@ -612,6 +755,29 @@ export class Transaction {
             outputsData: this.outputsData.map((header) => bytesFrom(header)),
         }));
     }
+    /**
+     * Converts the whole transaction data to bytes.
+     *
+     * @returns A Uint8Array containing the full transaction bytes.
+     *
+     * @example
+     * ```typescript
+     * const txBytes = transaction.toBytes();
+     * ```
+     */
+    toBytes() {
+        return bytesFrom(mol.SerializeTransaction({
+            raw: {
+                version: numToBytes(this.version, 4),
+                cellDeps: this.cellDeps.map((d) => d._toMolData()),
+                headerDeps: this.headerDeps.map((header) => bytesFrom(header)),
+                inputs: this.inputs.map((i) => i._toMolData()),
+                outputs: this.outputs.map((o) => o._toMolData()),
+                outputsData: this.outputsData.map((header) => bytesFrom(header)),
+            },
+            witnesses: this.witnesses.map((witness) => bytesFrom(witness)),
+        }));
+    }
     /**
      * Calculates the hash of the transaction.
      *
@@ -664,10 +830,11 @@ export class Transaction {
         const hasher = new Hasher();
         hasher.update(this.hash());
         for (let i = 0; i < this.witnesses.length; i += 1) {
-            if (this.inputs[i]) {
-                const input = await this.inputs[i].completeExtraInfos(client);
+            const input = await this.inputs[i];
+            await input.completeExtraInfos(client);
+            if (input) {
                 if (!input.cellOutput) {
-                    throw Error("Unable to resolve inputs info");
+                    throw new Error("Unable to complete input");
                 }
                 if (!script.eq(input.cellOutput.lock)) {
                     continue;
@@ -704,15 +871,129 @@ export class Transaction {
     async findInputIndexByLock(scriptLike, client) {
         const script = Script.from(scriptLike);
         for (let i = 0; i < this.inputs.length; i += 1) {
-            const input = await this.inputs[i].completeExtraInfos(client);
+            const input = this.inputs[i];
+            await input.completeExtraInfos(client);
             if (!input.cellOutput) {
-                throw Error("Unable to resolve inputs info");
+                throw new Error("Unable to complete input");
             }
             if (script.eq(input.cellOutput.lock)) {
                 return i;
             }
         }
     }
+    /**
+     * 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 prepared transaction
+     *
+     * @example
+     * ```typescript
+     * const index = await tx.findLastInputIndexByLock(scriptLike, client);
+     * ```
+     */
+    async findLastInputIndexByLock(scriptLike, client) {
+        const script = Script.from(scriptLike);
+        for (let i = this.inputs.length - 1; i >= 0; i -= 1) {
+            const input = this.inputs[i];
+            await input.completeExtraInfos(client);
+            if (!input.cellOutput) {
+                throw new Error("Unable to complete input");
+            }
+            if (script.eq(input.cellOutput.lock)) {
+                return i;
+            }
+        }
+    }
+    /**
+     * Add cell deps if they are not existed
+     *
+     * @param cellDepLikes - The cell deps to add
+     *
+     * @example
+     * ```typescript
+     * tx.addCellDeps(cellDep);
+     * ```
+     */
+    addCellDeps(...cellDepsLike) {
+        cellDepsLike.flat().forEach((cellDepLike) => {
+            const cellDep = CellDep.from(cellDepLike);
+            if (this.cellDeps.some((c) => c.eq(cellDep))) {
+                return;
+            }
+            this.cellDeps.push(cellDep);
+        });
+    }
+    /**
+     * Add cell dep from infos if they are not existed
+     *
+     * @param client - A client for searching cell deps
+     * @param cellDepLikes - The cell dep infos to add
+     *
+     * @example
+     * ```typescript
+     * tx.addCellDepInfos(client, cellDepInfos);
+     * ```
+     */
+    async addCellDepInfos(client, ...cellDepInfosLike) {
+        this.addCellDeps(await client.getCellDeps(...cellDepInfosLike));
+    }
+    /**
+     * Add cell deps from known script
+     *
+     * @param client - The client for searching known script and cell deps
+     * @param scripts - The known scripts to add
+     *
+     * @example
+     * ```typescript
+     * tx.addCellDepsOfKnownScripts(client, KnownScript.OmniLock);
+     * ```
+     */
+    async addCellDepsOfKnownScripts(client, ...scripts) {
+        await Promise.all(scripts
+            .flat()
+            .map(async (script) => this.addCellDepInfos(client, (await client.getKnownScript(script)).cellDeps)));
+    }
+    /**
+     * Set output data at index.
+     *
+     * @param index - The index of the output data.
+     * @param witness - The data to set.
+     *
+     * @example
+     * ```typescript
+     * await tx.setOutputData(0, "0x00");
+     * ```
+     */
+    setOutputDataAt(index, data) {
+        if (this.outputsData.length < index) {
+            this.outputsData.push(...Array.from(new Array(index - this.outputsData.length), () => "0x"));
+        }
+        this.outputsData[index] = hexFrom(data);
+    }
+    /**
+     * Add output
+     *
+     * @param output - The cell output to add
+     * @param data - optional output data
+     *
+     * @example
+     * ```typescript
+     * await tx.addOutput(cellOutput, "0xabcd");
+     * ```
+     */
+    addOutput(outputLike, outputData = "0x") {
+        const output = CellOutput.from({
+            ...outputLike,
+            capacity: outputLike.capacity ?? 0,
+        });
+        if (output.capacity === Zero) {
+            output.capacity = fixedPointFrom(output.occupiedSize + bytesFrom(outputData).length);
+        }
+        const i = this.outputs.push(output) - 1;
+        this.setOutputDataAt(i, outputData);
+    }
     /**
      * Get witness at index as WitnessArgs
      *
@@ -735,7 +1016,6 @@ export class Transaction {
      *
      * @param index - The index of the witness.
      * @param witness - The WitnessArgs to set.
-     * @returns The transaction itself.
      *
      * @example
      * ```typescript
@@ -747,7 +1027,6 @@ export class Transaction {
             this.witnesses.push(...Array.from(new Array(index - this.witnesses.length), () => "0x"));
         }
         this.witnesses[index] = hexFrom(witness.toBytes());
-        return this;
     }
     /**
      * Prepare dummy witness for sighash all method
@@ -765,10 +1044,171 @@ export class Transaction {
     async prepareSighashAllWitness(scriptLike, lockLen, client) {
         const position = await this.findInputIndexByLock(scriptLike, client);
         if (position === undefined) {
-            return this;
+            return;
         }
         const witness = this.getWitnessArgsAt(position) ?? WitnessArgs.from({});
         witness.lock = hexFrom(Array.from(new Array(lockLen), () => 0));
-        return this.setWitnessArgsAt(position, witness);
+        this.setWitnessArgsAt(position, witness);
+    }
+    async getInputsCapacity(client) {
+        return reduceAsync(this.inputs, async (acc, input) => {
+            await input.completeExtraInfos(client);
+            if (!input.cellOutput) {
+                throw new Error("Unable to complete input");
+            }
+            return acc + input.cellOutput.capacity;
+        }, numFrom(0));
+    }
+    getOutputsCapacity() {
+        return this.outputs.reduce((acc, { capacity }) => acc + capacity, numFrom(0));
+    }
+    async getInputsUdtBalance(client, type) {
+        return reduceAsync(this.inputs, async (acc, input) => {
+            await input.completeExtraInfos(client);
+            if (!input.cellOutput || !input.outputData) {
+                throw new Error("Unable to complete input");
+            }
+            if (!input.cellOutput.type?.eq(type)) {
+                return;
+            }
+            return acc + udtBalanceFrom(input.outputData);
+        }, numFrom(0));
+    }
+    getOutputsUdtBalance(type) {
+        return this.outputs.reduce((acc, output, i) => {
+            if (!output.type?.eq(type)) {
+                return acc;
+            }
+            return acc + udtBalanceFrom(this.outputsData[i]);
+        }, numFrom(0));
+    }
+    async completeInputs(from, filter, accumulator, init) {
+        const scripts = (await from.getAddressObjs()).map(({ script }) => script);
+        const collectedCells = [];
+        let acc = init;
+        for (const script of scripts) {
+            for await (const cell of from.client.findCellsByCollectableSearchKey({
+                script,
+                scriptType: "lock",
+                filter,
+                scriptSearchMode: "exact",
+                withData: true,
+            })) {
+                if (this.inputs.some(({ previousOutput }) => previousOutput.eq(cell.outPoint))) {
+                    continue;
+                }
+                const i = collectedCells.push(cell);
+                const next = await Promise.resolve(accumulator(acc, cell, i - 1, collectedCells));
+                if (next === undefined) {
+                    this.inputs.push(...collectedCells.map(({ outPoint, outputData, cellOutput }) => CellInput.from({
+                        previousOutput: outPoint,
+                        since: 0,
+                        outputData,
+                        cellOutput,
+                    })));
+                    return collectedCells.length;
+                }
+                acc = next;
+            }
+        }
+        throw new Error("Failed to find enough cells for input");
+    }
+    async completeInputsByCapacity(from, capacityTweak, filter) {
+        const exceptedCapacity = this.getOutputsCapacity() + numFrom(capacityTweak ?? 0);
+        const inputsCapacity = await this.getInputsCapacity(from.client);
+        if (inputsCapacity >= exceptedCapacity) {
+            return 0;
+        }
+        return this.completeInputs(from, filter ?? {
+            scriptLenRange: [0, 1],
+            outputDataLenRange: [0, 1],
+        }, (acc, { cellOutput: { capacity } }) => {
+            const sum = acc + capacity;
+            return sum > exceptedCapacity ? undefined : sum;
+        }, inputsCapacity);
+    }
+    async completeInputsByUdt(from, type) {
+        const exceptedBalance = this.getOutputsUdtBalance(type);
+        const inputsBalance = await this.getInputsUdtBalance(from.client, type);
+        if (inputsBalance >= exceptedBalance) {
+            return 0;
+        }
+        return this.completeInputs(from, {
+            script: type,
+            outputDataLenRange: [16, numFrom("0xffffffff")],
+        }, (acc, { outputData }) => {
+            const balance = udtBalanceFrom(outputData);
+            const sum = acc + balance;
+            return sum > exceptedBalance ? undefined : sum;
+        }, inputsBalance);
+    }
+    estimateFee(feeRate) {
+        const txSize = this.toBytes().length + 4;
+        return (numFrom(txSize) * numFrom(feeRate) + numFrom(1000)) / numFrom(1000);
+    }
+    async completeFee(from, change, feeRate, filter) {
+        // Complete all inputs extra infos for cache
+        await this.getInputsCapacity(from.client);
+        let leastFee = this.estimateFee(feeRate);
+        let leastExtraCapacity = Zero;
+        while (true) {
+            const prepared = await from.prepareTransaction(this.clone());
+            const collected = await prepared.completeInputsByCapacity(from, leastFee + leastExtraCapacity, filter);
+            const extraCapacity = (await prepared.getInputsCapacity(from.client)) -
+                prepared.getOutputsCapacity();
+            // The extra capacity paid the fee without a change
+            if (extraCapacity === leastFee) {
+                this.copy(prepared);
+                return [collected, false];
+            }
+            let changed = prepared.clone();
+            const needed = numFrom(await Promise.resolve(change(changed, extraCapacity - leastFee)));
+            // No enough extra capacity to create new cells for change
+            if (needed > Zero) {
+                leastExtraCapacity = needed;
+                continue;
+            }
+            if ((await changed.getInputsCapacity(from.client)) -
+                changed.getOutputsCapacity() !==
+                leastFee) {
+                throw new Error("The change function doesn't use all available capacity");
+            }
+            // New change cells created, update the fee
+            await from.prepareTransaction(changed);
+            const changedFee = changed.estimateFee(feeRate);
+            if (leastFee > changedFee) {
+                throw new Error("The change function removed existed transaction data");
+            }
+            // The fee has been paid
+            if (leastFee === changedFee) {
+                this.copy(changed);
+                return [collected, true];
+            }
+            // The fee after changing is more than the original fee
+            leastFee = changedFee;
+        }
+    }
+    completeFeeChangeToLock(from, change, feeRate, filter) {
+        const script = Script.from(change);
+        return this.completeFee(from, (tx, capacity) => {
+            const changeCell = CellOutput.from({ capacity: 0, lock: script });
+            const occupiedCapacity = fixedPointFrom(changeCell.occupiedSize);
+            if (capacity < occupiedCapacity) {
+                return occupiedCapacity;
+            }
+            changeCell.capacity = capacity;
+            tx.addOutput(changeCell);
+            return 0;
+        }, feeRate, filter);
+    }
+    completeFeeChangeToOutput(from, index, feeRate, filter) {
+        const change = Number(numFrom(index));
+        if (!this.outputs[change]) {
+            throw new Error("Non-existed output to change");
+        }
+        return this.completeFee(from, (tx, capacity) => {
+            tx.outputs[change].capacity += capacity;
+            return 0;
+        }, feeRate, filter);
     }
 }

package/dist/client/advanced.d.ts

@@ -1,4 +1,6 @@
+export * from "./client.advanced";
 export * from "./clientPublicMainnet.advanced";
 export * from "./clientPublicTestnet.advanced";
+export * from "./clientTypes.advanced";
 export * from "./jsonRpc/advanced";
 //# sourceMappingURL=advanced.d.ts.map

package/dist/client/advanced.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"advanced.d.ts","sourceRoot":"","sources":["../../src/client/advanced.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"advanced.d.ts","sourceRoot":"","sources":["../../src/client/advanced.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC"}

package/dist/client/advanced.js

@@ -1,3 +1,5 @@
+export * from "./client.advanced";
 export * from "./clientPublicMainnet.advanced";
 export * from "./clientPublicTestnet.advanced";
+export * from "./clientTypes.advanced";
 export * from "./jsonRpc/advanced";