> ## Documentation Index
> Fetch the complete documentation index at: https://docs.story.foundation/llms.txt
> Use this file to discover all available pages before exploring further.

# RoyaltyPolicyLAP

The RoyaltyPolicyLAP (Liquid Absolute Percentage) contract defines the logic for splitting royalties for a given IP asset using a liquid absolute percentage mechanism. It manages the royalty relationships between IP assets and their ancestors, allowing for the transfer of revenue tokens to the appropriate royalty vaults.

## State Variables

### RoyaltyPolicyLAPStorage

```solidity theme={null}
struct RoyaltyPolicyLAPStorage {
    mapping(address ipId => uint32) royaltyStackLAP;
    mapping(address ipId => mapping(address ancestorIpId => uint32)) ancestorPercentLAP;
    mapping(address ipId => mapping(address ancestorIpId => mapping(address token => uint256))) transferredTokenLAP;
}
```

Storage structure for the RoyaltyPolicyLAP containing:

* `royaltyStackLAP`: Sum of the royalty percentages to be paid to all ancestors for LAP royalty policy
* `ancestorPercentLAP`: The royalty percentage between an IP asset and a given ancestor for LAP royalty policy
* `transferredTokenLAP`: Total lifetime revenue tokens transferred to a vault from a descendant IP via LAP

### IP\_GRAPH

```solidity theme={null}
address public constant IP_GRAPH = address(0x0101)
```

The address of the IP Graph precompile contract that tracks relationships between IPs.

### ROYALTY\_MODULE

```solidity theme={null}
IRoyaltyModule public immutable ROYALTY_MODULE
```

The address of the Royalty Module contract.

### IP\_GRAPH\_ACL

```solidity theme={null}
IPGraphACL public immutable IP_GRAPH_ACL
```

The address of the IP Graph Access Control List contract.

## Functions

### constructor

```solidity theme={null}
constructor(address royaltyModule, address ipGraphAcl)
```

Constructor for the RoyaltyPolicyLAP contract.

**Parameters:**

* `royaltyModule`: The RoyaltyModule address
* `ipGraphAcl`: The IPGraphACL address

### initialize

```solidity theme={null}
function initialize(address accessManager) external initializer
```

Initializer for this implementation contract.

**Parameters:**

* `accessManager`: The address of the protocol admin roles contract.

### onLicenseMinting

```solidity theme={null}
function onLicenseMinting(
    address ipId,
    uint32 licensePercent,
    bytes calldata
) external nonReentrant onlyRoyaltyModule
```

Executes royalty related logic on minting a license.

**Parameters:**

* `ipId`: The ipId whose license is being minted (licensor)
* `licensePercent`: The license percentage of the license being minted

### onLinkToParents

```solidity theme={null}
function onLinkToParents(
    address ipId,
    address[] calldata parentIpIds,
    address[] memory licenseRoyaltyPolicies,
    uint32[] calldata licensesPercent,
    bytes calldata
) external nonReentrant onlyRoyaltyModule returns (uint32 newRoyaltyStackLAP)
```

Executes royalty related logic on linking to parents.

**Parameters:**

* `ipId`: The children ipId that is being linked to parents
* `parentIpIds`: The parent ipIds that the children ipId is being linked to
* `licenseRoyaltyPolicies`: The royalty policies of the licenses
* `licensesPercent`: The license percentage of the licenses being minted

**Returns:**

* `newRoyaltyStackLAP`: The royalty stack of the child ipId for LAP royalty policy

### transferToVault

```solidity theme={null}
function transferToVault(
    address ipId,
    address ancestorIpId,
    address token
) external whenNotPaused returns (uint256)
```

Transfers to vault an amount of revenue tokens claimable via LAP royalty policy.

**Parameters:**

* `ipId`: The ipId of the IP asset
* `ancestorIpId`: The ancestor ipId of the IP asset
* `token`: The token address to transfer

**Returns:**

* The amount of revenue tokens transferred

### getPolicyRtsRequiredToLink

```solidity theme={null}
function getPolicyRtsRequiredToLink(address ipId, uint32 licensePercent) external view returns (uint32)
```

Returns the amount of royalty tokens required to link a child to a given IP asset.

**Parameters:**

* `ipId`: The ipId of the IP asset
* `licensePercent`: The percentage of the license

**Returns:**

* The amount of royalty tokens required to link a child to a given IP asset (always 0 for LAP)

### getPolicyRoyaltyStack

```solidity theme={null}
function getPolicyRoyaltyStack(address ipId) external view returns (uint32)
```

