# ERC20PaymentClientBase\_v1.sol

## ERC20PaymentClientBase\_v1

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

**Inherits:** IERC20PaymentClientBase\_v1, Module\_v1

**Author:** Inverter Network

Enables modules within the Inverter Network to create and manage payment orders that can be processed by authorized payment processors, ensuring efficient and secure transactions.

*Utilizes {SafeERC20} for token operations and integrates with {IPaymentProcessor\_v1} to handle token payments. This abstract contract must be extended by modules that manage {ERC20} payment orders, supporting complex payment scenarios.*

### State Variables

#### \_orders

*The list of oustanding orders.*

*Emptied whenever orders are collected.*

```solidity
PaymentOrder[] internal _orders;
```

#### \_outstandingTokenAmounts

*The current cumulative amount of tokens outstanding.*

```solidity
mapping(address => uint) internal _outstandingTokenAmounts;
```

#### \_flagCount

*The number of payment processor flags used by this payment client.*

```solidity
uint8 internal _flagCount;
```

#### \_flags

*The payment processor flags used by this payment client.*

```solidity
bytes32 internal _flags;
```

#### \_\_gap

*Storage gap for future upgrades.*

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

### Functions

#### supportsInterface

*See {IERC165-supportsInterface}.*

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

#### validRecipient

*Modifier to guarantee the recipient is valid.*

```solidity
modifier validRecipient(address recipient);
```

#### validAmount

*Modifier to guarantee the amount is valid.*

```solidity
modifier validAmount(uint amount);
```

#### validPaymentOrder

*Modifier to guarantee the payment order is valid.*

```solidity
modifier validPaymentOrder(PaymentOrder memory order);
```

#### \_\_ERC20PaymentClientBase\_v1\_init

*Initializes the staking contract.*

```solidity
function __ERC20PaymentClientBase_v1_init(uint8[] memory flags_)
    internal
    onlyInitializing;
```

**Parameters**

| Name     | Type      | Description                                                                            |
| -------- | --------- | -------------------------------------------------------------------------------------- |
| `flags_` | `uint8[]` | The flags, represented as an array of uint8 containing the flag IDs between 0 and 255. |

#### \_addPaymentOrder

*Adds a new {PaymentOrder} to the list of outstanding orders.*

```solidity
function _addPaymentOrder(PaymentOrder memory order)
    internal
    virtual
    validPaymentOrder(order);
```

**Parameters**

| Name    | Type           | Description            |
| ------- | -------------- | ---------------------- |
| `order` | `PaymentOrder` | The new payment order. |

#### \_addPaymentOrders

*Adds a set of new {PaymentOrder}s to the list of outstanding orders.*

```solidity
function _addPaymentOrders(PaymentOrder[] memory orders) internal virtual;
```

**Parameters**

| Name     | Type             | Description                     |
| -------- | ---------------- | ------------------------------- |
| `orders` | `PaymentOrder[]` | The list of new Payment Orders. |

#### \_setFlags

*Sets the flags for the PaymentOrders.*

```solidity
function _setFlags(uint8 flagCount_, uint8[] memory flags_) internal virtual;
```

**Parameters**

| Name         | Type      | Description                                                                            |
| ------------ | --------- | -------------------------------------------------------------------------------------- |
| `flagCount_` | `uint8`   | The number of flags.                                                                   |
| `flags_`     | `uint8[]` | The flags, represented as an array of uint8 containing the flag IDs between 0 and 255. |

#### paymentOrders

Returns the list of outstanding payment orders.

```solidity
function paymentOrders()
    external
    view
    virtual
    returns (PaymentOrder[] memory);
```

**Returns**

| Name     | Type             | Description             |
| -------- | ---------------- | ----------------------- |
| `<none>` | `PaymentOrder[]` | list of payment orders. |

#### outstandingTokenAmount

Returns the total outstanding token payment amount.

```solidity
function outstandingTokenAmount(address token_)
    external
    view
    virtual
    returns (uint total_);
```

**Parameters**

| Name     | Type      | Description                |
| -------- | --------- | -------------------------- |
| `token_` | `address` | The token in which to pay. |

**Returns**

