Class ClientAbstract

constructor

• new Client(config?: { cache?: ClientCache }): Client

  Parameters

  • Optionalconfig: { cache?: ClientCache }

  Returns Client

cache

Abstracturl

• get url(): string

  Returns string

AbstractaddressPrefix

• get addressPrefix(): string

  Returns string

AbstractgetKnownScript

• getKnownScript(script: KnownScript): Promise<ScriptInfo>

  Parameters

  • script: KnownScript

  Returns Promise<ScriptInfo>

AbstractgetFeeRateStatistics

• getFeeRateStatistics(
      blockRange?: NumLike,
  ): Promise<{ mean?: bigint; median?: bigint }>

  Parameters

  • OptionalblockRange: NumLike

  Returns Promise<{ mean?: bigint; median?: bigint }>

getFeeRate

• getFeeRate(
      blockRange?: NumLike,
      options?: { maxFeeRate?: NumLike },
  ): Promise<bigint>

  Parameters

  • OptionalblockRange: NumLike
  • Optionaloptions: { maxFeeRate?: NumLike }

  Returns Promise<bigint>

AbstractgetTip

• getTip(): Promise<bigint>

  Returns Promise<bigint>

AbstractgetTipHeader

• getTipHeader(verbosity?: null | number): Promise<ClientBlockHeader>

  Parameters

  • Optionalverbosity: null | number

  Returns Promise<ClientBlockHeader>

AbstractgetBlockByNumberNoCache

• getBlockByNumberNoCache(
      blockNumber: NumLike,
      verbosity?: null | number,
      withCycles?: null | boolean,
  ): Promise<undefined | ClientBlock>

  Parameters

  • blockNumber: NumLike
  • Optionalverbosity: null | number
  • OptionalwithCycles: null | boolean

  Returns Promise<undefined | ClientBlock>

AbstractgetBlockByHashNoCache

• getBlockByHashNoCache(
      blockHash: BytesLike,
      verbosity?: null | number,
      withCycles?: null | boolean,
  ): Promise<undefined | ClientBlock>

  Parameters

  • blockHash: BytesLike
  • Optionalverbosity: null | number
  • OptionalwithCycles: null | boolean

  Returns Promise<undefined | ClientBlock>

AbstractgetHeaderByNumberNoCache

• getHeaderByNumberNoCache(
      blockNumber: NumLike,
      verbosity?: null | number,
  ): Promise<undefined | ClientBlockHeader>

  Parameters

  • blockNumber: NumLike
  • Optionalverbosity: null | number

  Returns Promise<undefined | ClientBlockHeader>

AbstractgetHeaderByHashNoCache

• getHeaderByHashNoCache(
      blockHash: BytesLike,
      verbosity?: null | number,
  ): Promise<undefined | ClientBlockHeader>

  Parameters

  • blockHash: BytesLike
  • Optionalverbosity: null | number

  Returns Promise<undefined | ClientBlockHeader>

getBlockByNumber

• getBlockByNumber(
      blockNumber: NumLike,
      verbosity?: null | number,
      withCycles?: null | boolean,
  ): Promise<undefined | ClientBlock>

  Parameters

  • blockNumber: NumLike
  • Optionalverbosity: null | number
  • OptionalwithCycles: null | boolean

  Returns Promise<undefined | ClientBlock>

getBlockByHash

• getBlockByHash(
      blockHash: BytesLike,
      verbosity?: null | number,
      withCycles?: null | boolean,
  ): Promise<undefined | ClientBlock>

  Parameters

  • blockHash: BytesLike
  • Optionalverbosity: null | number
  • OptionalwithCycles: null | boolean

  Returns Promise<undefined | ClientBlock>

getHeaderByNumber

• getHeaderByNumber(
      blockNumber: NumLike,
      verbosity?: null | number,
  ): Promise<undefined | ClientBlockHeader>

  Parameters

  • blockNumber: NumLike
  • Optionalverbosity: null | number

  Returns Promise<undefined | ClientBlockHeader>

