@etherisc/gif-next 0.0.2-b38343e-249 → 0.0.2-b44ae3c-205

package/contracts/shared/IService.sol

@@ -1,16 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {VersionPart} from "../types/Version.sol";
-import {ObjectType} from "../types/ObjectType.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
 import {IRegisterable} from "./IRegisterable.sol";
 import {IVersionable} from "./IVersionable.sol";
+import {ObjectType} from "../types/ObjectType.sol";
 
 interface IService is 
     IRegisterable,
-    IVersionable
+    IVersionable,
+    IAccessManaged
 {
+    error ErrorServiceNotImplemented();
+
     function getDomain() external pure returns(ObjectType serviceDomain);
-    function getMajorVersion() external view returns(VersionPart majorVersion);
 }

package/contracts/shared/NftOwnable.sol

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-// import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
-
 import {ERC165} from "./ERC165.sol";
 import {INftOwnable} from "./INftOwnable.sol";
 import {NftId} from "../types/NftId.sol";

package/contracts/shared/PolicyHolder.sol

@@ -5,11 +5,12 @@ import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
+import {Amount} from "../types/Amount.sol";
+import {ClaimId, ClaimIdLib} from "../types/ClaimId.sol";
 import {ERC165} from "./ERC165.sol";
 import {IPolicyHolder} from "./IPolicyHolder.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
 import {NftId} from "../types/NftId.sol";
-import {NumberId} from "../types/NumberId.sol";
+import {PayoutId} from "../types/PayoutId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
 
 /// @dev template implementation for IPolicyHolder
@@ -22,33 +23,43 @@ contract PolicyHolder is
     // TODO fix address
     bytes32 public constant POLICY_HOLDER_STORAGE_LOCATION_V1 = 0x07ebcf49758b6ed3af50fa146bec0abe157c0218fe65dc0874c286e9d5da4f00;
 
-    // TODO uncomment/fix/refactor
     struct PolicyHolderStorage {
-        // mapping(NftId policyId => mapping(NumberId claimId => address beneficiary)) private _claimBeneficiary;
-        // mapping(NftId policyId => address beneficiary) private _beneficiary;
-        bool dummy;
+        mapping(NftId policyId => mapping(ClaimId claimId => address beneficiary)) _beneficiary;
     }
 
     function initializePolicyHolder(
-        address registryAddress
+        address registryAddress,
+        address beneficiaryDefault
     )
         public
         virtual
         onlyInitializing()
     {
         initializeRegistryLinked(registryAddress);
+        registerInterface(type(IPolicyHolder).interfaceId);
     }
 
     /// @dev empty default implementation
-    function policyCreatedCallback(NftId policyNftId) external virtual { }
+    function policyActivated(NftId policyNftId) external {}
 
     /// @dev empty default implementation
-    function payoutExecutedCallback(NftId policyNftId, NumberId payoutId, address beneficiary, uint256 amount) external virtual { }
+    function policyExpired(NftId policyNftId) external {}
 
-    /// @dev determines beneficiary address that will be used in payouts targeting this contract
-    /// returned address will override GIF default where the policy nft holder is treated as beneficiary
-    function getBeneficiary(NftId policyId, NumberId claimId) external virtual view returns (address beneficiary) { 
-        // TODO add implementation
+    /// @dev empty default implementation
+    function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external {}
+
+    /// @dev empty default implementation
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, address beneficiary, Amount amount) external {}
+
+    /// @dev returns claim specific beneficiary
+    /// when no such beneficiary is defined the policy specific beneficiary is returned
+    function getBeneficiary(NftId policyNftId, ClaimId claimId) external virtual view returns (address beneficiary) {
+        beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][claimId];
+
+        // fallback to claim independent beneficiary
+        if(beneficiary == address(0) && claimId.gtz()) {
+            beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][ClaimIdLib.zero()];
+        }
     }
 
     //--- IERC165 functions ---------------// 
@@ -65,12 +76,14 @@ contract PolicyHolder is
         return IERC721Receiver.onERC721Received.selector;
     }
 