| Name     | Type      | Description             |
| -------- | --------- | ----------------------- |
| `total_` | `uint256` | amount of token to pay. |

#### collectPaymentOrders

Collects outstanding payment orders.

*Marks the orders as completed for the client.*

```solidity
function collectPaymentOrders()
    external
    virtual
    returns (
        PaymentOrder[] memory paymentOrders_,
        address[] memory tokens_,
        uint[] memory totalAmounts_
    );
```

**Returns**

| Name             | Type             | Description              |
| ---------------- | ---------------- | ------------------------ |
| `paymentOrders_` | `PaymentOrder[]` | list of payment orders.  |
| `tokens_`        | `address[]`      | list of token addresses. |
| `totalAmounts_`  | `uint256[]`      | list of amounts.         |

#### amountPaid

Notifies the PaymentClient, that tokens have been paid out accordingly.

*Payment Client will reduce the total amount of tokens it will stock up by the given amount.*

```solidity
function amountPaid(address token_, uint amount_) external virtual;
```

**Parameters**

| Name      | Type      | Description                               |
| --------- | --------- | ----------------------------------------- |
| `token_`  | `address` | The token in which the payment was made.  |
| `amount_` | `uint256` | amount of tokens that have been paid out. |

#### getFlags

Returns the flags used when creating payment orders in this client.

```solidity
function getFlags() public view returns (bytes32 flags_);
```

**Returns**

| Name     | Type      | Description                     |
| -------- | --------- | ------------------------------- |
| `flags_` | `bytes32` | The flags this client will use. |

#### getFlagCount

Returns the number of flags this client uses for PaymentOrders.

```solidity
function getFlagCount() public view returns (uint8 flagCount_);
```

**Returns**

| Name         | Type    | Description          |
| ------------ | ------- | -------------------- |
| `flagCount_` | `uint8` | The number of flags. |

#### \_ensureValidRecipient

*Ensures the recipient is valid.*

```solidity
function _ensureValidRecipient(address recipient) private view;
```

**Parameters**

| Name        | Type      | Description             |
| ----------- | --------- | ----------------------- |
| `recipient` | `address` | The recipient to check. |

#### \_ensureValidAmount

*Ensures the amount is valid.*

```solidity
function _ensureValidAmount(uint amount) private pure;
```

**Parameters**

| Name     | Type      | Description          |
| -------- | --------- | -------------------- |
| `amount` | `uint256` | The amount to check. |

#### \_ensureValidToken

*Ensures the token is valid.*

```solidity
function _ensureValidToken(address token) private pure;
```

**Parameters**

| Name    | Type      | Description         |
| ------- | --------- | ------------------- |
| `token` | `address` | The token to check. |

#### \_ensureValidPaymentOrder

*Ensures the payment order is valid.*

```solidity
function _ensureValidPaymentOrder(PaymentOrder memory order) private;
```

**Parameters**

| Name    | Type           | Description                 |
| ------- | -------------- | --------------------------- |
| `order` | `PaymentOrder` | The payment order to check. |

#### \_ensureTokenBalance

*Ensures `amount` of payment tokens exist in address(this). In case the token being paid out is the FundingManager token, it will trigger a callback to the FundingManager to transfer the tokens to*

```solidity
function _ensureTokenBalance(address token) internal virtual;
```

#### \_ensureTokenAllowance

*Ensures `amount` of token allowance for payment processor(s).*

```solidity
function _ensureTokenAllowance(IPaymentProcessor_v1 spender, address token)
    internal
    virtual;
```

#### \_isAuthorizedPaymentProcessor

*Returns whether address `who` is an authorized payment processor.*

```solidity
function _isAuthorizedPaymentProcessor(IPaymentProcessor_v1 who)
    internal
    view
    virtual
    returns (bool);
```

#### \_assemblePaymentConfig

*Returns the payment configuration from a list of supplied flag values. Can be overriden to add additional validation steps.*

```solidity
function _assemblePaymentConfig(bytes32[] memory flagValues_)
    internal
    view
    virtual
    returns (bytes32 flags_, bytes32[] memory data_);
```


---

# 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/abstracts/erc20paymentclientbase_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.