API reference

• buildETHTransaction: Create Ethereum transactions.

  • Parameters:

    • req: A PayloadBuildETHTransactionRequest object containing the transaction details.

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A Data object containing the raw Ethereum transaction in serialized form, or nil if the operation fails.

  • Throws: This method can throw an error if the input parameters are invalid or if there are issues constructing the transaction.

  • Example:

  let request = PayloadBuildETHTransactionRequest()
  
  do {
      let transaction = try client.buildETHTransaction(request, error: nil)
      if let txData = transaction {
          print("Ethereum transaction built successfully.")
      } else {
          print("Failed to build Ethereum transaction.")
      }
  } catch {
      print("Error creating Ethereum transaction: \(error.localizedDescription)")
  }

• buildSolTransaction: Create Solana transactions.

  • Parameters:

    • req: A PayloadBuildSolTransactionRequest object containing the transaction details.

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A Data object containing the raw Solana transaction in serialized form, or nil if the operation fails.

  • Throws: This method can throw an error if the input parameters are invalid or if there are issues constructing the transaction.

  • Example:

  let request = PayloadBuildSolTransactionRequest()
  
  do {
      let transaction = try client.buildSolTransaction(request, error: nil)
      if let txData = transaction {
          print("Solana transaction built successfully.")
      } else {
          print("Failed to build Solana transaction.")
      }
  } catch {
      print("Error creating Solana transaction: \(error.localizedDescription)")
  }

• buildTronTransaction: Create Tron transactions.

  • Parameters:

    • req: A PayloadBuildTronTransactionRequest object containing the transaction details.

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A Data object containing the raw Tron transaction in serialized form, or nil if the operation fails.

  • Throws: This method can throw an error if the input parameters are invalid or if there are issues constructing the transaction.

  • Example:

  let request = PayloadBuildTronTransactionRequest()
  
  do {
      let transaction = try client.buildTronTransaction(request, error: nil)
      if let txData = transaction {
          print("Tron transaction built successfully.")
      } else {
          print("Failed to build Tron transaction.")
      }
  } catch {
      print("Error creating Tron transaction: \(error.localizedDescription)")
  }

buildTonTransaction: Create Ton transactions.

• Parameters:

  • req: A PayloadBuildTonTransactionRequest object containing the transaction details.

  • error: An optional pointer to an Error object to capture errors, if any.

• Returns:

  • A Data object containing the raw Ton transaction in serialized form, or nil if the operation fails.

• Throws: This method can throw an error if the input parameters are invalid or if there are issues constructing the transaction.

• Example:

let request = PayloadBuildTonTransactionRequest()

do {
    let transaction = try client.buildTonTransaction(request, error: nil)
    if let txData = transaction {
        print("Ton transaction built successfully.")
    } else {
        print("Failed to build Ton transaction.")
    }
} catch {
    print("Error creating Ton transaction: \(error.localizedDescription)")
}

buildXrpTransaction: Create Xrp transactions.

• Parameters:

  • req: A PayloadBuildXrpTransactionRequest object containing the transaction details.

  • error: An optional pointer to an Error object to capture errors, if any.

• Returns:

  • A Data object containing the raw Xrp transaction in serialized form, or nil if the operation fails.

• Throws: This method can throw an error if the input parameters are invalid or if there are issues constructing the transaction.

• Example:

let request = PayloadBuildXrpTransactionRequest()

do {
    let transaction = try client.buildXrpTransaction(request, error: nil)
    if let txData = transaction {
        print("Xrp transaction built successfully.")
        print("Raw Transaction Data: \(txData)")
    } else {
        print("Failed to build Xrp transaction.")
    }
} catch {
    print("Error creating Xrp transaction: \(error.localizedDescription)")
}

buildBtcTransaction: Create Btc transactions.

• Parameters:

  • req: A PayloadBuildBtcTransactionRequest object containing the transaction details.

  • error: An optional pointer to an Error object to capture errors, if any.

• Returns:

  • A Data object containing the raw Btc transaction in serialized form, or nil if the operation fails.

• Throws: This method can throw an error if the input parameters are invalid or if there are issues constructing the transaction.

• Example:

let request = PayloadBuildBtcTransactionRequest()

do {
    let transaction = try client.buildBtcTransaction(request, error: nil)
    if let txData = transaction {
        print("Btc transaction built successfully.")
    } else {
        print("Failed to build Btc transaction.")
    }
} catch {
    print("Error creating Btc transaction: \(error.localizedDescription)")
}

