Class SignerMultisigOmniLockReadonly

StaticEmptySignature

ReadonlymultisigInfo

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.

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,
  ): undefined | MultisigCkbWitness

  Decode the witness args at a specific index.

  Parameters

  • txLike: TransactionLike
  • index: number

  Returns undefined | MultisigCkbWitness

decodeWitnessArgs

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

  Decode the witness args.

  Parameters

  • OptionalwitnessLike: null | WitnessArgsLike

  Returns undefined | MultisigCkbWitness

prepareWitnessArgsAt

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

  Prepare the witness args at a specific index.

  Parameters

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

  Returns Promise<Transaction>

prepareTransactionOneScript

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

  Prepare multisig witness for a single script variant.

  Parameters

  • txLike: TransactionLike
  • script: ScriptLike
  • cellDeps: CellDepInfoLike[]

  Returns Promise<Transaction>

prepareTransaction

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

  Prepare transaction for multisig witness and adding related cell deps.

  Parameters

  • txLike: TransactionLike

  Returns Promise<Transaction>

getSignaturesCount

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

  Get the number of signatures in the transaction.

  Parameters

  • txLike: TransactionLike

  Returns Promise<undefined | number>

needMoreSignatures

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

  Check if the transaction needs more signatures.

  Parameters

  • txLike: TransactionLike

  Returns Promise<boolean>

getSignInfo

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

  Get the sign info for a script.

  Parameters

  • txLike: TransactionLike
  • script: ScriptLike

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

aggregateTransactions

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

  Aggregate transactions.

  Parameters

  • txs: TransactionLike[]

  Returns Promise<Transaction>

matchNetworkPreference

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

  Parameters

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

  Returns undefined | NetworkPreference

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?: null | boolean,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<Cell>

  Find cells of this signer

  Parameters

  • filter: ClientIndexerSearchKeyFilterLike

    The filter for the search key.
  • OptionalwithData: null | boolean

    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?: null | boolean,
      order?: "asc" | "desc",
      limit?: number,
  ): AsyncGenerator<Cell>

  Find cells of this signer

  Parameters

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

  Returns AsyncGenerator<Cell>

  A async generator that yields all matches cells

findTransactions

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

  Find transactions of this signer

  Parameters

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

  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.

signOnlyTransaction

• signOnlyTransaction(_: TransactionLike): Promise<Transaction>

  Signs a transaction without preparing information for it. This method is not implemented and should be overridden by subclasses.

  Parameters

  • _: TransactionLike

    The transaction to sign, represented as a TransactionLike object.

  Returns Promise<Transaction>

  A promise that resolves to the signed Transaction object.

  Throws

  Will throw an error if not implemented.

sendTransaction

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

  Send a transaction.

  Parameters

  • tx: TransactionLike

    The transaction to send.

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

  The transaction hash.