Class ClientAbstract

constructor

• new Client(config?): Client

• Parameters

  • Optionalconfig: {
        cache?: ClientCache;
    }

    • Optionalcache?: ClientCache

  Returns Client

cache

Abstracturl

• get url(): string

• Returns string

AbstractaddressPrefix

• get addressPrefix(): string

• Returns string

AbstractgetKnownScript

• getKnownScript(script): Promise<ccc.ScriptInfo>

• Parameters

  • script: KnownScript

  Returns Promise<ccc.ScriptInfo>

AbstractgetFeeRateStatistics

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

• Parameters

  • OptionalblockRange: NumLike

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

getFeeRate

• getFeeRate(blockRange?, options?): Promise<bigint>

• Parameters

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

    • OptionalmaxFeeRate?: NumLike

  Returns Promise<bigint>

AbstractgetTip

• getTip(): Promise<bigint>

• Returns Promise<bigint>

AbstractgetTipHeader

• getTipHeader(verbosity?): Promise<ClientBlockHeader>

• Parameters

  • Optionalverbosity: null | number

  Returns Promise<ClientBlockHeader>

AbstractgetBlockByNumberNoCache

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

• Parameters

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

  Returns Promise<undefined | ClientBlock>

AbstractgetBlockByHashNoCache

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

• Parameters

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

  Returns Promise<undefined | ClientBlock>

AbstractgetHeaderByNumberNoCache

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

• Parameters

  • blockNumber: NumLike
  • Optionalverbosity: null | number

  Returns Promise<undefined | ClientBlockHeader>

AbstractgetHeaderByHashNoCache

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

• Parameters

  • blockHash: BytesLike
  • Optionalverbosity: null | number

  Returns Promise<undefined | ClientBlockHeader>

getBlockByNumber

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

• Parameters

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

  Returns Promise<undefined | ClientBlock>

getBlockByHash

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

• Parameters

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

  Returns Promise<undefined | ClientBlock>

getHeaderByNumber

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

• Parameters

  • blockNumber: NumLike
  • Optionalverbosity: null | number

  Returns Promise<undefined | ClientBlockHeader>

getHeaderByHash

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

• Parameters

  • blockHash: BytesLike
  • Optionalverbosity: null | number

  Returns Promise<undefined | ClientBlockHeader>

AbstractestimateCycles

• estimateCycles(transaction): Promise<bigint>

• Parameters

  • transaction: TransactionLike

  Returns Promise<bigint>

AbstractsendTransactionDry

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

• Parameters

  • transaction: TransactionLike
  • Optionalvalidator: OutputsValidator

  Returns Promise<bigint>

AbstractsendTransactionNoCache

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

• Parameters

  • transaction: TransactionLike
  • Optionalvalidator: OutputsValidator

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

AbstractgetTransactionNoCache

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

• Parameters

  • txHash: BytesLike

  Returns Promise<undefined | ClientTransactionResponse>

getCell

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

• Parameters

  • outPointLike: OutPointLike

  Returns Promise<undefined | Cell>

getCellWithHeader

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

• Parameters

  • outPointLike: OutPointLike

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

AbstractgetCellLiveNoCache

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

• Parameters

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

  Returns Promise<undefined | Cell>

getCellLive

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

• Parameters

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

  Returns Promise<undefined | Cell>

AbstractfindCellsPagedNoCache

• findCellsPagedNoCache(key, order?, limit?, after?): Promise<ClientFindCellsResponse>

• Parameters

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

  Returns Promise<ClientFindCellsResponse>

findCellsPaged

• findCellsPaged(key, order?, limit?, after?): Promise<ClientFindCellsResponse>

• Parameters

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

  Returns Promise<ClientFindCellsResponse>

findCellsOnChain

• findCellsOnChain(key, order?, limit?): AsyncGenerator<Cell, any, any>

• Parameters

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

  Returns AsyncGenerator<Cell, any, any>

findCells

• findCells(keyLike, order?, limit?): AsyncGenerator<Cell, any, any>

• Find cells by search key designed for collectable cells.

  Parameters

  • keyLike: ClientCollectableSearchKeyLike

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

  Returns AsyncGenerator<Cell, any, any>

  A async generator for yielding cells.

findCellsByLock

• findCellsByLock(lock, type?, withData?, order?, limit?): AsyncGenerator<Cell, any, any>

• Parameters

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

  Returns AsyncGenerator<Cell, any, any>

findCellsByType

• findCellsByType(type, withData?, order?, limit?): AsyncGenerator<Cell, any, any>

• Parameters

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

  Returns AsyncGenerator<Cell, any, any>

findSingletonCellByType

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

• Parameters

  • type: ScriptLike
  • withData: boolean = false

  Returns Promise<undefined | Cell>

getCellDeps

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

• Parameters

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

  Returns Promise<CellDep[]>

AbstractfindTransactionsPaged

• findTransactionsPaged(key, order?, limit?, after?): Promise<ClientFindTransactionsGroupedResponse>

• Parameters

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

  Returns Promise<ClientFindTransactionsGroupedResponse>

• findTransactionsPaged(key, order?, limit?, after?): Promise<ClientFindTransactionsResponse>

• Parameters

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

  Returns Promise<ClientFindTransactionsResponse>

• findTransactionsPaged(key, order?, limit?, after?): Promise<ClientFindTransactionsResponse | ClientFindTransactionsGroupedResponse>

• Parameters

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

  Returns Promise<ClientFindTransactionsResponse | ClientFindTransactionsGroupedResponse>

findTransactions

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

• 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;
      }[];
  }, any, any>

• findTransactions(key, order?, limit?): AsyncGenerator<{
      txHash: `0x${string}`;
      blockNumber: bigint;
      txIndex: bigint;
      isInput: boolean;
      cellIndex: bigint;
  }, any, any>

• 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;
  }, any, any>

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

• 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;
      }[];
  }, any, any>

findTransactionsByLock

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

• 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;
      }[];
  }, any, any>

• findTransactionsByLock(lock, type?, groupByTransaction?, order?, limit?): AsyncGenerator<{
      txHash: `0x${string}`;
      blockNumber: bigint;
      txIndex: bigint;
      isInput: boolean;
      cellIndex: bigint;
  }, any, any>

• 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;
  }, any, any>

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

• 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;
      }[];
  }, any, any>

findTransactionsByType

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

• Parameters

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

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

• findTransactionsByType(type, groupByTransaction?, order?, limit?): AsyncGenerator<{
      txHash: `0x${string}`;
      blockNumber: bigint;
      txIndex: bigint;
      isInput: boolean;
      cellIndex: bigint;
  }, any, any>

• Parameters

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

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

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

• 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;
      }[];
  }, any, any>

AbstractgetCellsCapacity

• getCellsCapacity(key): Promise<bigint>

• Parameters

  • key: ClientIndexerSearchKeyLike

  Returns Promise<bigint>

getBalanceSingle

• getBalanceSingle(lock): Promise<bigint>

• Parameters

  • lock: ScriptLike

  Returns Promise<bigint>

getBalance

• getBalance(locks): Promise<bigint>

• Parameters

  • locks: ScriptLike[]

  Returns Promise<bigint>

sendTransaction

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

• Parameters

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

    • OptionalmaxFeeRate?: NumLike

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

getTransaction

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

• Parameters

  • txHashLike: BytesLike

  Returns Promise<undefined | ClientTransactionResponse>

getTransactionWithHeader

• getTransactionWithHeader(txHashLike): 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, confirmations?, timeout?, interval?): Promise<undefined | ClientTransactionResponse>

• Parameters

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

  Returns Promise<undefined | ClientTransactionResponse>