-    function _setBeneficiary(address beneficiary) internal {
-
+    /// @dev sets policy specific beneficiary (used when no claim specific beneficiary is defined)
+    function _setBeneficiary(NftId policyNftId, address beneficiary) internal {
+        _setBeneficiary(policyNftId, ClaimIdLib.zero(), beneficiary);
     }
 
-    function _setBeneficiary(NftId policyId, address beneficiary) internal {
-
+    /// @dev sets policy and claim specific beneficiary
+    function _setBeneficiary(NftId policyNftId, ClaimId claimId, address beneficiary) internal {
+        _getPolicyHolderStorage()._beneficiary[policyNftId][claimId] = beneficiary;
     }
 
     function _getPolicyHolderStorage() private pure returns (PolicyHolderStorage storage $) {

package/contracts/shared/Registerable.sol

@@ -9,7 +9,6 @@ import {ObjectType} from "../types/ObjectType.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegisterable} from "./IRegisterable.sol";
-import {Versionable} from "./Versionable.sol";
 
 contract Registerable is
     NftOwnable,
@@ -25,19 +24,13 @@ contract Registerable is
         bytes _data;
     }
 
-    function _getRegisterableStorage() private pure returns (RegisterableStorage storage $) {
-        assembly {
-            $.slot := REGISTERABLE_LOCATION_V1
-        }
-    }
-
     function initializeRegisterable(
         address registryAddress,
         NftId parentNftId,
         ObjectType objectType,
         bool isInterceptor,
         address initialOwner,
-        bytes memory data
+        bytes memory registryData // writeonly data that will saved in the object info record of the registry
     )
         public
         virtual
@@ -47,11 +40,15 @@ contract Registerable is
             initialOwner,
             registryAddress);
 
-        RegisterableStorage storage $ = _getRegisterableStorage();
+        RegisterableStorage storage $;
+        assembly {
+            $.slot := REGISTERABLE_LOCATION_V1
+        }
+
         $._parentNftId = parentNftId;
         $._objectType = objectType;
         $._isInterceptor = isInterceptor;
-        $._data = data;
+        $._data = registryData;
     }
 
 
@@ -61,7 +58,11 @@ contract Registerable is
         virtual 
         returns (IRegistry.ObjectInfo memory info) 
     {
-        RegisterableStorage memory $ = _getRegisterableStorage();
+        RegisterableStorage storage $;
+        assembly {
+            $.slot := REGISTERABLE_LOCATION_V1
+        }
+
         info = IRegistry.ObjectInfo(
             zeroNftId(),
             $._parentNftId,

package/contracts/shared/RegistryLinked.sol

@@ -40,9 +40,4 @@ contract RegistryLinked is
     function getRegistry() public view returns (IRegistry) {
         return _registry;
     }
-
-
-    function getRegistryAddress() public view returns (address) {
-        return address(_registry);
-    }
 }

package/contracts/shared/Service.sol

@@ -1,7 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {ObjectType, SERVICE} from "../types/ObjectType.sol";
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
+import {ObjectType, REGISTRY, SERVICE} from "../types/ObjectType.sol";
 import {NftId, zeroNftId} from "../types/NftId.sol";
 import {Version, VersionPart, VersionLib, VersionPartLib} from "../types/Version.sol";
 
@@ -18,14 +21,11 @@ import {IRegistry} from "../registry/IRegistry.sol";
 abstract contract Service is 
     Registerable,
     Versionable,
+    AccessManagedUpgradeable,
     IService
 {
-    function getDomain() public pure virtual override returns(ObjectType);
 
-    // version major version MUST be consistent with major version of getVersion()
-    function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
-        return VersionPartLib.toVersionPart(3); 
-    }
+    uint8 private constant GIF_MAJOR_VERSION = 3;
 
     // from Versionable
     function getVersion()
@@ -34,11 +34,12 @@ abstract contract Service is
         virtual override (IVersionable, Versionable)
         returns(Version)
     {
-        return VersionLib.toVersion(3,0,0);
+        return VersionLib.toVersion(GIF_MAJOR_VERSION,0,0);
     }
 
     function initializeService(
         address registry, 
+        address authority, // real authority for registry service adress(0) for other services
         address initialOwner
     )
         public
@@ -53,6 +54,19 @@ abstract contract Service is
             initialOwner, 
             ""); // data
 
