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<Pick<ccc.Script, "codeHash" | "hashType"> & {
      cellDeps: CellDepInfo[];
  }>

• Parameters

  • script: KnownScript

  Returns Promise<Pick<ccc.Script, "codeHash" | "hashType"> & {
      cellDeps: CellDepInfo[];
  }>

AbstractgetTip

• getTip(): Promise<bigint>

• Returns Promise<bigint>

AbstractgetTipHeader

• getTipHeader(verbosity?): Promise<ClientBlockHeader>

• Parameters

  • Optionalverbosity: null | number

  Returns Promise<ClientBlockHeader>

AbstractgetBlockByNumber

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

• Parameters

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

  Returns Promise<undefined | ClientBlock>

AbstractgetBlockByHash

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

• Parameters

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

  Returns Promise<undefined | ClientBlock>

AbstractgetHeaderByNumber

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

• Parameters

  • blockNumber: NumLike
  • Optionalverbosity: null | number

  Returns Promise<undefined | ClientBlockHeader>

AbstractgetHeaderByHash

• 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>

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, unknown>

• Parameters

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

  Returns AsyncGenerator<Cell, any, unknown>

findCells

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

• 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, unknown>

  A async generator for yielding cells.

findCellsByLock

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

• Parameters

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

  Returns AsyncGenerator<Cell, any, unknown>

findCellsByType

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

• Parameters

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

  Returns AsyncGenerator<Cell, any, unknown>

findSingletonCellByType

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

• Parameters

  • type: ScriptLike
  • withData: boolean = false

  Returns Promise<undefined | Cell>

getCellDeps

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

• Parameters

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

  Returns Promise<ccc.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, unknown>

• 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, unknown>

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

• 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, unknown>

• 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, unknown>

• 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, unknown>

findTransactionsByLock

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

• 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, unknown>

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

• 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, unknown>

• 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, unknown>

• 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, unknown>

findTransactionsByType

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

• 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, unknown>

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

• 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, unknown>

• 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, unknown>

• 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, unknown>

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?): Promise<`0x${string}`>

• Parameters

  • transaction: TransactionLike
  • Optionalvalidator: OutputsValidator

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

getTransaction

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

• Parameters

  • txHashLike: BytesLike

  Returns Promise<undefined | ClientTransactionResponse>