Returns the LAP royalty stack for a given IP asset.

**Parameters:**

* `ipId`: The ipId to get the royalty stack for

**Returns:**

* Sum of the royalty percentages to be paid to all ancestors for LAP royalty policy

### getPolicyRoyalty

```solidity theme={null}
function getPolicyRoyalty(address ipId, address ancestorIpId) external returns (uint32)
```

Returns the royalty percentage between an IP asset and its ancestors via LAP.

**Parameters:**

* `ipId`: The ipId to get the royalty for
* `ancestorIpId`: The ancestor ipId to get the royalty for

**Returns:**

* The royalty percentage between an IP asset and its ancestors via LAP

### getTransferredTokens

```solidity theme={null}
function getTransferredTokens(address ipId, address ancestorIpId, address token) external view returns (uint256)
```

Returns the total lifetime revenue tokens transferred to a vault from a descendant IP via LAP.

**Parameters:**

* `ipId`: The ipId of the IP asset
* `ancestorIpId`: The ancestor ipId of the IP asset
* `token`: The token address to transfer

**Returns:**

* The total lifetime revenue tokens transferred to a vault from a descendant IP via LAP

### isSupportGroup

```solidity theme={null}
function isSupportGroup() external view returns (bool)
```

Returns whether the royalty policy supports working with groups.

**Returns:**

* False (LAP royalty policy does not support working with groups)

## Internal Functions

### \_getRoyaltyStackLAP

```solidity theme={null}
function _getRoyaltyStackLAP(address ipId) internal returns (uint32)
```

Returns the royalty stack for a given IP asset for LAP royalty policy.

**Parameters:**

* `ipId`: The ipId to get the royalty stack for

**Returns:**

* The royalty stack for a given IP asset for LAP royalty policy

### \_setRoyaltyLAP

```solidity theme={null}
function _setRoyaltyLAP(address ipId, address parentIpId, uint32 royalty) internal
```

Sets the LAP royalty for a given link between an IP asset and its ancestor.

**Parameters:**

* `ipId`: The ipId to set the royalty for
* `parentIpId`: The parent ipId to set the royalty for
* `royalty`: The LAP license royalty percentage

### \_getRoyaltyLAP

```solidity theme={null}
function _getRoyaltyLAP(address ipId, address ancestorIpId) internal returns (uint32)
```

Returns the royalty percentage between an IP asset and its ancestor via royalty policy LAP.

**Parameters:**

* `ipId`: The ipId to get the royalty for
* `ancestorIpId`: The ancestor ipId to get the royalty for

**Returns:**

* The royalty percentage between an IP asset and its ancestor via royalty policy LAP

### \_getRoyaltyPolicyLAPStorage

```solidity theme={null}
function _getRoyaltyPolicyLAPStorage() private pure returns (RoyaltyPolicyLAPStorage storage $)
```

Returns the storage struct of RoyaltyPolicyLAP.

**Returns:**

* The storage structure for the RoyaltyPolicyLAP

### \_authorizeUpgrade

```solidity theme={null}
function _authorizeUpgrade(address newImplementation) internal override restricted
```

Hook to authorize the upgrade according to UUPSUpgradeable.

**Parameters:**

* `newImplementation`: The address of the new implementation

## Events

### RevenueTransferredToVault

```solidity theme={null}
event RevenueTransferredToVault(address ipId, address ancestorIpId, address token, uint256 amount)
```

Emitted when revenue tokens are transferred to a vault.

**Parameters:**

* `ipId`: The ipId of the IP asset
* `ancestorIpId`: The ancestor ipId of the IP asset
* `token`: The token address transferred
* `amount`: The amount of tokens transferred

## Security Considerations

The RoyaltyPolicyLAP contract implements several security measures:

1. **Access Control**: Functions like `onLicenseMinting` and `onLinkToParents` can only be called by the Royalty Module through the `onlyRoyaltyModule` modifier.

2. **Reentrancy Protection**: The `nonReentrant` modifier is used on functions that handle token transfers to prevent reentrancy attacks.

3. **Pausability**: The contract can be paused in emergency situations using the `whenNotPaused` modifier.

4. **Safe Token Transfers**: The contract uses OpenZeppelin's SafeERC20 library to ensure safe token transfers.

5. **Upgradability**: The contract is upgradable using the UUPS pattern, with upgrade authorization restricted to the protocol admin.

6. **Input Validation**: The contract validates inputs and checks for edge cases, such as preventing transfers between the same IP.