getHeaderByHash

• getHeaderByHash(
      blockHash: BytesLike,
      verbosity?: null | number,
  ): Promise<undefined | ClientBlockHeader>

  Parameters

  • blockHash: BytesLike
  • Optionalverbosity: null | number

  Returns Promise<undefined | ClientBlockHeader>

AbstractestimateCycles

• estimateCycles(transaction: TransactionLike): Promise<bigint>

  Parameters

  • transaction: TransactionLike

  Returns Promise<bigint>

AbstractsendTransactionDry

• sendTransactionDry(
      transaction: TransactionLike,
      validator?: OutputsValidator,
  ): Promise<bigint>

  Parameters

  • transaction: TransactionLike
  • Optionalvalidator: OutputsValidator

  Returns Promise<bigint>

AbstractsendTransactionNoCache

• sendTransactionNoCache(
      transaction: TransactionLike,
      validator?: OutputsValidator,
  ): Promise<`0x${string}`>

  Parameters

  • transaction: TransactionLike
  • Optionalvalidator: OutputsValidator

  Returns Promise<`0x${string}`>

AbstractgetTransactionNoCache

• getTransactionNoCache(
      txHash: BytesLike,
  ): Promise<undefined | ClientTransactionResponse>

  Parameters

  • txHash: BytesLike

  Returns Promise<undefined | ClientTransactionResponse>

getCell

• getCell(outPointLike: OutPointLike): Promise<undefined | Cell>

  Get a cell by its out point. The cell will be cached if it is found.

  Parameters

  • outPointLike: OutPointLike

    The out point of the cell to get.

  Returns Promise<undefined | Cell>

  The cell if it exists, otherwise undefined.

getCellWithHeader

• getCellWithHeader(
      outPointLike: OutPointLike,
  ): Promise<undefined | { cell: Cell; header?: ClientBlockHeader }>

  Parameters

  • outPointLike: OutPointLike

  Returns Promise<undefined | { cell: Cell; header?: ClientBlockHeader }>

AbstractgetCellLiveNoCache

• getCellLiveNoCache(
      outPointLike: OutPointLike,
      withData?: null | boolean,
      includeTxPool?: null | boolean,
  ): Promise<undefined | Cell>

  Parameters

  • outPointLike: OutPointLike
  • OptionalwithData: null | boolean
  • OptionalincludeTxPool: null | boolean

  Returns Promise<undefined | Cell>

getCellLive

• getCellLive(
      outPointLike: OutPointLike,
      withData?: null | boolean,
      includeTxPool?: null | boolean,
  ): Promise<undefined | Cell>

  Parameters

  • outPointLike: OutPointLike
  • OptionalwithData: null | boolean
  • OptionalincludeTxPool: null | boolean

  Returns Promise<undefined | Cell>

AbstractfindCellsPagedNoCache

• findCellsPagedNoCache(
      key: ClientIndexerSearchKeyLike,
      order?: "asc" | "desc",
      limit?: NumLike,
      after?: string,
  ): Promise<ClientFindCellsResponse>

  Parameters

  • key: ClientIndexerSearchKeyLike
  • Optionalorder: "asc" | "desc"
  • Optionallimit: NumLike
  • Optionalafter: string

  Returns Promise<ClientFindCellsResponse>

findCellsPaged

• findCellsPaged(
      key: ClientIndexerSearchKeyLike,
      order?: "asc" | "desc",
      limit?: NumLike,
      after?: string,
  ): Promise<ClientFindCellsResponse>

  Parameters

  • key: ClientIndexerSearchKeyLike
  • Optionalorder: "asc" | "desc"
  • Optionallimit: NumLike
  • Optionalafter: string

  Returns Promise<ClientFindCellsResponse>

findCellsOnChain