+        // externally provided authority
+        if(authority != address(0)) {
+            __AccessManaged_init(authority);
+        } else {
+            address registryServiceAddress = getRegistry().getServiceAddress(
+                REGISTRY(), 
+                VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
+
+            // copy authority from already registered registry services
+            __AccessManaged_init(IAccessManaged(registryServiceAddress).authority());
+        }
+
+        registerInterface(type(IAccessManaged).interfaceId);
         registerInterface(type(IService).interfaceId);
     }
 }

package/contracts/shared/TokenHandler.sol

@@ -4,6 +4,10 @@ pragma solidity ^0.8.20;
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
+import {Amount} from "../types/Amount.sol";
+
+/// @dev token specific transfer helper
+/// relies internally on oz SafeERC20.safeTransferFrom
 contract TokenHandler {
     IERC20Metadata private _token;
 
@@ -11,17 +15,21 @@ contract TokenHandler {
         _token = IERC20Metadata(token);
     }
 
-    // TODO add logging
     function transfer(
         address from,
         address to,
-        uint256 amount // TODO add authz (only treasury/instance/product/pool/ service)
-    ) external {
-        SafeERC20.safeTransferFrom(_token, from, to, amount);
-        // _token.transferFrom(from, to, amount);
+        Amount amount
+    )
+        external
+    {
+        SafeERC20.safeTransferFrom(_token, from, to, amount.toInt());
     }
 
-    function getToken() external view returns (IERC20Metadata) {
+    function getToken()
+        external
+        view 
+        returns (IERC20Metadata)
+    {
         return _token;
     }
 }

package/contracts/test/TestService.sol

@@ -16,7 +16,7 @@ contract TestService is Service {
     constructor(address registry, NftId registryNftId, address initialOwner)
     // solhint-disable-next-line no-empty-blocks
     {
-        initializeService(registry, initialOwner);
+        initializeService(registry, address(0), initialOwner);
     }
 
     function getDomain() public pure override returns(ObjectType) {

package/contracts/types/Amount.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {UFixed, UFixedLib} from "./UFixed.sol";
+
+type Amount is uint96;
+
+using {
+    addAmount as +,
+    subAmount as -,
+    eqAmount as ==,
+    ltAmount as <,
+    gtAmount as >,
+    AmountLib.eq,
+    AmountLib.eqz,
+    AmountLib.gtz,
+    AmountLib.toInt,
+    AmountLib.add,
+    AmountLib.toUFixed
+} for Amount global;
+
+function addAmount(Amount a, Amount b) pure returns (Amount) {
+    return AmountLib.add(a, b);
+}
+
+function subAmount(Amount a, Amount b) pure returns (Amount) {
+    return AmountLib.sub(a, b);
+}
+
+function eqAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.eq(a, b);
+}
+
+function ltAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.lt(a, b);
+}
+
+function gtAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.gt(a, b);
+}
+
+library AmountLib {
+
+    error ErrorAmountLibValueTooBig(uint256 amount);
+
+    function zero() public pure returns (Amount) {
+        return Amount.wrap(0);
+    }
+
+    function max() public pure returns (Amount) {
+        return Amount.wrap(_max());
+    }
+
+    /// @dev converts the uint amount into Amount
+    /// function reverts if value is exceeding max Amount value
+    function toAmount(uint256 amount) public pure returns (Amount) {
+        if(amount > _max()) {
+            revert ErrorAmountLibValueTooBig(amount);
+        }
+
+        return Amount.wrap(uint96(amount));
+    }
+
+    /// @dev return true if amount equals 0
+    function eqz(Amount amount) public pure returns (bool) {
+        return Amount.unwrap(amount) == 0;
+    }
+
+    /// @dev return true if amount1 equals amount2
+    function eq(Amount amount1, Amount amount2) public pure returns (bool) {
+        return Amount.unwrap(amount1) == Amount.unwrap(amount2);
+    }
+
+    /// @dev return true if amount a1 is smaller than a2
+    function lt(Amount a1, Amount a2) public pure returns (bool) {
+        return Amount.unwrap(a1) < Amount.unwrap(a2);
+    }
+
+    /// @dev return true if amount a1 is larger than a2
+    function gt(Amount a1, Amount a2) public pure returns (bool) {
+        return Amount.unwrap(a1) > Amount.unwrap(a2);
+    }
+
+    /// @dev return true if amount is larger than 0
+    function gtz(Amount amount) public pure returns (bool) {
+        return Amount.unwrap(amount) > 0;
+    }
+
+    function add(Amount a1, Amount a2) public pure returns (Amount) {
+        return Amount.wrap(Amount.unwrap(a1) + Amount.unwrap(a2));
+    }
+
+    function sub(Amount a1, Amount a2) public pure returns (Amount) {
+        return Amount.wrap(Amount.unwrap(a1) - Amount.unwrap(a2));
+    }
+
+    function toInt(Amount amount) public pure returns (uint256) {
+        return uint256(uint96(Amount.unwrap(amount)));
+    }
+
+    function toUFixed(Amount amount) public pure returns (UFixed) {
+        return UFixedLib.toUFixed(Amount.unwrap(amount));
+    }
+
+    function _max() internal pure returns (uint96) {
+        // IMPORTANT: type nees to match with actual definition for Amount
+        return type(uint96).max;
+    }
+}