• listBlockChainTransaction: Fetch a list of blockchain transactions.

  • Parameters:

    • req: A PayloadListBlockchainTransactionsRequest object containing the parameters for filtering transactions. - pageSize: The number of transactions per page.

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A PayloadListBlockchainTransactionsResponse object containing the list of transactions and pagination metadata, or nil if the operation fails.

  • Throws: This method can throw an error if the request parameters are invalid or if there are runtime issues.

  • Example:

  let request = PayloadListBlockchainTransactionsRequest()
  
  do {
      let response = try client.listBlockChainTransaction(request, error: nil)
      if let transactions = response?.transactions {
          print("Retrieved \(transactions.count) transactions:")
      } else {
          print("No transactions found.")
      }
  } catch {
      print("Error fetching transactions: \(error.localizedDescription)")
  }

• signing: Perform signing operations for a given MPC group.

  • Parameters:

    • req: A PayloadSigningRequest object containing the details for the signing operation.

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A Data object containing the digital signature, or nil if the operation fails.

  • Throws: This method can throw an error if the signing request is invalid, if the group is misconfigured, or if there are runtime issues during the operation.

  • Example:

  let request = PayloadSigningRequest()
  
  do {
      let signature = try client.signing(request, error: nil)
      if let signedData = signature {
          print("Signing operation completed successfully.")
      } else {
          print("Signing operation failed.")
      }
  } catch {
      print("Error performing signing operation: \(error.localizedDescription)")
  }

• profile: Retrieve the user's profile.

  • Parameters:

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A ModelUser object containing the user's profile information, or nil if the operation fails.

  • Throws: This method can throw an error if the user's profile is unavailable or if there are runtime issues.

  • Example:

  do {
      let userProfile = try client.profile(nil)
      if let profile = userProfile {
          print("User Profile Retrieved:")
      } else {
          print("No user profile found.")
      }
  } catch {
      print("Error retrieving user profile: \(error.localizedDescription)")
  }

• saveUserSetting: Save user-specific settings.

  • Parameters:

    • req: A PayloadSaveUserSettingRequest object containing the user settings to save.

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A boolean value indicating whether the operation was successful (true) or not (false).

  • Throws: This method can throw an error if the request payload is invalid or if there are runtime issues.

  • Example:

  let request = PayloadSaveUserSettingRequest()
  request.key = "theme"
  request.value = "dark" // Example setting: User's preferred theme
  
  do {
      let success = try client.saveUserSetting(request, error: nil)
      if success {
          print("User setting saved successfully.")
      } else {
          print("Failed to save user setting.")
      }
  } catch {
      print("Error saving user setting: \(error.localizedDescription)")
  }

• getUserSetting: Retrieve user-specific settings.

  • Parameters:

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A Data object containing the serialized user settings, or nil if the operation fails.

  • Throws: This method can throw an error if the settings cannot be retrieved or if there are runtime issues.

  • Example:

  do {
      let userSettingsData = try client.getUserSetting(nil)
      if let data = userSettingsData {
          print("User settings retrieved successfully.")
      } else {
          print("No user settings found.")
      }
  } catch {
      print("Error retrieving user settings: \(error.localizedDescription)")
  }

• prepareAASmartAccount: Prepare an Account Abstraction smart account.

  • Parameters:

    • req: A PayloadPrepareAASmartAccountRequest object containing the details for the smart account setup.

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A PayloadAASmartAccount object containing the details of the prepared smart account, including the account address and configuration, or nil if the operation fails.

  • Throws: This method can throw an error if the request is invalid, the network is unsupported, or there are runtime issues during the setup process.

  • Example:

  let request = PayloadPrepareAASmartAccountRequest()
  
  do {
      let smartAccount = try client.prepareAASmartAccount(request, error: nil)
      if let account = smartAccount {
          print("Smart account prepared successfully.")
          print("Account Address: \(account.accountAddress)")
          print("Network: \(account.network)")
      } else {
          print("Failed to prepare smart account.")
      }
  } catch {
      print("Error preparing smart account: \(error.localizedDescription)")
  }

• prepareAATxUserOp: Prepare a user operation for Account Abstraction transactions.

  • Parameters:

    • req: A PayloadPrepareAATxUserOpRequest object containing the details of the user operation to prepare.

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A PayloadPrepareAATxUserOpResponse object containing the prepared user operation, including details such as the encoded operation and required fields for signing, or nil if the operation fails.

  • Throws: This method can throw an error if the request parameters are invalid or if there are runtime issues during the preparation process.

  • Example:

  let request = PayloadPrepareAATxUserOpRequest()
  
  do {
      let userOpResponse = try client.prepareAATxUserOp(request, error: nil)
      if let operation = userOpResponse {
          print("User operation prepared successfully.")
          print("Encoded Operation: \(operation.encodedOperation)")
          print("Nonce: \(operation.nonce)")
      } else {
          print("Failed to prepare user operation.")
      }
  } catch {
      print("Error preparing user operation: \(error.localizedDescription)")
  }