• findCellsOnChain(
      key: ClientIndexerSearchKeyLike,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<Cell>

  Parameters

  • key: ClientIndexerSearchKeyLike
  • Optionalorder: "asc" | "desc"
  • limit: number = 10

  Returns AsyncGenerator<Cell>

findCells

• findCells(
      keyLike: ClientCollectableSearchKeyLike,
      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.

  Parameters

  • keyLike: ClientCollectableSearchKeyLike

    The search key.
  • Optionalorder: "asc" | "desc"
  • limit: number = 10

  Returns AsyncGenerator<Cell>

  A async generator for yielding cells.

findCellsByLock

• findCellsByLock(
      lock: ScriptLike,
      type?: null | ScriptLike,
      withData?: boolean,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<Cell>

  Parameters

  • lock: ScriptLike
  • Optionaltype: null | ScriptLike
  • withData: boolean = true
  • Optionalorder: "asc" | "desc"
  • limit: number = 10

  Returns AsyncGenerator<Cell>

findCellsByType

• findCellsByType(
      type: ScriptLike,
      withData?: boolean,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<Cell>

  Parameters

  • type: ScriptLike
  • withData: boolean = true
  • Optionalorder: "asc" | "desc"
  • limit: number = 10

  Returns AsyncGenerator<Cell>

findSingletonCellByType

• findSingletonCellByType(
      type: ScriptLike,
      withData?: boolean,
  ): Promise<undefined | Cell>

  Parameters

  • type: ScriptLike
  • withData: boolean = false

  Returns Promise<undefined | Cell>

getCellDeps

• getCellDeps(
      ...cellDepsInfoLike: (CellDepInfoLike | CellDepInfoLike[])[],
  ): Promise<CellDep[]>

  Parameters

  • ...cellDepsInfoLike: (CellDepInfoLike | CellDepInfoLike[])[]

  Returns Promise<CellDep[]>

AbstractfindTransactionsPaged

• findTransactionsPaged(
      key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
          groupByTransaction: true;
      },
      order?: "asc" | "desc",
      limit?: NumLike,
      after?: string,
  ): Promise<ClientFindTransactionsGroupedResponse>

  Parameters

  • key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
        groupByTransaction: true;
    }
  • Optionalorder: "asc" | "desc"
  • Optionallimit: NumLike
  • Optionalafter: string

  Returns Promise<ClientFindTransactionsGroupedResponse>

• findTransactionsPaged(
      key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
          groupByTransaction?: null | false;
      },
      order?: "asc" | "desc",
      limit?: NumLike,
      after?: string,
  ): Promise<ClientFindTransactionsResponse>

  Parameters

  • key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
        groupByTransaction?: null | false;
    }
  • Optionalorder: "asc" | "desc"
  • Optionallimit: NumLike
  • Optionalafter: string

  Returns Promise<ClientFindTransactionsResponse>

• findTransactionsPaged(
      key: ClientIndexerSearchKeyTransactionLike,
      order?: "asc" | "desc",
      limit?: NumLike,
      after?: string,
  ): Promise<
      ClientFindTransactionsResponse
      | ClientFindTransactionsGroupedResponse,
  >

  Parameters

  • key: ClientIndexerSearchKeyTransactionLike
  • Optionalorder: "asc" | "desc"
  • Optionallimit: NumLike
  • Optionalafter: string

  Returns Promise<ClientFindTransactionsResponse | ClientFindTransactionsGroupedResponse>

findTransactions

• findTransactions(
      key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
          groupByTransaction: true;
      },
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

  Parameters

  • key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
        groupByTransaction: true;
    }
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

• findTransactions(
      key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
          groupByTransaction?: null | false;
      },
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      },
  >

  Parameters

  • key: Omit<ClientIndexerSearchKeyTransactionLike, "groupByTransaction"> & {
        groupByTransaction?: null | false;
    }
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      },
  >

