# 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**:

```swift
    fun main() {
        // Retrieve the current transaction policy
        let resPolicy = getCurrentPolicy()
    }

```

#### 3. enablePolicy

The `enablePolicy()` method allows enabling/disabling of a transaction policy. - enabled: A flag to enable or disable the transaction policy. - force: A flag to enable the turning- off mode (default is false)

**Example**:

```swift
    fun main() {
        let enablePolicy = true
        let force = true
    
        // enable the Transaction Policy
        let updatedPolicy = enablePolicy(
            enablePolicy: enablePolicy,
            force: force,
        )
    }

```

#### 3. disablePolicy

The `disablePolicy()` method allows disable transaction policy.

**Example**:

```swift
    fun main() {
         val updatedPolicy = disablePolicy()
    }

```

#### 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**:

```swift
   fun main() {
        // Address to be added to the whitelist
        let recipientAddress = "recipientAddress"
        let networkChain = "networkChain"
        let labels = ["alias0"]

        // Add the address to the whitelist
        let 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**:

```swift
   fun main() {
        // Address to be added to the whitelist
        let walletId = "walletId"

        // Add the address to the whitelist
        let whitelistResult = removeWalletAddress(walletId)
    }

```

#### 6. updateWalletAddress

The `updateWalletAddress()` method update a specified address from the whitelist. - walletId: The whitelist wallet id - labels: the alias of wallet

**Example**:

```swift
   fun main() {

        let walletId = "walletId"
        let labels = ["alias0"]
        
        let resValidateStatus = updateWalletAddress(walletId, labels)
        
    }

```

#### 7. getTransactionAmountLimit

The `getTransactionAmountLimit()` method retrieves the current transaction amount limit policy.

* **Returns**: The current `TransactionLimitPolicy` object.
* **Throws**: An error if the retrieval process fails.

**Example**:

```swift
func main() {
    do {
        let policy = try await getTransactionAmountLimit()
    } catch {
        print("Error retrieving transaction limit policy: \(error)")
    }
}

```

#### 8. updateTransactionAmountLimit

The `updateTransactionAmountLimit()` method updates the transaction amount limit policy with new parameters.

* **Parameters**:
  * `perTransactionLimit`: The maximum allowed amount per transaction.
  * `dailyLimit`: The maximum cumulative amount allowed per day.
  * `enable`: A Boolean indicating whether the transaction limit policy should be enabled.
* **Throws**: An error if updating the transaction amount limit fails.

**Example**:

```swift
func main() {
    do {
        try await updateTransactionAmountLimit(perTransactionLimit: 500000, dailyLimit: 5000000, enable: true)
        print("Transaction amount limit updated successfully.")
    } catch {
        print("Error updating transaction amount limit: \(error)")
    }
}
```

#### 9. updateTransactionAmountLimitForSpecificAddress

**Description:**\
Updates the transaction amount limit for a specific wallet address and its associated network chain. The new limits must not exceed the corresponding global limits. Increases may be staged (subject to a security delay or whitelisting process), while reductions take effect immediately.

**Parameters:**

* `address`: The wallet address whose limits are being updated.
* `networkChain`: The blockchain network identifier (e.g., "1" for Ethereum).
* `perTransactionLimit`: The new maximum allowed amount for a single transaction for this address.
* `dailyLimit`: The new maximum cumulative amount allowed per day for this address.
* `enable`: A Boolean indicating whether the new limits should be enabled.

**Throws:**\
An error if the update operation fails.

**Example:**

```swift
func main() async {
    do {
        let address = "walletAddress"
        let networkChain = "1"
        let perTransactionLimit: Int64 = 100000
        let dailyLimit: Int64 = 1000000
        let enable = true
        try await updateTransactionAmountLimitForSpecificAddress(
            address: address,
            networkChain: networkChain,
            perTransactionLimit: perTransactionLimit,
            dailyLimit: dailyLimit,
            enable: enable
        )
        print("Specific address transaction limit updated successfully.")
    } catch {
        print("Error updating transaction amount limit for specific address: \(error)")
    }
}
```

***

#### 10. getTransactionCurrentUsage

**Description:**\
Retrieves the current snapshot of daily transaction usage. This includes global usage totals as well as detailed usage statistics per wallet address.

**Returns:**\
A `TransactionCurrentUsage` object containing today's transaction usage details.

**Throws:**\
An error if the operation fails.

**Example:**

```swift
func main() async {
    do {
        let usage = try await getTransactionCurrentUsage()
        print("Transaction Usage: \(usage)")
    } catch {
        print("Error retrieving transaction usage: \(error)")
    }
}
```

***

#### 11. recordTransactionDailyUsage

**Description:**\
Records a transaction for daily usage tracking. It logs the transaction amount, status, and associated wallet information. Daily counters are automatically reset when the day changes.

**Parameters:**

* `address`: The wallet address from which the transaction originated.
* `networkChain`: The blockchain network identifier.
* `amount`: The transaction amount.
* `status`: The status of the transaction (e.g., `"SUCCESS"`, `"FAILED"`, or `"UNKNOWN"`).

**Returns:**\
A `TransactionRecordResponse` object containing updated usage totals and the recorded date.

**Throws:**\
An error if the operation fails.

**Example:**

```swift
func main() async {
    do {
        let address = "walletAddress"
        let networkChain = "1"
        let amount: Int64 = 25000
        let status: TransactionRecordStatus = .SUCCESS
        let recordResponse = try await recordTransactionDailyUsage(
            address: address,
            networkChain: networkChain,
            amount: amount,
            status: status
        )
        print("Transaction recorded: \(recordResponse)")
    } catch {
        print("Error recording transaction: \(error)")
    }
}
```

***

#### 12. checkAmountWithPolicy

**Description:**\
Validates whether a given transaction amount in USD complies with the current global and address-specific limits defined by the active policy.

**Parameters:**

* `amountInUsd`: The transaction amount in USD.
* `address`: The wallet address associated with the transaction.
* `networkChain`: The blockchain network identifier.

**Returns:**\
A Boolean value indicating if the transaction amount is within the allowed limits.

**Throws:**\
An error if the validation operation fails.

**Example:**

```swift
func main() async {
    do {
        let amountInUsd: Int64 = 1500
        let address = "walletAddress"
        let networkChain = "1"
        let isValid = try await checkAmountWithPolicy(amountInUsd: amountInUsd, address: address, networkChain: networkChain)
        print("Transaction amount valid: \(isValid)")
    } catch {
        print("Error validating transaction amount: \(error)")
    }
}
```


---

# 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-ios/usage-guide-for-an-mpc-wallet-app/transaction-policy.md?ask=<question>
```

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.