Class SignerMultisigCkbPrivateKey

StaticEmptySignature

ReadonlymultisigInfo

Optional Readonlysince

ReadonlyscriptInfos

type

• get type(): SignerType

  Returns SignerType

signType

• get signType(): SignerSignType

  Returns SignerSignType

client

• get client(): Client

  Returns Client

getMemberCount

• getMemberCount(): Promise<number>

  Get the number of members in the multisig script.

  Returns Promise<number>

  The number of members.

getMemberThreshold

• getMemberThreshold(): Promise<number>

  Get the threshold of the multisig script.

  Returns Promise<number>

  The threshold.

getMemberRequiredCount

• getMemberRequiredCount(): Promise<number>

  Get the count of required member of the multisig script.

  Returns Promise<number>

  The must match count.

connect

• connect(): Promise<void>

  Connects to the signer.

  Returns Promise<void>

  A promise that resolves when the connection is complete.

isConnected

• isConnected(): Promise<boolean>

  Check if the signer is connected.

  Returns Promise<boolean>

  A promise that resolves the connection status.

getInternalAddress

• getInternalAddress(): Promise<string>

  Gets the internal address associated with the signer.

  Returns Promise<string>

  A promise that resolves to a string representing the internal address.

getAddressObjs

• getAddressObjs(): Promise<Address[]>

  Gets an array of Address objects associated with the signer.

  Returns Promise<Address[]>

  A promise that resolves to an array of Address objects.

decodeWitnessArgsAt

• decodeWitnessArgsAt(
      txLike: TransactionLike,
      index: number,
  ): MultisigCkbWitness | undefined

  Decode the witness args at a specific index.

  Parameters

  • txLike: TransactionLike

    The transaction.

  • index: number

    The index of the witness args.

  Returns MultisigCkbWitness | undefined

  The decoded MultisigCkbWitness.

decodeWitnessArgs

• decodeWitnessArgs(
      witnessLike?: WitnessArgsLike | null,
  ): MultisigCkbWitness | undefined

  Decode the witness args.

  Parameters

  • OptionalwitnessLike: WitnessArgsLike | null

    The witness args like object.

  Returns MultisigCkbWitness | undefined

  The decoded MultisigCkbWitness.

prepareWitnessArgsAt

• prepareWitnessArgsAt(
      txLike: TransactionLike,
      index: number,
      transformer?:
          | (
              (
                  witness: MultisigCkbWitness,
                  witnessArgs: WitnessArgs,
              ) =>
                  | void
                  | MultisigCkbWitnessLike
                  | Promise<(void | MultisigCkbWitnessLike | null | undefined)>
                  | null
                  | undefined
          )
          | null,
  ): Promise<Transaction>

  Prepare the witness args at a specific index.

  Parameters

  • txLike: TransactionLike

    The transaction.

  • index: number

    The index of the witness args.

  • Optionaltransformer:
        | (
            (
                witness: MultisigCkbWitness,
                witnessArgs: WitnessArgs,
            ) =>
                | void
                | MultisigCkbWitnessLike
                | Promise<(void | MultisigCkbWitnessLike | null | undefined)>
                | null
                | undefined
        )
        | null

    The transformer function.

  Returns Promise<Transaction>

  The prepared transaction.

prepareTransactionOneScript

• prepareTransactionOneScript(
      txLike: TransactionLike,
      script: ScriptLike,
      cellDeps: CellDepInfoLike[],
  ): Promise<Transaction>

  Prepare multisig witness, if the existence of multisig witness is detected, nothing happens

  Parameters

  • txLike: TransactionLike

    The transaction to prepare.

  • script: ScriptLike
  • cellDeps: CellDepInfoLike[]

  Returns Promise<Transaction>

  A promise that resolves to the prepared transaction

prepareTransaction

• prepareTransaction(txLike: TransactionLike): Promise<Transaction>

  Prepare transaction for multisig witness and adding related cell deps

  Parameters

  • txLike: TransactionLike

    The transaction to prepare.

  Returns Promise<Transaction>

  A promise that resolves to the prepared transaction

getSignaturesCount

• getSignaturesCount(txLike: TransactionLike): Promise<number | undefined>

  Get the number of valid signatures for matching multisig inputs in the transaction.

  Parameters

  • txLike: TransactionLike

    The transaction.

  Returns Promise<number | undefined>

  The matched multisig signature count, or undefined when the transaction is unrelated to any multisig address supported by this signer.

  Remarks

  Returns undefined when the transaction has no inputs locked by any multisig address supported by this signer. This method only counts signatures for matching multisig inputs and does not imply that the transaction should be signed by this multisig.

needMoreSignatures

• needMoreSignatures(txLike: TransactionLike): Promise<boolean>

  Check if related multisig inputs in the transaction need more signatures.

  Parameters

  • txLike: TransactionLike

    The transaction to check.

  Returns Promise<boolean>

  A promise that resolves to true when related multisig inputs still need signatures, and false otherwise.

  Remarks

  Returns false when the transaction has no inputs locked by any multisig address supported by this signer. A false result therefore means either the related multisig inputs are already fulfilled, or the transaction is unrelated to all multisig addresses supported by this signer.

getSignInfo

• getSignInfo(
      txLike: TransactionLike,
      script: ScriptLike,
  ): Promise<{ message: `0x${string}`; position: number } | undefined>

  Get the sign info for a script.

  Parameters

  • txLike: TransactionLike

    The transaction.

  • script: ScriptLike

    The script.

  Returns Promise<{ message: `0x${string}`; position: number } | undefined>

  The sign info.

aggregateTransactions