• sendUserOperation: Sends a user operation to the blockchain for Account Abstraction (AA) transactions.

  • Parameters:

    • req: A PayloadSendUserOperationRequest object containing the details of the operation to execute.

    • error: An optional pointer to an Error object to capture errors, if any.

  • Returns:

    • A String object containing the transaction hash of the executed operation, or nil if the operation fails.

  • Throws: This method can throw an error if the request payload is invalid, the network is unavailable, or the operation fails during execution.

  • Example:

  let request = PayloadSendUserOperationRequest()
  
  do {
      let transactionHash = try client.sendUserOperation(request, error: nil)
      if let txHash = transactionHash {
          print("User operation sent successfully.")
          print("Transaction Hash: \(txHash)")
      } else {
          print("Failed to send user operation.")
      }
  } catch {
      print("Error executing user operation: \(error.localizedDescription)")
  }

• exportMnemonic: Retrieve wallet's Mnemonic phrase.

  • Parameters:

    • keygenGroupId: Master wallet's key generation group ID.

    • keyIdentities: The key identity of the wallet.

  • Returns:

    • A String containing your mnemonic, or nil if the operation fails.

  • Example:

  do {
      let mnemonic = try client.exportMnemonic("keygenGroupId", "keygenGroupId")
      print("Export mnemonic successfully.")
  } catch {
      print("Error retrieving to export Mnemonic : \(error.localizedDescription)")
  }
  

• deleteMPCGroup : Deletes a Paillier MPC group.

  • Parameters:

    • groupID: The unique identifier of the group to delete.

  • Throws: An error if the deletion fails.

  • Example:

  func main() {
      do {
          // Initialize the group ID
          let groupID = "keyGenGroupID"
          
          // Call deleteGroup to delete the group
          try deleteGroup(groupID: groupID)
          
          // Print success message
          print("Group with ID \(groupID) deleted successfully!")
      } catch {
          // Handle exceptions
          print("Failed to delete group: \(error.localizedDescription)")
      }
  }
  

• getCurrentPolicy: Retrieves the current policy as a publisher that emits [Policy] objects.

  • Returns: An [AnyPublisher] emitting [Policy] objects.

  • Throws: An error if fetching the current policy fails.

  • Example:

  fun main() {
      var cancellables = Set<AnyCancellable>()
      Task {
          do {
              let policyPublisher = try await getCurrentPolicy()
              policyPublisher
                  .sink(receiveCompletion: { completion in
                      switch completion {
                      case .finished:
                          print("Successfully received policy.")
                      case .failure(let error):
                          print("Error: \(error)")
                      }
                  }, receiveValue: { policy in
                      print("Current policy: \(policy)")
                  })
                  .store(in: &cancellables)
          } catch {
              print("Failed to fetch policy with error: \(error)")
          }
      }
  }

• enablePolicy: Enables the current policy with a specified delay and an option to force the operation.

  • Parameters:

    • delayHours: The number of hours to delay before enabling the policy.

    • force: A boolean flag indicating whether to force enable the policy, overriding existing conditions.

  • Returns: An [AnyPublisher] emitting the updated [Policy] object.

  • Throws: An error if enabling the policy fails.

  • Example::

  fun main() {
      var cancellables = Set<AnyCancellable>()
      Task {
          do {
              let policyPublisher = try await enablePolicy(delayHours: 24, force: true)
              policyPublisher
                  .sink(receiveCompletion: { completion in
                      switch completion {
                      case .finished:
                          print("Policy enabled successfully.")
                      case .failure(let error):
                          print("Error enabling policy: \(error)")
                      }
                  }, receiveValue: { policy in
                      print("Updated policy: \(policy)")
                  })
                  .store(in: &cancellables)
          } catch {
              print("Failed to enable policy with error: \(error)")
          }
      }
  }

• disablePolicy: isables the current policy and returns a publisher that emits the updated [Policy] object.

  • Returns: An [AnyPublisher] emitting the updated [Policy] object.

  • Throws: An error if disabling the policy fails.

  • Example:

  fun main() {
      var cancellables = Set<AnyCancellable>()
      Task {
          do {
              let policyPublisher = try await disablePolicy()
              policyPublisher
                  .sink(receiveCompletion: { completion in
                      switch completion {
                      case .finished:
                          print("Policy disabled successfully.")
                      case .failure(let error):
                          print("Error disabling policy: \(error)")
                      }
                  }, receiveValue: { policy in
                      print("Updated policy: \(policy)")
                  })
                  .store(in: &cancellables)
          } catch {
              print("Failed to disable policy with error: \(error)")
          }
      }
  }

