@ckb-ccc/core 0.0.4-alpha.1 → 0.0.4-alpha.12

package/dist/ckb/transaction.js

@@ -6,6 +6,20 @@ import { apply } from "../utils";
 import * as mol from "./molecule.advanced";
 import { Script } from "./script";
 import { DEP_TYPE_TO_NUM, NUM_TO_DEP_TYPE } from "./transaction.advanced";
+/**
+ * Converts a DepTypeLike value to a DepType.
+ *
+ * @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"
+ * ```
+ */
 export function depTypeFrom(val) {
     const depType = (() => {
         if (typeof val === "number") {
@@ -21,32 +35,99 @@ export function depTypeFrom(val) {
     }
     return depType;
 }
+/**
+ * Converts a DepTypeLike value to its corresponding byte representation.
+ *
+ * @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]
+ * ```
+ */
 export function depTypeToBytes(depType) {
-    return bytesFrom([DEP_TYPE_TO_NUM[depType]]);
+    return bytesFrom([DEP_TYPE_TO_NUM[depTypeFrom(depType)]]);
 }
+/**
+ * Converts a byte-like value to a DepType.
+ *
+ * @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"
+ * ```
+ */
 export function depTypeFromBytes(bytes) {
     return NUM_TO_DEP_TYPE[bytesFrom(bytes)[0]];
 }
 export class OutPoint {
+    /**
+     * Creates an instance of OutPoint.
+     *
+     * @param txHash - The transaction hash.
+     * @param index - The index of the output in the transaction.
+     */
     constructor(txHash, index) {
         this.txHash = txHash;
         this.index = index;
     }
+    /**
+     * Creates an OutPoint instance from an OutPointLike object.
+     *
+     * @param outPoint - An OutPointLike object or an instance of OutPoint.
+     * @returns An OutPoint instance.
+     *
+     * @example
+     * ```typescript
+     * const outPoint = OutPoint.from({ txHash: "0x...", index: 0 });
+     * ```
+     */
     static from(outPoint) {
         if (outPoint instanceof OutPoint) {
             return outPoint;
         }
         return new OutPoint(hexFrom(outPoint.txHash), numFrom(outPoint.index));
     }
+    /**
+     * Converts the OutPoint instance to molecule data format.
+     *
+     * @returns An object representing the outpoint in molecule data format.
+     */
     _toMolData() {
         return {
             txHash: bytesFrom(this.txHash),
             index: numToBytes(this.index, 4),
         };
     }
+    /**
+     * Converts the OutPoint instance to bytes.
+     *
+     * @returns A Uint8Array containing the outpoint bytes.
+     *
+     * @example
+     * ```typescript
+     * const outPointBytes = outPoint.encode();
+     * ```
+     */
     encode() {
         return bytesFrom(mol.SerializeOutPoint(this._toMolData()));
     }
+    /**
+     * Creates an OutPoint instance from a byte-like value or molecule OutPoint.
+     *
+     * @param bytes - The byte-like value or molecule OutPoint to convert.
+     * @returns An OutPoint instance.
+     *
+     * @example
+     * ```typescript
+     * const outPoint = OutPoint.fromBytes(new Uint8Array([/* outpoint bytes *\/]));
+     * ```
+     */
     static fromBytes(bytes) {
         const view = bytes instanceof mol.OutPoint
             ? bytes
@@ -55,17 +136,44 @@ export class OutPoint {
     }
 }
 export class CellOutput {
+    /**
+     * 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, lock, type) {
         this.capacity = capacity;
         this.lock = lock;
         this.type = type;
     }
+    /**
+     * Creates a CellOutput instance from a CellOutputLike object.
+     *
+     * @param cellOutput - A CellOutputLike object or an instance of CellOutput.
+     * @returns A CellOutput instance.
+     *
+     * @example
+     * ```typescript
+     * const cellOutput = CellOutput.from({
+     *   capacity: 1000n,
+     *   lock: { codeHash: "0x...", hashType: "type", args: "0x..." },
+     *   type: { codeHash: "0x...", hashType: "type", args: "0x..." }
+     * });
+     * ```
+     */
     static from(cellOutput) {
         if (cellOutput instanceof CellOutput) {
             return cellOutput;
         }
         return new CellOutput(numFrom(cellOutput.capacity), Script.from(cellOutput.lock), apply(Script.from, cellOutput.type));
     }
+    /**
+     * Converts the CellOutput instance to molecule data format.
+     *
+     * @returns An object representing the cell output in molecule data format.
+     */
     _toMolData() {
         return {
             capacity: numToBytes(this.capacity, 8),
@@ -73,9 +181,30 @@ export class CellOutput {
             type: this.type?._toMolData(),
         };
     }
+    /**
+     * Converts the CellOutput instance to bytes.
+     *
+     * @returns A Uint8Array containing the cell output bytes.
+     *
+     * @example
+     * ```typescript
+     * const cellOutputBytes = cellOutput.toBytes();
+     * ```
+     */
     toBytes() {
         return bytesFrom(mol.SerializeCellOutput(this._toMolData()));
     }
+    /**
+     * Creates a CellOutput instance from a byte-like value or molecule CellOutput.
+     *
+     * @param bytes - The byte-like value or molecule CellOutput to convert.
+     * @returns A CellOutput instance.
+     *
+     * @example
+     * ```typescript
+     * const cellOutput = CellOutput.fromBytes(new Uint8Array([/* cell output bytes *\/]));
+     * ```
+     */
     static fromBytes(bytes) {
         const view = bytes instanceof mol.CellOutput
             ? bytes
@@ -83,28 +212,123 @@ export class CellOutput {
         return new CellOutput(numFromBytes(view.getCapacity().raw()), Script.fromBytes(view.getLock()), apply(Script.fromBytes, mol.molOptional(view.getType())));
     }
 }
+export class Cell {
+    /**
+     * Creates an instance of Cell.
+     *
+     * @param cellOutput - The cell output of the cell.
+     * @param outputData - The output data of the cell.
+     */
+    constructor(cellOutput, outputData) {
+        this.cellOutput = cellOutput;
+        this.outputData = outputData;
+    }
+    /**
+     * Creates a Cell instance from a CellLike object.
+     *
+     * @param cell - A CellLike object or an instance of Cell.
+     * @returns A Cell instance.
+     */
+    static from(cell) {
+        if (cell instanceof Cell) {
+            return cell;
+        }
+        return new Cell(CellOutput.from(cell.cellOutput), hexFrom(cell.outputData));
+    }
+}
 export class CellInput {
+    /**
+     * Creates an instance of CellInput.
+     *
+     * @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.
+     */
     constructor(previousOutput, since, cellOutput, outputData) {
         this.previousOutput = previousOutput;
         this.since = since;
         this.cellOutput = cellOutput;
         this.outputData = outputData;
     }
+    /**
+     * Creates a CellInput instance from a CellInputLike object.
+     *
+     * @param cellInput - A CellInputLike object or an instance of CellInput.
+     * @returns A CellInput instance.
+     *
+     * @example
+     * ```typescript
+     * const cellInput = CellInput.from({
+     *   previousOutput: { txHash: "0x...", index: 0 },
+     *   since: 0n
+     * });
+     * ```
+     */
     static from(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));
     }
+    /**
+     * Complete extra infos in the input. Like the output of the out point.
+     * The instance will be modified.
+     *
+     * @returns The completed instance.
+     * @example
+     * ```typescript
+     * if (!cellInput.cellOutput) {
+     *   await cellInput.completeExtraInfos();
+     * }
+     * ```
+     */
+    async completeExtraInfos(client) {
+        if (this.cellOutput && this.outputData) {
+            return this;
+        }
+        const cell = await client.getCell(this.previousOutput);
+        if (cell) {
+            this.cellOutput = cell.cellOutput;
+            this.outputData = cell.outputData;
+        }
+        return this;
+    }
+    /**
+     * Converts the CellInput instance to molecule data format.
+     *
+     * @returns An object representing the cell input in molecule data format.
+     */
     _toMolData() {
         return {
             previousOutput: this.previousOutput._toMolData(),
             since: numToBytes(this.since, 8),
         };
     }
+    /**
+     * Converts the CellInput instance to bytes.
+     *
+     * @returns A Uint8Array containing the cell input bytes.
+     *
+     * @example
+     * ```typescript
+     * const cellInputBytes = cellInput.toBytes();
+     * ```
+     */
     toBytes() {
         return bytesFrom(mol.SerializeCellInput(this._toMolData()));
     }
+    /**
+     * Creates a CellInput instance from a byte-like value or molecule CellInput.
+     *
+     * @param bytes - The byte-like value or molecule CellInput to convert.
+     * @returns A CellInput instance.
+     *
+     * @example
+     * ```typescript
+     * const cellInput = CellInput.fromBytes(new Uint8Array([/* cell input bytes *\/]));
+     * ```
+     */
     static fromBytes(bytes) {
         const view = bytes instanceof mol.CellInput
             ? bytes
@@ -113,42 +337,115 @@ export class CellInput {
     }
 }
 export class CellDep {
+    /**
+     * Creates an instance of CellDep.
+     *
+     * @param outPoint - The outpoint of the cell dependency.
+     * @param depType - The dependency type.
+     */
     constructor(outPoint, depType) {
         this.outPoint = outPoint;
         this.depType = depType;
     }
+    /**
+     * Creates a CellDep instance from a CellDepLike object.
+     *
+     * @param cellDep - A CellDepLike object or an instance of CellDep.
+     * @returns A CellDep instance.
+     *
+     * @example
+     * ```typescript
+     * const cellDep = CellDep.from({
+     *   outPoint: { txHash: "0x...", index: 0 },
+     *   depType: "depGroup"
+     * });
+     * ```
+     */
     static from(cellDep) {
         if (cellDep instanceof CellDep) {
             return cellDep;
         }
         return new CellDep(OutPoint.from(cellDep.outPoint), depTypeFrom(cellDep.depType));
     }
+    /**
+     * Converts the CellDep instance to molecule data format.
+     *
+     * @returns An object representing the cell dependency in molecule data format.
+     */
     _toMolData() {
         return {
             outPoint: this.outPoint._toMolData(),
             depType: depTypeToBytes(this.depType),
         };
     }
+    /**
+     * Converts the CellDep instance to bytes.
+     *
+     * @returns A Uint8Array containing the cell dependency bytes.
+     *
+     * @example
+     * ```typescript
+     * const cellDepBytes = cellDep.toBytes();
+     * ```
+     */
     toBytes() {
         return bytesFrom(mol.SerializeCellDep(this._toMolData()));
     }
+    /**
+     * Creates a CellDep instance from a byte-like value or molecule CellDep.
+     *
+     * @param bytes - The byte-like value or molecule CellDep to convert.
+     * @returns A CellDep instance.
+     *
+     * @example
+     * ```typescript
+     * const cellDep = CellDep.fromBytes(new Uint8Array([/* cell dep bytes *\/]));
+     * ```
+     */
     fromBytes(bytes) {
         const view = bytes instanceof mol.CellDep ? bytes : new mol.CellDep(bytesFrom(bytes));
         return new CellDep(OutPoint.fromBytes(view.getOutPoint()), depTypeFromBytes([view.getDepType()]));
     }
 }
 export class WitnessArgs {
+    /**
+     * Creates an instance of WitnessArgs.
+     *
+     * @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, inputType, outputType) {
         this.lock = lock;
         this.inputType = inputType;
         this.outputType = outputType;
     }
+    /**
+     * 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 witnessArgs = WitnessArgs.from({
+     *   lock: "0x...",
+     *   inputType: "0x...",
+     *   outputType: "0x..."
+     * });
+     * ```
+     */
     static from(witnessArgs) {
         if (witnessArgs instanceof WitnessArgs) {
             return witnessArgs;
         }
         return new WitnessArgs(apply(hexFrom, witnessArgs.lock), apply(hexFrom, witnessArgs.inputType), apply(hexFrom, witnessArgs.outputType));
     }
+    /**
+     * Converts the WitnessArgs instance to molecule data format.
+     *
+     * @returns An object representing the witness arguments in molecule data format.
+     */
     _toMolData() {
         return {
             lock: apply(bytesFrom, this.lock),
@@ -156,9 +453,30 @@ export class WitnessArgs {
             outputType: apply(bytesFrom, this.outputType),
         };
     }
+    /**
+     * Converts the WitnessArgs instance to bytes.
+     *
+     * @returns A Uint8Array containing the witness arguments bytes.
+     *
+     * @example
+     * ```typescript
+     * const witnessArgsBytes = witnessArgs.toBytes();
+     * ```
+     */
     toBytes() {
         return bytesFrom(mol.SerializeWitnessArgs(this._toMolData()));
     }
+    /**
+     * Creates a WitnessArgs instance from a byte-like value or molecule WitnessArgs.
+     *
+     * @param bytes - The byte-like value or molecule WitnessArgs to convert.
+     * @returns A WitnessArgs instance.
+     *
+     * @example
+     * ```typescript
+     * const witnessArgs = WitnessArgs.fromBytes(new Uint8Array([/* witness args bytes *\/]));
+     * ```
+     */
     static fromBytes(bytes) {
         const view = bytes instanceof mol.WitnessArgs
             ? bytes
@@ -167,6 +485,17 @@ export class WitnessArgs {
     }
 }
 export class Transaction {
+    /**
+     * 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, cellDeps, headerDeps, inputs, outputs, outputsData, witnesses) {
         this.version = version;
         this.cellDeps = cellDeps;
@@ -176,15 +505,57 @@ export class Transaction {
         this.outputsData = outputsData;
         this.witnesses = witnesses;
     }
+    /**
+     * Creates a default Transaction instance with empty fields.
+     *
+     * @returns A default Transaction instance.
+     *
+     * @example
+     * ```typescript
+     * const defaultTx = Transaction.default();
+     * ```
+     */
     static default() {
         return new Transaction(0n, [], [], [], [], [], []);
     }
+    /**
+     * Creates a Transaction instance from a TransactionLike object.
+     *
+     * @param tx - A TransactionLike object or an instance of Transaction.
+     * @returns A Transaction instance.
+     *
+     * @example
+     * ```typescript
+     * const transaction = Transaction.from({
+     *   version: 0,
+     *   cellDeps: [],
+     *   headerDeps: [],
+     *   inputs: [],
+     *   outputs: [],
+     *   outputsData: [],
+     *   witnesses: []
+     * });
+     * ```
+     */
     static from(tx) {
         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));
     }
+    /**
+     * 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.
+     *
+     * @example
+     * ```typescript
+     * const transaction = Transaction.fromLumosSkeleton(skeleton);
+     * ```
+     */
     static fromLumosSkeleton(skeleton) {
         return Transaction.from({
             version: 0n,
@@ -206,6 +577,16 @@ export class Transaction {
             witnesses: skeleton.witnesses.toArray(),
         });
     }
+    /**
+     * Converts the raw transaction data to bytes.
+     *
+     * @returns A Uint8Array containing the raw transaction bytes.
+     *
+     * @example
+     * ```typescript
+     * const rawTxBytes = transaction.rawToBytes();
+     * ```
+     */
     rawToBytes() {
         return bytesFrom(mol.SerializeRawTransaction({
             version: numToBytes(this.version, 4),
@@ -216,9 +597,30 @@ export class Transaction {
             outputsData: this.outputsData.map((header) => bytesFrom(header)),
         }));
     }
+    /**
+     * Calculates the hash of the transaction.
+     *
+     * @returns The hash of the transaction.
+     *
+     * @example
+     * ```typescript
+     * const txHash = transaction.hash();
+     * ```
+     */
     hash() {
         return ckbHash(this.rawToBytes());
     }
+    /**
+     * 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, hasher) {
         const raw = bytesFrom(hexFrom(witness));
         hasher.update(numToBytes(raw.length, 8));

package/dist/client/advanced.d.ts

@@ -1,3 +1,4 @@
 export * from "./clientPublicMainnet.advanced";
 export * from "./clientPublicTestnet.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"}
+{"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"}

package/dist/client/advanced.js

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

package/dist/client/client.d.ts

@@ -1,6 +1,6 @@
-import { ScriptLike, TransactionLike } from "../ckb";
-import { Hex } from "../hex";
-import { OutputsValidator } from "./clientTypes";
+import { Cell, OutPointLike, Script, TransactionLike } from "../ckb";
+import { Hex, HexLike } from "../hex";
+import { ClientTransactionResponse, OutputsValidator } from "./clientTypes";
 export declare enum KnownScript {
     Secp256k1Blake160 = 0,
     Secp256k1Multisig = 1,
@@ -8,10 +8,12 @@ export declare enum KnownScript {
     JoyId = 3,
     OmniLock = 4
 }
-export interface Client {
-    getUrl(): string;
-    getAddressPrefix(): Promise<string>;
-    getKnownScript(script: KnownScript): Promise<Omit<ScriptLike, "args">>;
-    sendTransaction(transaction: TransactionLike, validator?: OutputsValidator): Promise<Hex>;
+export declare abstract class Client {
+    abstract getUrl(): string;
+    abstract getAddressPrefix(): Promise<string>;
+    abstract getKnownScript(script: KnownScript): Promise<Pick<Script, "codeHash" | "hashType">>;
+    abstract sendTransaction(transaction: TransactionLike, validator?: OutputsValidator): Promise<Hex>;
+    abstract getTransaction(txHash: HexLike): Promise<ClientTransactionResponse | null>;
+    getCell(outPoint: OutPointLike): Promise<Cell | null>;
 }
 //# sourceMappingURL=client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AACrD,OAAO,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAC7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,oBAAY,WAAW;IACrB,iBAAiB,IAAA;IACjB,iBAAiB,IAAA;IACjB,YAAY,IAAA;IACZ,KAAK,IAAA;IACL,QAAQ,IAAA;CACT;AAED,MAAM,WAAW,MAAM;IACrB,MAAM,IAAI,MAAM,CAAC;IAEjB,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;IAEvE,eAAe,CACb,WAAW,EAAE,eAAe,EAC5B,SAAS,CAAC,EAAE,gBAAgB,GAC3B,OAAO,CAAC,GAAG,CAAC,CAAC;CACjB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AACrE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAE5E,oBAAY,WAAW;IACrB,iBAAiB,IAAA;IACjB,iBAAiB,IAAA;IACjB,YAAY,IAAA;IACZ,KAAK,IAAA;IACL,QAAQ,IAAA;CACT;AAED,8BAAsB,MAAM;IAC1B,QAAQ,CAAC,MAAM,IAAI,MAAM;IAEzB,QAAQ,CAAC,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;IAC5C,QAAQ,CAAC,cAAc,CACrB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC,CAAC;IAEjD,QAAQ,CAAC,eAAe,CACtB,WAAW,EAAE,eAAe,EAC5B,SAAS,CAAC,EAAE,gBAAgB,GAC3B,OAAO,CAAC,GAAG,CAAC;IACf,QAAQ,CAAC,cAAc,CACrB,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;IAEtC,OAAO,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;CAgB5D"}

package/dist/client/client.js

@@ -1,3 +1,5 @@
+import { Cell } from "../ckb";
+import { numFrom } from "../num";
 export var KnownScript;
 (function (KnownScript) {
     KnownScript[KnownScript["Secp256k1Blake160"] = 0] = "Secp256k1Blake160";
@@ -6,3 +8,19 @@ export var KnownScript;
     KnownScript[KnownScript["JoyId"] = 3] = "JoyId";
     KnownScript[KnownScript["OmniLock"] = 4] = "OmniLock";
 })(KnownScript || (KnownScript = {}));
+export class Client {
+    async getCell(outPoint) {
+        const transaction = await this.getTransaction(outPoint.txHash);
+        if (!transaction) {
+            return null;
+        }
+        const index = Number(numFrom(outPoint.index));
+        if (index >= transaction.transaction.outputs.length) {
+            return null;
+        }
+        return Cell.from({
+            cellOutput: transaction.transaction.outputs[index],
+            outputData: transaction.transaction.outputsData[index] ?? "0x",
+        });
+    }
+}

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

@@ -1,4 +1,4 @@
-import { ScriptLike } from "../ckb";
+import { Script } from "../ckb";
 import { KnownScript } from "./client";
-export declare const MAINNET_SCRIPTS: Record<KnownScript, Omit<ScriptLike, "args">>;
+export declare const MAINNET_SCRIPTS: Record<KnownScript, Pick<Script, "codeHash" | "hashType">>;
 //# sourceMappingURL=clientPublicMainnet.advanced.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"clientPublicMainnet.advanced.d.ts","sourceRoot":"","sources":["../../src/client/clientPublicMainnet.advanced.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CA0BzE,CAAC"}
+{"version":3,"file":"clientPublicMainnet.advanced.d.ts","sourceRoot":"","sources":["../../src/client/clientPublicMainnet.advanced.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,eAAO,MAAM,eAAe,EAAE,MAAM,CAClC,WAAW,EACX,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC,CA2BtC,CAAC"}

package/dist/client/clientPublicMainnet.d.ts

@@ -1,9 +1,9 @@
-import { ScriptLike } from "../ckb";
+import { Script } from "../ckb";
 import { KnownScript } from "./client";
 import { ClientJsonRpc } from "./jsonRpc";
 export declare class ClientPublicMainnet extends ClientJsonRpc {
-    constructor(timeout?: number);
+    constructor(url?: string, timeout?: number);
     getAddressPrefix(): Promise<string>;
-    getKnownScript(script: KnownScript): Promise<Omit<ScriptLike, "args">>;
+    getKnownScript(script: KnownScript): Promise<Pick<Script, "codeHash" | "hashType">>;
 }
 //# sourceMappingURL=clientPublicMainnet.d.ts.map