• aggregateTransactions(txs: TransactionLike[]): Promise<Transaction>

  Aggregate transactions.

  Parameters

  • txs: TransactionLike[]

    The transactions to aggregate.

  Returns Promise<Transaction>

  The aggregated transaction.

matchNetworkPreference

• matchNetworkPreference(
      preferences: NetworkPreference[],
      currentNetwork: string | undefined,
  ): NetworkPreference | undefined

  Parameters

  • preferences: NetworkPreference[]
  • currentNetwork: string | undefined

  Returns NetworkPreference | undefined

StaticverifyMessage

• verifyMessage(message: BytesLike, signature: Signature): Promise<boolean>

  Parameters

  • message: BytesLike
  • signature: Signature

  Returns Promise<boolean>

onReplaced

• onReplaced(_: () => void): () => void

  Register a listener to be called when this signer is replaced.

  Parameters

  • _: () => void

  Returns () => void

  A function for unregister

disconnect

• disconnect(): Promise<void>

  Disconnects to the signer.

  Returns Promise<void>

  A promise that resolves when the signer is disconnected.

getIdentity

• getIdentity(): Promise<string>

  Gets the identity for verifying signature, usually it's address

  Returns Promise<string>

  A promise that resolves to a string representing the identity

getRecommendedAddressObj

• getRecommendedAddressObj(_preference?: unknown): Promise<Address>

  Gets the recommended Address object for the signer.

  Parameters

  • Optional_preference: unknown

    Optional preference parameter.

  Returns Promise<Address>

  A promise that resolves to the recommended Address object.

getRecommendedAddress

• getRecommendedAddress(preference?: unknown): Promise<string>

  Gets the recommended address for the signer as a string.

  Parameters

  • Optionalpreference: unknown

    Optional preference parameter.

  Returns Promise<string>

  A promise that resolves to the recommended address as a string.

getAddresses

• getAddresses(): Promise<string[]>

  Gets an array of addresses associated with the signer as strings.

  Returns Promise<string[]>

  A promise that resolves to an array of addresses as strings.

findCellsOnChain

• findCellsOnChain(
      filter: ClientIndexerSearchKeyFilterLike,
      withData?: boolean | null,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<Cell>

  Find cells of this signer

  Parameters

  • filter: ClientIndexerSearchKeyFilterLike

    The filter for the search key.

  • OptionalwithData: boolean | null

    Whether to include cell data in the response.

  • Optionalorder: "asc" | "desc"

    The order of the returned cells, can be "asc" or "desc".

  • Optionallimit: number

    The maximum number of cells for every querying chunk.

  Returns AsyncGenerator<Cell>

  A async generator that yields all matching cells

findCells

• findCells(
      filter: ClientCollectableSearchKeyFilterLike,
      withData?: boolean | null,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<Cell>

  Find cells of this signer

  Parameters

  • filter: ClientCollectableSearchKeyFilterLike
  • OptionalwithData: boolean | null
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

  Returns AsyncGenerator<Cell>

  A async generator that yields all matches cells

findTransactions

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

  Find transactions of this signer

  Parameters

  • filter: ClientCollectableSearchKeyFilterLike
  • OptionalgroupByTransaction: false | null
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

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

  A async generator that yields all matches transactions

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

  Find transactions of this signer

  Parameters

  • filter: ClientCollectableSearchKeyFilterLike
  • groupByTransaction: true
  • Optionalorder: "asc" | "desc"
  • Optionallimit: number

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

  A async generator that yields all matches transactions

• findTransactions(
      filter: ClientCollectableSearchKeyFilterLike,
      groupByTransaction?: boolean | null,
      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 }[];
      },
  >

  Find transactions of this signer

  Parameters

  • filter: ClientCollectableSearchKeyFilterLike
  • OptionalgroupByTransaction: boolean | null
  • 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 }[];
      },
  >

  A async generator that yields all matches transactions

getBalance

• getBalance(): Promise<bigint>

  Gets balance of all addresses

  Returns Promise<bigint>

  A promise that resolves to the balance

signMessage

• signMessage(message: BytesLike): Promise<Signature>

  Signs a message.

  Parameters

  • message: BytesLike

    The message to sign, as a string or BytesLike object.

  Returns Promise<Signature>

  A promise that resolves to the signature info.

  Throws

  Will throw an error if not implemented.

signMessageRaw

• signMessageRaw(_: BytesLike): Promise<string>

  Signs a message and returns signature only. This method is not implemented and should be overridden by subclasses.

  Parameters

  • _: BytesLike

    The message to sign, as a string or BytesLike object.

  Returns Promise<string>

  A promise that resolves to the signature as a string.

  Throws

  Will throw an error if not implemented.

verifyMessage

• verifyMessage(
      message: BytesLike,
      signature: string | Signature,
  ): Promise<boolean>

  Verify a signature.

  Parameters

  • message: BytesLike

    The original message.

  • signature: string | Signature

    The signature to verify.

  Returns Promise<boolean>

  A promise that resolves to the verification result.

  Throws

  Will throw an error if not implemented.

signTransaction

• signTransaction(tx: TransactionLike): Promise<Transaction>

  Signs a transaction.

  Parameters

  • tx: TransactionLike

    The transaction to sign, represented as a TransactionLike object.

  Returns Promise<Transaction>

  A promise that resolves to the signed Transaction object.

sendTransaction

• sendTransaction(tx: TransactionLike): Promise<`0x${string}`>

  Send a transaction.

  Parameters

  • tx: TransactionLike

    The transaction to send.

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

  The transaction hash.

  Remarks

  This method rejects the transaction only when related multisig inputs still need signatures. It does not verify that the transaction actually contains inputs locked by any multisig address supported by this signer, so transactions unrelated to those multisig addresses are not rejected by this check.