# Transaction Policy
The [Transaction Policy (TP)](https://cramiumlabs.gitbook.io/docs/feature-list/transaction-policy) module ensures secure and customizable transaction controls for users by integrating features like whitelisting and time delays.
#### 1. getCurrentPolicy
The `getCurrentPolicy()` method retrieves the current transaction policy configuration. This includes details about the whitelisted addresses, time limits, and whether the policy is enabled.
**Example**:
```kotlin
fun main() {
// Retrieve the current transaction policy
val resPolicy = getCurrentPolicy()
}
```
#### 2. enablePolicy
The `enablePolicy()` method allows updating the settings of a transaction policy. This method supports enabling/disabling the policy - enabled: A flag to enable or disable the transaction policy. - force: A flag to enable the turning- off mode (default is false) **Example**:
```kotlin
fun main() {
val force = false
val enablePolicy = true
// Update the Transaction Policy
val updatedPolicy = enablePolicy(enabled, force)
// Handle the response
println("Transaction Policy Updated: $updatedPolicy")
}
```
#### 3. disablePolicy
The `disablePolicy()` method allows updating the settings of a transaction policy. This method supports enabling/disabling the policy
**Example**:
```kotlin
fun main() {
// Update the Transaction Policy
val updatedPolicy = disablePolicy()
// Handle the response
println("Transaction Policy Updated: $updatedPolicy")
}
```
#### 4. addWalletAddress
The `addWalletAddress()` method allows you to add a recipient’s wallet address to the whitelist. - address: The recipient's wallet address that you want to whitelist. - networkChain: the chain of wallet - labels: the alias of wallet
**Example**:
```kotlin
fun main() {
// Address to be added to the whitelist
val recipientAddress = "RecipientAddress"
val networkChain = "BTC"
val labels = ["alias0"]
// Add the address to the whitelist
val whitelistResult = addWalletAddress(recipientAddress, networkChain, labels)
// Handle the response
println("Whitelisted Address Result: $whitelistResult")
}
```
#### 5. removeWalletAddress
The `removeWalletAddress()` method removes a specified address from the whitelist. - walletId: The whitelist wallet id
**Example**:
```kotlin
fun main() {
// Address to be added to the whitelist
val walletId = "recipientAddressId"
// Remove the address to the whitelist
val whitelistResult = removeWalletAddress(walletId)
// Handle the response
println("Whitelisted Address Result: $whitelistResult")
}
```
#### 6. updateWalletAddress
The `updateWalletAddress()` method update a specified address from the whitelist. - walletId: The whitelist wallet id - labels: the alias of wallet
**Example**:
```kotlin
fun main() {
// Address to be added to the whitelist
val walletId = "recipientAddressId"
val labels = ["alias0"]
// Add the address to the whitelist
val whitelistResult = updateWalletAddress(walletId, labels)
// Handle the response
println("Whitelisted Address Result: $whitelistResult")
}
```
#### 7. getTransactionAmountLimit
The `getTransactionAmountLimit()` method retrieves the current transaction limit policy.
**Example**:
```kotlin
fun main() {
// Retrieve the current transaction limit policy
val limitPolicy = getTransactionAmountLimit().first()
// Handle the response
println("Transaction Limit Policy: $limitPolicy")
}
```
8\. updateTransactionAmountLimit
The `updateTransactionAmountLimit()` method updates the transaction amount limit with the specified parameters.
**Example**:
```kotlin
fun main() {
// Define the new transaction limits and whether they're enabled
val perTxLimit = 1000L
val dailyTxLimit = 5000L
val isLimitEnabled = true
// Update the transaction amount limit
val updateResult = updateTransactionAmountLimit(perTxLimit, dailyTxLimit, isLimitEnabled).first()
// Handle the response
println("Update Transaction Amount Limit Result: $updateResult")
}
```
***
#### 9. updateTransactionLimitPolicyForSpecificAddress
The `updateTransactionLimitPolicyForSpecificAddress()` method sets or updates the transaction limits for a specific address. The new limits must adhere to the global limits, and increasing the limits may trigger a security delay (whitelisting process).
* **Parameters:**
* `address`: The wallet address for which the limits are being set.
* `networkChain`: The blockchain network identifier.
* `perTransactionLimit`: The maximum allowed amount for a single transaction for this address.
* `dailyLimit`: The maximum allowed cumulative amount per day for this address.
* `enable`: A flag indicating whether the limits for this address should be enabled.
**Example:**
```kotlin
fun main() {
// Define address-specific limits
val address = "0x1234567890123456789012345678901234567890"
val networkChain = "1"
val perTransactionLimit = 50000L
val dailyLimit = 200000L
val enable = true
// Update the transaction limits for the specific address
val updateResult = updateTransactionLimitPolicyForSpecificAddress(address, networkChain, perTransactionLimit, dailyLimit, enable).first()
// Handle the response
println("Updated Address-Specific Transaction Limit: $updateResult")
}
```
***
#### 10. getTransactionCurrentUsage
The `getTransactionCurrentUsage()` method retrieves a snapshot of the current day's transaction usage, including both global totals and address-specific details.
**Example:**
```kotlin
fun main() {
// Retrieve the current transaction usage for today
val usageSnapshot = getTransactionCurrentUsage().first()
// Handle the response
println("Current Transaction Usage Snapshot: $usageSnapshot")
}
```
***
#### 11. checkAmountWithPolicy
The `checkAmountWithPolicy()` method validates whether a given transaction amount (in USD) complies with the current transaction policy limits for a specific address.
* **Parameters:**
* `amountInUsd`: The transaction amount in USD.
* `address`: The wallet address for the transaction.
* `networkChain`: The blockchain network identifier.
**Example:**
```kotlin
fun main() {
val amountInUsd = 750L
val address = "0x1234567890123456789012345678901234567890"
val networkChain = "1"
// Check if the transaction amount is within policy limits
val isAllowed = checkAmountWithPolicy(amountInUsd, address, networkChain).first()
// Handle the response
println("Is the transaction amount allowed? $isAllowed")
}
```
***
#### 12. recordTransactionDailyUsage
The `recordTransactionDailyUsage()` method records a transaction for daily usage tracking. It updates the cumulative total, records the status, and automatically resets if a new day begins.
* **Parameters:**
* `address`: The wallet address from which the transaction originated.
* `networkChain`: The blockchain network identifier.
* `amount`: The transaction amount.
* `status`: The transaction status (e.g., `SUCCESS`, `FAILED`, or `UNKNOWN`).
**Example:**
```kotlin
fun main() {
val address = "0x1234567890123456789012345678901234567890"
val networkChain = "1"
val amount = 500L
val status = TransactionRecordStatus.SUCCESS // Enum or constant representing the status
// Record the transaction for daily usage tracking
val recordResponse = recordTransactionDailyUsage(address, networkChain, amount, status).first()
// Handle the response
println("Transaction Recorded: $recordResponse")
}
```
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://cramiumlabs.gitbook.io/docs/sdk-mpc-android/usage-guide-for-an-mpc-wallet-app/transaction-policy.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.