Class DAppConnector

constructor

• new DAppConnector(metadata, network, projectId, methods?, events?, chains?): DAppConnector

• Initializes the DAppConnector instance.

  Parameters

  • metadata: Metadata

    SignClientTypes.Metadata object for the DApp metadata.

  • network: LedgerId

    LedgerId representing the network (default: LedgerId.TESTNET).

  • projectId: string

    Project ID for the WalletConnect client.

  • Optional methods: string[]

    Array of supported methods for the DApp (optional).

  • Optional events: string[]

    Array of supported events for the DApp (optional).

  • Optional chains: string[]

  Returns DAppConnector

dAppMetadata

isInitializing

network

projectId

signers

supportedChains

supportedEvents

supportedMethods

walletConnectClient

connect

• connect(launchCallback, pairingTopic?): Promise<void>

• Initiates the WallecConnect connection flow using URI.

  Parameters

  • launchCallback: ((uri) => void)

    • • (uri): void

      • Parameters

        • uri: string

        Returns void

  • Optional pairingTopic: string

    The pairing topic for the connection (optional).

  Returns Promise<void>

  A Promise that resolves when the connection process is complete.

connectQR

• connectQR(pairingTopic?): Promise<void>

• Initiates the WalletConnect connection flow using a QR code.

  Parameters

  • Optional pairingTopic: string

    The pairing topic for the connection (optional).

  Returns Promise<void>

  A Promise that resolves when the connection process is complete.

disconnect

• disconnect(topic): Promise<void>

• Disconnects the current session associated with the specified topic.

  Parameters

  • topic: string

    The topic of the session to disconnect.

  Returns Promise<void>

  A Promise that resolves when the session is disconnected.

disconnectAll

• disconnectAll(): Promise<void>

• Disconnects all active sessions and pairings.

  Throws error when WalletConnect is not initialized or there are no active sessions/pairings.

  Returns Promise<void>

  A Promise that resolves when all active sessions and pairings are disconnected.

executeTransaction

• executeTransaction(params): Promise<ExecuteTransactionResult>

• Executes a transaction on the Hedera network.

  Parameters

  • params: ExecuteTransactionParams

    The parameters of type ExecuteTransactionParams required for the transaction execution.

  Returns Promise<ExecuteTransactionResult>

  Promise<ExecuteTransactionResult>

  Example

  Use helper transactionToBase64String to encode Transaction to Base64 string

  const params = {
   signedTransaction: [transactionToBase64String(transaction)]
  }
  
  const result = await dAppConnector.executeTransaction(params)
  Copy

getNodeAddresses

• getNodeAddresses(): Promise<GetNodeAddressesResult>

• Retrieves the node addresses associated with the current Hedera network.

  When there is no active session or an error occurs during the request.

  Returns Promise<GetNodeAddressesResult>

  Promise<GetNodeAddressesResult>

init

• init(logger?): Promise<void>

• Initializes the DAppConnector instance.

  Parameters

  • logger: {
        logger?: BaseLogger;
    } = {}

    BaseLogger for logging purposes (optional).

    • Optional logger?: BaseLogger

  Returns Promise<void>

openModal

• openModal(pairingTopic?): Promise<void>

• Initiates the WalletConnect connection flow using a QR code.

  Parameters

  • Optional pairingTopic: string

    The pairing topic for the connection (optional).

  Returns Promise<void>

  A Promise that resolves when the connection process is complete.

signAndExecuteQuery

• signAndExecuteQuery(params): Promise<SignAndExecuteQueryResult>

• Signs and send Query on the Hedera network.

  Parameters

  • params: SignAndExecuteQueryParams

    The parameters of type SignAndExecuteQueryParams required for the Query execution.

  Returns Promise<SignAndExecuteQueryResult>

  Promise<SignAndExecuteQueryResult>

  Example

  Use helper queryToBase64String to encode Query to Base64 string

  const params = {
   signerAccountId: '0.0.12345',
   query: queryToBase64String(query),
  }
  
  const result = await dAppConnector.signAndExecuteQuery(params)
  Copy

signAndExecuteTransaction

• signAndExecuteTransaction(params): Promise<SignAndExecuteTransactionResult>

• Signs and executes Transactions on the Hedera network.

  Parameters

  • params: SignAndExecuteTransactionParams

    The parameters of type SignAndExecuteTransactionParams required for Transaction signing and execution.

  Returns Promise<SignAndExecuteTransactionResult>

  Promise<SignAndExecuteTransactionResult>

  Example

  Use helper transactionToBase64String to encode Transaction to Base64 string

  const params = {
   signerAccountId: '0.0.12345'
   transaction: [transactionToBase64String(transaction)]
  }
  
  const result = await dAppConnector.signAndExecuteTransaction(params)
  Copy

signMessage

• signMessage(params): Promise<SignMessageResult>

• Signs a provided message with provided signerAccountId.

  Parameters

  • params: SignMessageParams

    The parameters of type SignMessageParams required for signing message.

  Returns Promise<SignMessageResult>

  Promise<SignMessageResult>

  Example

  const params = {
   signerAccountId: '0.0.12345',
   message: 'Hello World!'
  }
  
  const result = await dAppConnector.signMessage(params)
  Copy

signTransaction

• signTransaction(params): Promise<SignTransactionResult>

• Signs and executes Transactions on the Hedera network.

  Parameters

  • params: SignTransactionParams

    The parameters of type SignTransactionParams required for Transaction signing.

  Returns Promise<SignTransactionResult>

  Promise<SignTransactionResult>

  Example

  const transactionBodyObject = transactionToTransactionBody(transaction, AccountId.fromString('0.0.3'))
  const transactionBody = transactionBodyToBase64String(transactionBodyObject)
  
  const params = {
   signerAccountId: '0.0.12345',
   transactionBody
  }
  
  const result = await dAppConnector.signTransaction(params)
  Copy