package/contracts/types/Blocknumber.sol

@@ -52,6 +52,7 @@ function blockBlocknumber() view returns (Blocknumber) {
     return toBlocknumber(block.number);
 }
 
+// TODO move to BlocknumberLib and rename to zero()
 /// @dev Return the Blocknumber zero (0)
 function zeroBlocknumber() pure returns (Blocknumber) {
     return toBlocknumber(0);

package/contracts/types/ClaimId.sol

@@ -4,13 +4,18 @@ pragma solidity ^0.8.20;
 // uint16 allows for 65'535 claims per policy
 type ClaimId is uint16;
 
+import {CLAIM} from "./ObjectType.sol";
+import {Key32, KeyId, Key32Lib} from "./Key32.sol";
+import {NftId} from "./NftId.sol";
+
 // type bindings
 using {
     eqClaimId as ==, 
     neClaimId as !=, 
     ClaimIdLib.eqz,
     ClaimIdLib.gtz,
-    ClaimIdLib.toInt
+    ClaimIdLib.toInt,
+    ClaimIdLib.toKey32
 } for ClaimId global;
 
 
@@ -25,10 +30,14 @@ function neClaimId(ClaimId a, ClaimId b) pure returns (bool isDifferent) {
 
 // library functions that operate on user defined type
 library ClaimIdLib {
-    /// @dev Converts the ClaimId to a uint.
+    /// @dev claim id min value (0), use only for non-initialized values
     function zero() public pure returns (ClaimId) {
         return ClaimId.wrap(0);
     }
+    /// @dev claim id max value (2**16-1), use only for non-initialized values
+    function max() public pure returns (ClaimId) {
+        return ClaimId.wrap(type(uint16).max);
+    }
 
     /// @dev Converts an uint into a ClaimId.
     function toClaimId(uint256 a) public pure returns (ClaimId) {
@@ -40,6 +49,20 @@ library ClaimIdLib {
         return uint16(ClaimId.unwrap(a));
     }
 
+    /// @dev Converts the ClaimId and NftId to a Key32.
+    function toKey32(ClaimId claimId, NftId policyNftId) public pure returns (Key32) {
+        return Key32Lib.toKey32(CLAIM(), toKeyId(claimId, policyNftId));
+    }
+
+    /// @dev Converts the ClaimId and NftId to a Key32.
+    function toKeyId(ClaimId claimId, NftId policyNftId) public pure returns (KeyId) {
+        return KeyId.wrap(
+            bytes31(
+                bytes14(
+                    uint112(
+                        NftId.unwrap(policyNftId) << 16 + ClaimId.unwrap(claimId)))));
+    }
+
     /// @dev Returns true if the value is non-zero (> 0).
     function gtz(ClaimId a) public pure returns (bool) {
         return ClaimId.unwrap(a) > 0;

package/contracts/types/Fee.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
+import {Amount, AmountLib} from "./Amount.sol";
 import {UFixed, UFixedLib} from "./UFixed.sol";
 
 struct Fee {
@@ -12,19 +13,22 @@ library FeeLib {
 
     function calculateFee(
         Fee memory fee,
-        uint256 amount
+        Amount amount
     )
         public
         pure
         returns (
-            uint256 feeAmount, 
-            uint256 netAmount
+            Amount feeAmount, 
+            Amount netAmount
         )
     {
-        UFixed fractionalAmount = UFixedLib.toUFixed(amount) *
-            fee.fractionalFee;
-        feeAmount = fractionalAmount.toInt() + fee.fixedFee;
-        netAmount = amount - feeAmount;
+        netAmount = amount;
+        if(gtz(fee)) {
+            UFixed fractionalAmount = 
+                amount.toUFixed() * fee.fractionalFee;
+            feeAmount = AmountLib.toAmount(fractionalAmount.toInt() + fee.fixedFee);
+            netAmount = netAmount - feeAmount;
+        }
     }
 
     /// @dev Converts the uint256 to a fee struct.
@@ -40,6 +44,7 @@ library FeeLib {
         return Fee(UFixedLib.toUFixed(percent, -2), 0);
     }
 
+    // TODO rename to zero
     /// @dev Return a zero fee struct (0, 0)
     function zeroFee() public pure returns (Fee memory fee) {
         return Fee(UFixed.wrap(0), 0);
@@ -50,7 +55,11 @@ library FeeLib {
         return a.fixedFee == b.fixedFee && a.fractionalFee == b.fractionalFee;
     }
 
-    function feeIsZero(Fee memory fee) public pure returns (bool) {
+    function gtz(Fee memory fee) public pure returns (bool) {
+        return UFixed.unwrap(fee.fractionalFee) > 0 || fee.fixedFee > 0;
+    }
+
+    function eqz(Fee memory fee) public pure returns (bool) {
         return fee.fixedFee == 0 && UFixed.unwrap(fee.fractionalFee) == 0;
     }
 }

package/contracts/types/NftId.sol

@@ -24,6 +24,7 @@ function toNftId(uint256 id) pure returns (NftId) {
     return NftId.wrap(uint96(id));
 }
 
+// TODO move to NftIdLib and rename to zero()
 /// @dev Return the NftId zero (0)
 function zeroNftId() pure returns (NftId) {
     return NftId.wrap(0);
@@ -40,6 +41,13 @@ function neNftId(NftId a, NftId b) pure returns (bool isDifferent) {
 
 // library functions that operate on user defined type
 library NftIdLib {
+
+    /// @dev the zero nft id
+    /// is never a valid nft id and implies a non-initialized value
+    function zero() public pure returns (NftId) {
+        return NftId.wrap(0);
+    }
+
     /// @dev Converts the NftId to a uint256.
     function toInt(NftId nftId) public pure returns (uint96) {
         return uint96(NftId.unwrap(nftId));

package/contracts/types/ObjectType.sol

@@ -86,6 +86,10 @@ function POOL() pure returns (ObjectType) {
     return toObjectType(140);
 }
 
+function BUNDLE() pure returns (ObjectType) {
+    return toObjectType(220);
+}
+
 function RISK() pure returns (ObjectType) {
     return toObjectType(200);
 }
@@ -102,12 +106,12 @@ function CLAIM() pure returns (ObjectType) {
     return toObjectType(212);
 }
 
-function BUNDLE() pure returns (ObjectType) {
-    return toObjectType(220);
+function PAYOUT() pure returns (ObjectType) {
+    return toObjectType(213); 
 }
 
-function PAYOUT() pure returns (ObjectType) {
-    return toObjectType(212);
+function PRICE() pure returns (ObjectType) {
+    return toObjectType(230);
 }
 
 /// @dev Converts the uint8 to a ObjectType.
@@ -115,6 +119,7 @@ function toObjectType(uint256 objectType) pure returns (ObjectType) {
     return ObjectType.wrap(uint8(objectType));
 }
 
+// TODO move to ObjecTypeLib and rename to zero()
 /// @dev Return the ObjectType zero (0)
 function zeroObjectType() pure returns (ObjectType) {
     return ObjectType.wrap(0);
@@ -153,4 +158,4 @@ library ObjectTypeLib {
     function eq(ObjectType a, ObjectType b) public pure returns (bool isSame) {
         return eqObjectType(a, b);
     }
-}
+}

package/contracts/types/PayoutId.sol

@@ -4,13 +4,21 @@ pragma solidity ^0.8.20;
 // uint24 allows for 65'535 claims with 255 payouts each per policy
 type PayoutId is uint24;
 
+import {ClaimId} from "./ClaimId.sol";
+import {PAYOUT} from "./ObjectType.sol";
+import {Key32, KeyId, Key32Lib} from "./Key32.sol";
+import {NftId} from "./NftId.sol";
+
 // type bindings
 using {
     eqPayoutId as ==, 
     nePayoutId as !=, 
     PayoutIdLib.eqz,
     PayoutIdLib.gtz,
-    PayoutIdLib.toInt
+    PayoutIdLib.toInt,
+    PayoutIdLib.toClaimId,
+    PayoutIdLib.toPayoutNo,
+    PayoutIdLib.toKey32
 } for PayoutId global;
 
 
@@ -23,8 +31,6 @@ function nePayoutId(PayoutId a, PayoutId b) pure returns (bool isDifferent) {
     return PayoutId.unwrap(a) != PayoutId.unwrap(b);
 }
 
-// TODO come up with a way to code claim id into payout id
-// eg payoutId.getClaimId(), payoutId.getPayoutNo()
 // library functions that operate on user defined type
 library PayoutIdLib {
     /// @dev Converts the PayoutId to a uint.
@@ -33,8 +39,16 @@ library PayoutIdLib {
     }
 
     /// @dev Converts an uint into a PayoutId.
-    function toPayoutId(uint256 a) public pure returns (PayoutId) {
-        return PayoutId.wrap(uint24(a));
+    function toPayoutId(ClaimId claimId, uint8 payoutNo) public pure returns (PayoutId) {
+        return PayoutId.wrap((ClaimId.unwrap(claimId) << 8) + payoutNo);
+    }
+
+    function toClaimId(PayoutId payoutId) public pure returns (ClaimId) {
+        return ClaimId.wrap(uint16(PayoutId.unwrap(payoutId) >> 8));
+    }
+
+    function toPayoutNo(PayoutId payoutId) public pure returns (uint8) {
+        return uint8(PayoutId.unwrap(payoutId) & 255);
     }
 
     /// @dev Converts the PayoutId to a uint.
@@ -51,4 +65,18 @@ library PayoutIdLib {
     function eqz(PayoutId a) public pure returns (bool) {
         return PayoutId.unwrap(a) == 0;
     }
+
+    /// @dev Converts the PayoutId and NftId to a Key32.
+    function toKey32(PayoutId payoutId, NftId policyNftId) public pure returns (Key32) {
+        return Key32Lib.toKey32(PAYOUT(), toKeyId(payoutId, policyNftId));
+    }
+
+    /// @dev Converts the PayoutId and NftId to a Key32.
+    function toKeyId(PayoutId payoutId, NftId policyNftId) public pure returns (KeyId) {
+        return KeyId.wrap(
+            bytes31(
+                bytes15(
+                    uint120(
+                        (NftId.unwrap(policyNftId) << 24) + PayoutId.unwrap(payoutId)))));
+    }
 }