# LM\_PC\_RecurringPayments\_v1.sol

[Git Source](https://github.com/InverterNetwork/inverter-contracts/blob/649b450f02fc8b735c128ff0821467e71966c666/src/modules/logicModule/LM_PC_RecurringPayments_v1.sol)

**Inherits:** ILM\_PC\_RecurringPayments\_v1, ERC20PaymentClientBase\_v1

**Author:** Inverter Network

Facilitates the creation, management, and execution of scheduled recurring payments within the Inverter Network, allowing for systematic and timed financial commitments or subscriptions.

*Uses epochs to define the period of recurring payments and supports operations such as adding, removing, and triggering payments based on time cycles. Integrates with {ERC20PaymentClientBase\_v1} for handling actual payment transactions. Note that it will use the token type stored in the FundingManager for the payments.*

### State Variables

#### \_SENTINEL

*Marks the beginning of the list.*

```solidity
uint internal constant _SENTINEL = type(uint).max;
```

#### \_nextId

*Value for what the next id will be.*

```solidity
uint private _nextId;
```

#### epochLength

*length of an epoch.*

```solidity
uint private epochLength;
```

#### \_paymentRegistry

*Registry mapping ids to RecurringPayment structs id => RecurringPayment.*

```solidity
mapping(uint => RecurringPayment) private _paymentRegistry;
```

#### \_paymentList

*List of RecurringPayment id's.*

```solidity
LinkedIdList.List _paymentList;
```

#### \_\_gap

*Storage gap for future upgrades.*

```solidity
uint[50] private __gap;
```

### Functions

#### supportsInterface

*See {IERC165-supportsInterface}.*

```solidity
function supportsInterface(bytes4 interfaceId)
    public
    view
    virtual
    override(ERC20PaymentClientBase_v1)
    returns (bool);
```

#### validId

*Checks if the given id is valid.*

```solidity
modifier validId(uint recurringPaymentId);
```

**Parameters**

| Name                 | Type      | Description                              |
| -------------------- | --------- | ---------------------------------------- |
| `recurringPaymentId` | `uint256` | The id of the RecurringPayment to check. |

#### validStartEpoch

*Checks if the given startEpoch is valid.*

```solidity
modifier validStartEpoch(uint startEpoch);
```

**Parameters**

| Name         | Type      | Description                                      |
| ------------ | --------- | ------------------------------------------------ |
| `startEpoch` | `uint256` | The startEpoch of the RecurringPayment to check. |

#### startIdBeforeEndId

*Checks if the startId is before the endId.*

```solidity
modifier startIdBeforeEndId(uint startId, uint endId);
```

**Parameters**

| Name      | Type      | Description                                   |
| --------- | --------- | --------------------------------------------- |
| `startId` | `uint256` | The startId of the RecurringPayment to check. |
| `endId`   | `uint256` | The endId of the RecurringPayment to check.   |

#### init

```solidity
function init(
    IOrchestrator_v1 orchestrator_,
    Metadata memory metadata,
    bytes memory configData
) external override(Module_v1) initializer;
```

#### getEpochLength

Returns the length of an epoch.

```solidity
function getEpochLength() external view returns (uint);
```

**Returns**

| Name     | Type      | Description                                         |
| -------- | --------- | --------------------------------------------------- |
| `<none>` | `uint256` | epochLength Length of an epoch in a uint timestamp. |

#### getRecurringPaymentInformation

Returns the RecurringPayment instance with id `id`.

```solidity
function getRecurringPaymentInformation(uint id)
    external
    view
    validId(id)
    returns (RecurringPayment memory);
```

**Parameters**

| Name | Type      | Description                               |
| ---- | --------- | ----------------------------------------- |
| `id` | `uint256` | The id of the RecurringPayment to return. |

**Returns**

| Name     | Type               | Description                    |
| -------- | ------------------ | ------------------------------ |
| `<none>` | `RecurringPayment` | RecurringPayment with id `id`. |

#### listRecurringPaymentIds

Returns total list of RecurringPayment ids.

*List is in ascending order.*

```solidity
function listRecurringPaymentIds() external view returns (uint[] memory);
```

**Returns**

| Name     | Type        | Description                   |
| -------- | ----------- | ----------------------------- |
| `<none>` | `uint256[]` | List of RecurringPayment ids. |

#### getPreviousPaymentId

Returns the id of previous RecurringPayment.

```solidity
function getPreviousPaymentId(uint id) external view returns (uint);
```

**Parameters**

| Name | Type      | Description                               |
| ---- | --------- | ----------------------------------------- |
| `id` | `uint256` | The id of the RecurringPayment to return. |

**Returns**

| Name     | Type      | Description                                 |
| -------- | --------- | ------------------------------------------- |
| `<none>` | `uint256` | prevId The id of previous RecurringPayment. |

#### isExistingRecurringPaymentId

Returns whether RecurringPayment with id `id` exists.

```solidity
function isExistingRecurringPaymentId(uint id) public view returns (bool);
```

**Parameters**

| Name | Type      | Description                             |
| ---- | --------- | --------------------------------------- |
| `id` | `uint256` | The id of the RecurringPayment to test. |

**Returns**

| Name     | Type   | Description                                                    |
| -------- | ------ | -------------------------------------------------------------- |
| `<none>` | `bool` | True if RecurringPayment with id `id` exists, false otherwise. |

#### getEpochFromTimestamp

Calculates the epoch from a given uint timestamp.

*Calculation is: timestamp divided by epochLength.*

```solidity
function getEpochFromTimestamp(uint timestamp)
    external
    view
    returns (uint epoch);
```

**Parameters**

| Name        | Type      | Description                   |
| ----------- | --------- | ----------------------------- |
| `timestamp` | `uint256` | A timestamp in a uint format. |

**Returns**

| Name    | Type      | Description                          |
| ------- | --------- | ------------------------------------ |
| `epoch` | `uint256` | Epoch in which timestamp belongs to. |

#### getCurrentEpoch

Calculates the current epoch.

*Calculation is: block.timestamp divided by epochLength.*

```solidity
function getCurrentEpoch() public view returns (uint epoch);
```

**Returns**

| Name    | Type      | Description                                                    |
| ------- | --------- | -------------------------------------------------------------- |
| `epoch` | `uint256` | Epoch in which current timestamp (block.timestamp) belongs to. |

#### getFutureEpoch

Calculates a future epoch x epochs from now.

*Calculation is: current epoch + X epochs in the future = futureEpoch.*

```solidity
function getFutureEpoch(uint xEpochsInTheFuture)
    external
    view
    returns (uint futureEpoch);
```

**Parameters**

| Name                 | Type      | Description                             |
| -------------------- | --------- | --------------------------------------- |
| `xEpochsInTheFuture` | `uint256` | How many epochs from the current epoch. |

**Returns**

| Name          | Type      | Description          |
| ------------- | --------- | -------------------- |
| `futureEpoch` | `uint256` | Epoch in the future. |

#### addRecurringPayment

Adds a recurring payment to the manager.

*a new id is created for each Payment.*

```solidity
function addRecurringPayment(uint amount, uint startEpoch, address recipient)
    external
    onlyOrchestratorAdmin
    validAmount(amount)
    validStartEpoch(startEpoch)
    validRecipient(recipient)
    returns (uint id);
```

**Parameters**

| Name         | Type      | Description                                                                                                       |
| ------------ | --------- | ----------------------------------------------------------------------------------------------------------------- |
| `amount`     | `uint256` | Amount of tokens send to the recipient address.                                                                   |
| `startEpoch` | `uint256` | Epoch in which the payment starts. Use getEpochFromTimestamp() or getCurrentEpoch() to get the appropriate epoch. |
| `recipient`  | `address` | Recipient address that should receive tokens.                                                                     |

**Returns**

| Name | Type      | Description                                |
| ---- | --------- | ------------------------------------------ |
| `id` | `uint256` | Id of the newly created recurring payment. |

#### removeRecurringPayment

Removes a recurring Payment.

```solidity
function removeRecurringPayment(uint prevId, uint id)
    external
    onlyOrchestratorAdmin;
```

**Parameters**

| Name     | Type      | Description                                               |
| -------- | --------- | --------------------------------------------------------- |
| `prevId` | `uint256` | Id of the previous recurring payment in the payment list. |
| `id`     | `uint256` | Id of the recurring payment that is to be removed.        |

#### trigger

Triggers the start of the due payments for all recurring payment orders.

```solidity
function trigger() external;
```

#### triggerFor

See trigger() but enables you to determine which ids you want to trigger payment ordes for.

*this is to being able to bypass the unlikely event of having a runOutOfGas error for the normal trigger function.*

```solidity
function triggerFor(uint startId, uint endId)
    external
    validId(startId)
    validId(endId)
    startIdBeforeEndId(startId, endId);
```

**Parameters**

| Name      | Type      | Description                                                                |
| --------- | --------- | -------------------------------------------------------------------------- |
| `startId` | `uint256` | : id of start position of the recurring payments that should be triggered. |
| `endId`   | `uint256` | : id of end position of the recurring payments that should be triggered.   |

#### \_triggerFor

*Triggers the given RecurringPayment.*

```solidity
function _triggerFor(uint startId, uint endId) private;
```

**Parameters**

| Name      | Type      | Description                                      |
| --------- | --------- | ------------------------------------------------ |
| `startId` | `uint256` | The id of the first RecurringPayment to trigger. |
| `endId`   | `uint256` | The id of the last RecurringPayment to trigger.  |


---

# 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://docs.inverter.network/contracts/technical-reference/modules/logic-module/lm_pc_recurringpayments_v1.sol.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.