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)")
    }
}

PreviousImporting and Initializing NextUsage Guide for an MPC Wallet App

Last updated 1 month ago