• findTransactions(
      key: ClientIndexerSearchKeyTransactionLike,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      }
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

  Parameters

  • key: ClientIndexerSearchKeyTransactionLike
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      }
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

findTransactionsByLock

• findTransactionsByLock(
      lock: ScriptLike,
      type: undefined | null | ScriptLike,
      groupByTransaction: true,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

  Parameters

  • lock: ScriptLike
  • type: undefined | null | ScriptLike
  • groupByTransaction: true
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

• findTransactionsByLock(
      lock: ScriptLike,
      type?: null | ScriptLike,
      groupByTransaction?: null | false,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      },
  >

  Parameters

  • lock: ScriptLike
  • Optionaltype: null | ScriptLike
  • OptionalgroupByTransaction: null | false
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      },
  >

• findTransactionsByLock(
      lock: ScriptLike,
      type?: null | ScriptLike,
      groupByTransaction?: null | boolean,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      }
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

  Parameters

  • lock: ScriptLike
  • Optionaltype: null | ScriptLike
  • OptionalgroupByTransaction: null | boolean
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      }
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

findTransactionsByType

• findTransactionsByType(
      type: ScriptLike,
      groupByTransaction: true,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

  Parameters

  • type: ScriptLike
  • groupByTransaction: true
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

• findTransactionsByType(
      type: ScriptLike,
      groupByTransaction?: null | false,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      },
  >

  Parameters

  • type: ScriptLike
  • OptionalgroupByTransaction: null | false
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<
      {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      },
  >

• findTransactionsByType(
      type: ScriptLike,
      groupByTransaction?: null | boolean,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      }
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

  Parameters

  • type: ScriptLike
  • OptionalgroupByTransaction: null | boolean
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          isInput: boolean;
          cellIndex: bigint;
      }
      | {
          txHash: `0x${string}`;
          blockNumber: bigint;
          txIndex: bigint;
          cells: { isInput: boolean; cellIndex: bigint }[];
      },
  >

AbstractgetCellsCapacity

• getCellsCapacity(key: ClientIndexerSearchKeyLike): Promise<bigint>

  Parameters

  • key: ClientIndexerSearchKeyLike

  Returns Promise<bigint>

getBalanceSingle

• getBalanceSingle(lock: ScriptLike): Promise<bigint>

  Parameters

  • lock: ScriptLike

  Returns Promise<bigint>

getBalance

• getBalance(locks: ScriptLike[]): Promise<bigint>

  Parameters

  • locks: ScriptLike[]

  Returns Promise<bigint>

sendTransaction

• sendTransaction(
      transaction: TransactionLike,
      validator?: OutputsValidator,
      options?: { maxFeeRate?: NumLike },
  ): Promise<`0x${string}`>

  Parameters

  • transaction: TransactionLike
  • Optionalvalidator: OutputsValidator
  • Optionaloptions: { maxFeeRate?: NumLike }

  Returns Promise<`0x${string}`>

getTransaction

• getTransaction(
      txHashLike: BytesLike,
  ): Promise<undefined | ClientTransactionResponse>

  Parameters

  • txHashLike: BytesLike

  Returns Promise<undefined | ClientTransactionResponse>

getTransactionWithHeader

• getTransactionWithHeader(
      txHashLike: BytesLike,
  ): Promise<
      | undefined
      | { transaction: ClientTransactionResponse; header?: ClientBlockHeader },
  >

  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.

  Parameters

  • txHashLike: BytesLike

  Returns Promise<
      | undefined
      | { transaction: ClientTransactionResponse; header?: ClientBlockHeader },
  >

waitTransaction

• waitTransaction(
      txHash: BytesLike,
      confirmations?: number,
      timeout?: number,
      interval?: number,
  ): Promise<undefined | ClientTransactionResponse>

  Parameters

  • txHash: BytesLike
  • confirmations: number = 0
  • timeout: number = 60000
  • interval: number = 2000

  Returns Promise<undefined | ClientTransactionResponse>