• addWalletAddress: Adds a wallet address to the whitelist for a specific network chain with associated labels.

  • Parameters:

    • address: The wallet address to be added.

    • networkChain: The identifier for the blockchain network to which the address belongs.

    • labels: An array of labels to be associated with the wallet address.

  • Returns: An [AnyPublisher] emitting the newly added [Address] object.

  • Throws: An error if the wallet address cannot be added.

  • Example:

  fun main() {
  do {
      var cancellables = Set<AnyCancellable>()
      Task {
          do {
              let addressPublisher = try await addWalletAddress(
                  address: "0x123abc...",
                  networkChain: "ETH",
                  labels: ["whitelist", "verified"]
              )
              addressPublisher
                  .sink(receiveCompletion: { completion in
                      switch completion {
                      case .finished:
                          print("Wallet address added successfully.")
                      case .failure(let error):
                          print("Error adding wallet address: \(error)")
                      }
                  }, receiveValue: { address in
                      print("Added address: \(address)")
                  })
                  .store(in: &cancellables)
          } catch {
              print("Failed to add wallet address: \(error)")
          }
      }
  }

• removeWalletAddress: Removes the wallet address associated with the specified identifier.

  • Parameter walletId: The unique identifier of the wallet address to be removed.

  • Returns: An [AnyPublisher] emitting an optional [String] that indicates the result of the removal operation.

  • Throws: An error if the wallet address removal fails.

  • Example:

  fun main() {
      var cancellables = Set<AnyCancellable>()
      Task {
          do {
              let removalPublisher = try await removeWalletAddress(walletId: "walletId12345")
              removalPublisher
                  .sink(receiveCompletion: { completion in
                      switch completion {
                      case .finished:
                          print("Wallet address removed successfully.")
                      case .failure(let error):
                          print("Error removing wallet address: \(error)")
                      }
                  }, receiveValue: { removedId in
                      if let id = removedId {
                          print("Removed wallet address with id: \(id)")
                      } else {
                          print("No wallet address was removed.")
                      }
                  })
                  .store(in: &cancellables)
          } catch {
              print("Failed to remove wallet address with error: \(error)")
          }
      }
  }

• updateWalletAddress: Updates an existing wallet address with new labels.

  • Parameters:

    • walletId: The unique identifier of the wallet address to update.

    • labels: An array of new labels to associate with the wallet address.

  • Returns: An [AnyPublisher] emitting the updated [Address] object.

  • Throws: An error if updating the wallet address fails.

  • Example:

  fun main() {
      var cancellables = Set<AnyCancellable>()
  
      Task {
          do {
              let updatePublisher = try await updateWalletAddress(
                  walletId: "walletId12345",
                  labels: ["verified", "premium"]
              )
              updatePublisher
                  .sink(receiveCompletion: { completion in
                      switch completion {
                      case .finished:
                          print("Wallet address updated successfully.")
                      case .failure(let error):
                          print("Error updating wallet address: \(error)")
                      }
                  }, receiveValue: { address in
                      print("Updated address: \(address)")
                  })
                  .store(in: &cancellables)
          } catch {
              print("Failed to update wallet address with error: \(error)")
          }
      }
  }

getTransactionAmountLimit: Retrieves the current transaction amount limit policy, including per-transaction and daily limits.

• Parameters: None

• Returns: An AnyPublisher emitting the current TransactionLimitPolicy object.

• Throws: An error if retrieving the transaction limit policy fails.

• Example:

import Combine

var cancellables = Set<AnyCancellable>()

let limitPublisher = getTransactionAmountLimit()
limitPublisher
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Successfully retrieved transaction amount limit.")
        case .failure(let error):
            print("Error retrieving transaction amount limit: \(error)")
        }
    }, receiveValue: { policy in
        print("Transaction Limit Policy:")
        print("- Per transaction: \(policy.perTransactionLimit)")
        print("- Daily limit: \(policy.dailyLimit)")
        print("- Enabled: \(policy.enable)")
    })
    .store(in: &cancellables)

updateTransactionAmountLimit: Updates the transaction amount limit policy with new values for per-transaction and daily limits, and whether the policy is enabled.

• Parameters:

  • perTransactionLimit: The maximum amount allowed per individual transaction (in smallest denomination).

  • dailyLimit: The maximum cumulative amount allowed per day.

  • enable: A Boolean value indicating whether the transaction limit policy is enabled.

• Returns: An AnyPublisher<Void, Error> indicating completion of the update operation.

• Throws: An error if retrieving the transaction limit policy fails.

• Example:

import Combine

var cancellables = Set<AnyCancellable>()

Task {
    do {
        let updatePublisher = try await updateTransactionAmountLimit(
            perTransactionLimit: 500000,
            dailyLimit: 5000000,
            enable: true
        )

        updatePublisher
            .sink(receiveCompletion: { completion in
                switch completion {
                case .finished:
                    print("Transaction amount limit updated successfully.")
                case .failure(let error):
                    print("Error updating transaction amount limit: \(error)")
                }
            }, receiveValue: {
                // No data returned on success (Void)
            })
            .store(in: &cancellables)

    } catch {
        print("Failed to update transaction amount limit with error: \(error)")
    }
}