Skip to content

Commit 19f0041

Browse files
sebsadfacesebsadface
committed
test(register-derivatives): add tests for commercial license parent derivatives
1 parent 5fdbc74 commit 19f0041

File tree

4 files changed

+204
-106
lines changed

4 files changed

+204
-106
lines changed

‎script/Main.s.sol

+2
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,8 @@ contract Main is Script, StoryProtocolCoreAddressManager, BroadcastManager, Json
5757
accessControllerAddr,
5858
ipAssetRegistryAddr,
5959
licensingModuleAddr,
60+
licenseRegistryAddr,
61+
royaltyModuleAddr,
6062
coreMetadataModuleAddr,
6163
pilTemplateAddr,
6264
licenseTokenAddr

‎script/utils/StoryProtocolCoreAddressManager.sol

+4
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,8 @@ contract StoryProtocolCoreAddressManager is Script {
1010
address internal protocolAccessManagerAddr;
1111
address internal ipAssetRegistryAddr;
1212
address internal licensingModuleAddr;
13+
address internal licenseRegistryAddr;
14+
address internal royaltyModuleAddr;
1315
address internal coreMetadataModuleAddr;
1416
address internal accessControllerAddr;
1517
address internal pilTemplateAddr;
@@ -31,6 +33,8 @@ contract StoryProtocolCoreAddressManager is Script {
3133
protocolAccessManagerAddr = json.readAddress(".main.ProtocolAccessManager");
3234
ipAssetRegistryAddr = json.readAddress(".main.IPAssetRegistry");
3335
licensingModuleAddr = json.readAddress(".main.LicensingModule");
36+
licenseRegistryAddr = json.readAddress(".main.LicenseRegistry");
37+
royaltyModuleAddr = json.readAddress(".main.RoyaltyModule");
3438
coreMetadataModuleAddr = json.readAddress(".main.CoreMetadataModule");
3539
accessControllerAddr = json.readAddress(".main.AccessController");
3640
pilTemplateAddr = json.readAddress(".main.PILicenseTemplate");

‎test/StoryProtocolGateway.t.sol

+149-105
Original file line numberDiff line numberDiff line change
@@ -205,8 +205,9 @@ contract StoryProtocolGatewayTest is BaseTest {
205205

206206
modifier withEnoughTokens() {
207207
require(caller != address(0), "withEnoughTokens: caller not set");
208-
mockToken.mint(address(caller), 1000 * 10 ** mockToken.decimals());
208+
mockToken.mint(address(caller), 2000 * 10 ** mockToken.decimals());
209209
mockToken.approve(address(nftContract), 1000 * 10 ** mockToken.decimals());
210+
mockToken.approve(address(spg), 1000 * 10 ** mockToken.decimals());
210211
_;
211212
}
212213

@@ -280,7 +281,7 @@ contract StoryProtocolGatewayTest is BaseTest {
280281
});
281282
}
282283

283-
modifier withParentIp() {
284+
modifier withNonCommercialParentIp() {
284285
(ipIdParent, , ) = spg.mintAndRegisterIpAndAttachPILTerms({
285286
nftContract: address(nftContract),
286287
recipient: caller,
@@ -291,134 +292,67 @@ contract StoryProtocolGatewayTest is BaseTest {
291292
_;
292293
}
293294

294-
function test_SPG_mintAndRegisterIpAndMakeDerivative()
295+
function test_SPG_mintAndRegisterIpAndMakeDerivativeWithNonCommercialLicense()
295296
public
296297
withCollection
297298
whenCallerHasMinterRole
298299
withEnoughTokens
299-
withParentIp
300+
withNonCommercialParentIp
300301
{
301-
(address licenseTemplateParent, uint256 licenseTermsIdParent) = licenseRegistry.getAttachedLicenseTerms(
302-
ipIdParent,
303-
0
304-
);
305-
306-
address[] memory parentIpIds = new address[](1);
307-
parentIpIds[0] = ipIdParent;
302+
_mintAndRegisterIpAndMakeDerivativeBaseTest();
303+
}
308304

309-
uint256[] memory licenseTermsIds = new uint256[](1);
310-
licenseTermsIds[0] = licenseTermsIdParent;
305+
function test_SPG_registerIpAndMakeDerivativeWithNonCommercialLicense()
306+
public
307+
withCollection
308+
whenCallerHasMinterRole
309+
withEnoughTokens
310+
withNonCommercialParentIp
311+
{
312+
_registerIpAndMakeDerivativeBaseTest();
313+
}
311314

312-
(address ipIdChild, uint256 tokenIdChild) = spg.mintAndRegisterIpAndMakeDerivative({
315+
modifier withCommercialParentIp() {
316+
(ipIdParent, , ) = spg.mintAndRegisterIpAndAttachPILTerms({
313317
nftContract: address(nftContract),
314-
derivData: ISPG.MakeDerivative({
315-
parentIpIds: parentIpIds,
316-
licenseTemplate: address(pilTemplate),
317-
licenseTermsIds: licenseTermsIds,
318-
royaltyContext: ""
319-
}),
318+
recipient: caller,
320319
nftMetadata: nftMetadataDefault,
321320
ipMetadata: ipMetadataDefault,
322-
recipient: caller
323-
});
324-
assertTrue(ipAssetRegistry.isRegistered(ipIdChild));
325-
assertEq(tokenIdChild, 2);
326-
assertMetadata(ipIdChild, ipMetadataDefault);
327-
assertMetadata(ipIdChild, ipMetadataDefault);
328-
(address licenseTemplateChild, uint256 licenseTermsIdChild) = licenseRegistry.getAttachedLicenseTerms(
329-
ipIdChild,
330-
0
331-
);
332-
assertEq(licenseTemplateChild, licenseTemplateParent);
333-
assertEq(licenseTermsIdChild, licenseTermsIdParent);
334-
assertEq(IIPAccount(payable(ipIdChild)).owner(), caller);
335-
336-
assertParentChild({
337-
ipIdParent: ipIdParent,
338-
ipIdChild: ipIdChild,
339-
expectedParentCount: 1,
340-
expectedParentIndex: 0
321+
terms: PILFlavors.commercialUse({
322+
mintingFee: 100 * 10 ** mockToken.decimals(),
323+
currencyToken: address(mockToken),
324+
royaltyPolicy: address(royaltyPolicyLAP)
325+
})
341326
});
327+
_;
342328
}
343329

344-
function test_SPG_registerIpAndMakeDerivative()
330+
function test_SPG_mintAndRegisterIpAndMakeDerivativeWithCommercialLicense()
345331
public
346332
withCollection
347333
whenCallerHasMinterRole
348334
withEnoughTokens
349-
withParentIp
335+
withCommercialParentIp
350336
{
351-
(address licenseTemplateParent, uint256 licenseTermsIdParent) = licenseRegistry.getAttachedLicenseTerms(
352-
ipIdParent,
353-
0
354-
);
355-
356-
uint256 tokenIdChild = nftContract.mint(address(caller), nftMetadataEmpty);
357-
address ipIdChild = ipAssetRegistry.ipId(block.chainid, address(nftContract), tokenIdChild);
358-
359-
uint256 deadline = block.timestamp + 1000;
360-
361-
(bytes memory sigMetadata, ) = _getSetPermissionSignatureForSPG({
362-
ipId: ipIdChild,
363-
module: address(coreMetadataModule),
364-
selector: ICoreMetadataModule.setAll.selector,
365-
deadline: deadline,
366-
nonce: 1,
367-
signerPk: alicePk
368-
});
369-
(bytes memory sigRegister, ) = _getSetPermissionSignatureForSPG({
370-
ipId: ipIdChild,
371-
module: address(licensingModule),
372-
selector: ILicensingModule.registerDerivative.selector,
373-
deadline: deadline,
374-
nonce: 2,
375-
signerPk: alicePk
376-
});
377-
378-
address[] memory parentIpIds = new address[](1);
379-
parentIpIds[0] = ipIdParent;
380-
381-
uint256[] memory licenseTermsIds = new uint256[](1);
382-
licenseTermsIds[0] = licenseTermsIdParent;
383-
384-
address ipIdChildActual = spg.registerIpAndMakeDerivative({
385-
nftContract: address(nftContract),
386-
tokenId: tokenIdChild,
387-
derivData: ISPG.MakeDerivative({
388-
parentIpIds: parentIpIds,
389-
licenseTemplate: address(pilTemplate),
390-
licenseTermsIds: licenseTermsIds,
391-
royaltyContext: ""
392-
}),
393-
ipMetadata: ipMetadataDefault,
394-
sigMetadata: ISPG.SignatureData({ signer: alice, deadline: deadline, signature: sigMetadata }),
395-
sigRegister: ISPG.SignatureData({ signer: alice, deadline: deadline, signature: sigRegister })
396-
});
397-
assertEq(ipIdChildActual, ipIdChild);
398-
assertTrue(ipAssetRegistry.isRegistered(ipIdChild));
399-
assertMetadata(ipIdChild, ipMetadataDefault);
400-
(address licenseTemplateChild, uint256 licenseTermsIdChild) = licenseRegistry.getAttachedLicenseTerms(
401-
ipIdChild,
402-
0
403-
);
404-
assertEq(licenseTemplateChild, licenseTemplateParent);
405-
assertEq(licenseTermsIdChild, licenseTermsIdParent);
406-
assertEq(IIPAccount(payable(ipIdChild)).owner(), caller);
337+
_mintAndRegisterIpAndMakeDerivativeBaseTest();
338+
}
407339

408-
assertParentChild({
409-
ipIdParent: ipIdParent,
410-
ipIdChild: ipIdChild,
411-
expectedParentCount: 1,
412-
expectedParentIndex: 0
413-
});
340+
function test_SPG_registerIpAndMakeDerivativeWithCommercialLicense()
341+
public
342+
withCollection
343+
whenCallerHasMinterRole
344+
withEnoughTokens
345+
withCommercialParentIp
346+
{
347+
_registerIpAndMakeDerivativeBaseTest();
414348
}
415349

416350
function test_SPG_mintAndRegisterIpAndMakeDerivativeWithLicenseTokens()
417351
public
418352
withCollection
419353
whenCallerHasMinterRole
420354
withEnoughTokens
421-
withParentIp
355+
withNonCommercialParentIp
422356
{
423357
(address licenseTemplateParent, uint256 licenseTermsIdParent) = licenseRegistry.getAttachedLicenseTerms(
424358
ipIdParent,
@@ -473,7 +407,7 @@ contract StoryProtocolGatewayTest is BaseTest {
473407
withCollection
474408
whenCallerHasMinterRole
475409
withEnoughTokens
476-
withParentIp
410+
withNonCommercialParentIp
477411
{
478412
caller = alice;
479413
vm.startPrank(caller);
@@ -611,4 +545,114 @@ contract StoryProtocolGatewayTest is BaseTest {
611545
(uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPk, digest);
612546
signature = abi.encodePacked(r, s, v);
613547
}
548+
549+
function _mintAndRegisterIpAndMakeDerivativeBaseTest() internal {
550+
(address licenseTemplateParent, uint256 licenseTermsIdParent) = licenseRegistry.getAttachedLicenseTerms(
551+
ipIdParent,
552+
0
553+
);
554+
555+
address[] memory parentIpIds = new address[](1);
556+
parentIpIds[0] = ipIdParent;
557+
558+
uint256[] memory licenseTermsIds = new uint256[](1);
559+
licenseTermsIds[0] = licenseTermsIdParent;
560+
561+
(address ipIdChild, uint256 tokenIdChild) = spg.mintAndRegisterIpAndMakeDerivative({
562+
nftContract: address(nftContract),
563+
derivData: ISPG.MakeDerivative({
564+
parentIpIds: parentIpIds,
565+
licenseTemplate: address(pilTemplate),
566+
licenseTermsIds: licenseTermsIds,
567+
royaltyContext: ""
568+
}),
569+
nftMetadata: nftMetadataDefault,
570+
ipMetadata: ipMetadataDefault,
571+
recipient: caller
572+
});
573+
assertTrue(ipAssetRegistry.isRegistered(ipIdChild));
574+
assertEq(tokenIdChild, 2);
575+
assertMetadata(ipIdChild, ipMetadataDefault);
576+
assertMetadata(ipIdChild, ipMetadataDefault);
577+
(address licenseTemplateChild, uint256 licenseTermsIdChild) = licenseRegistry.getAttachedLicenseTerms(
578+
ipIdChild,
579+
0
580+
);
581+
assertEq(licenseTemplateChild, licenseTemplateParent);
582+
assertEq(licenseTermsIdChild, licenseTermsIdParent);
583+
assertEq(IIPAccount(payable(ipIdChild)).owner(), caller);
584+
585+
assertParentChild({
586+
ipIdParent: ipIdParent,
587+
ipIdChild: ipIdChild,
588+
expectedParentCount: 1,
589+
expectedParentIndex: 0
590+
});
591+
}
592+
593+
function _registerIpAndMakeDerivativeBaseTest() internal {
594+
(address licenseTemplateParent, uint256 licenseTermsIdParent) = licenseRegistry.getAttachedLicenseTerms(
595+
ipIdParent,
596+
0
597+
);
598+
599+
uint256 tokenIdChild = nftContract.mint(address(caller), nftMetadataEmpty);
600+
address ipIdChild = ipAssetRegistry.ipId(block.chainid, address(nftContract), tokenIdChild);
601+
602+
uint256 deadline = block.timestamp + 1000;
603+
604+
(bytes memory sigMetadata, ) = _getSetPermissionSignatureForSPG({
605+
ipId: ipIdChild,
606+
module: address(coreMetadataModule),
607+
selector: ICoreMetadataModule.setAll.selector,
608+
deadline: deadline,
609+
nonce: 1,
610+
signerPk: alicePk
611+
});
612+
(bytes memory sigRegister, ) = _getSetPermissionSignatureForSPG({
613+
ipId: ipIdChild,
614+
module: address(licensingModule),
615+
selector: ILicensingModule.registerDerivative.selector,
616+
deadline: deadline,
617+
nonce: 2,
618+
signerPk: alicePk
619+
});
620+
621+
address[] memory parentIpIds = new address[](1);
622+
parentIpIds[0] = ipIdParent;
623+
624+
uint256[] memory licenseTermsIds = new uint256[](1);
625+
licenseTermsIds[0] = licenseTermsIdParent;
626+
627+
address ipIdChildActual = spg.registerIpAndMakeDerivative({
628+
nftContract: address(nftContract),
629+
tokenId: tokenIdChild,
630+
derivData: ISPG.MakeDerivative({
631+
parentIpIds: parentIpIds,
632+
licenseTemplate: address(pilTemplate),
633+
licenseTermsIds: licenseTermsIds,
634+
royaltyContext: ""
635+
}),
636+
ipMetadata: ipMetadataDefault,
637+
sigMetadata: ISPG.SignatureData({ signer: alice, deadline: deadline, signature: sigMetadata }),
638+
sigRegister: ISPG.SignatureData({ signer: alice, deadline: deadline, signature: sigRegister })
639+
});
640+
assertEq(ipIdChildActual, ipIdChild);
641+
assertTrue(ipAssetRegistry.isRegistered(ipIdChild));
642+
assertMetadata(ipIdChild, ipMetadataDefault);
643+
(address licenseTemplateChild, uint256 licenseTermsIdChild) = licenseRegistry.getAttachedLicenseTerms(
644+
ipIdChild,
645+
0
646+
);
647+
assertEq(licenseTemplateChild, licenseTemplateParent);
648+
assertEq(licenseTermsIdChild, licenseTermsIdParent);
649+
assertEq(IIPAccount(payable(ipIdChild)).owner(), caller);
650+
651+
assertParentChild({
652+
ipIdParent: ipIdParent,
653+
ipIdChild: ipIdChild,
654+
expectedParentCount: 1,
655+
expectedParentIndex: 0
656+
});
657+
}
614658
}

0 commit comments

Comments
 (0)