Adding fix for locking/unlocking pNFT editions. (#116)

* Adding fix for locking/unlocking pNFT editions. * Fixing test name. * Formatting fixes.
metaplex-foundation · Apr 9, 2024 · 3a3884e · 3a3884e
1 parent 87af917
commit 3a3884e
Show file tree

Hide file tree

Showing 4 changed files with 186 additions and 5 deletions.
diff --git a/clients/js/src/digitalAsset.ts b/clients/js/src/digitalAsset.ts
@@ -235,4 +235,5 @@ export const isNonFungible = (tokenStandard: TokenStandard): boolean =>
  !isFungible(tokenStandard);
 
 export const isProgrammable = (tokenStandard: TokenStandard): boolean =>
- tokenStandard === TokenStandard.ProgrammableNonFungible;
+ tokenStandard === TokenStandard.ProgrammableNonFungible ||
+ tokenStandard === TokenStandard.ProgrammableNonFungibleEdition;
diff --git a/clients/js/test/lockV1.test.ts b/clients/js/test/lockV1.test.ts
@@ -1,5 +1,8 @@
-import { TokenState as SplTokenState } from '@metaplex-foundation/mpl-toolbox';
-import { generateSigner } from '@metaplex-foundation/umi';
+import {
+ setComputeUnitLimit,
+ TokenState as SplTokenState,
+} from '@metaplex-foundation/mpl-toolbox';
+import { generateSigner, percentAmount } from '@metaplex-foundation/umi';
 import test from 'ava';
 import {
  DigitalAssetWithToken,
@@ -9,6 +12,8 @@ import {
  delegateUtilityV1,
  fetchDigitalAssetWithAssociatedToken,
  lockV1,
+ printSupply,
+ printV2,
 } from '../src';
 import {
  FUNGIBLE_TOKEN_STANDARDS,
@@ -46,6 +51,83 @@ test('it can lock a ProgrammableNonFungible', async (t) => {
  >{ tokenRecord: { state: TokenState.Locked } });
 });
 
+test('it can lock a ProgrammableNonFungibleEdition', async (t) => {
+ // Given a ProgrammableNonFungible with a utility delegate.
+ const umi = await createUmi();
+ const utilityDelegate = generateSigner(umi);
+ const originalOwner = generateSigner(umi);
+ const originalMint = await createDigitalAssetWithToken(umi, {
+ name: 'My NFT',
+ symbol: 'MNFT',
+ uri: 'https://example.com/nft.json',
+ sellerFeeBasisPoints: percentAmount(5.42),
+ tokenOwner: originalOwner.publicKey,
+ printSupply: printSupply('Limited', [10]),
+ tokenStandard: TokenStandard.ProgrammableNonFungible,
+ });
+
+ // When we print a new edition of the asset.
+ const editionMint = generateSigner(umi);
+ const editionOwner = generateSigner(umi);
+ await printV2(umi, {
+ masterTokenAccountOwner: originalOwner,
+ masterEditionMint: originalMint.publicKey,
+ editionMint,
+ editionTokenAccountOwner: editionOwner.publicKey,
+ editionNumber: 1,
+ tokenStandard: TokenStandard.ProgrammableNonFungible,
+ })
+ .prepend(
+ setComputeUnitLimit(umi, {
+ units: 400000,
+ })
+ )
+ .sendAndConfirm(umi);
+
+ const editionAsset = await fetchDigitalAssetWithAssociatedToken(
+ umi,
+ editionMint.publicKey,
+ editionOwner.publicKey
+ );
+
+ await delegateUtilityV1(umi, {
+ mint: editionMint.publicKey,
+ delegate: utilityDelegate.publicKey,
+ tokenStandard: TokenStandard.ProgrammableNonFungibleEdition,
+ token: editionAsset.token.publicKey,
+ tokenRecord: editionAsset.tokenRecord?.publicKey,
+ authority: editionOwner,
+ }).sendAndConfirm(umi);
+ t.like(
+ await fetchDigitalAssetWithAssociatedToken(
+ umi,
+ editionMint.publicKey,
+ editionOwner.publicKey
+ ),
+ <DigitalAssetWithToken>{ tokenRecord: { state: TokenState.Unlocked } }
+ );
+
+ // When the utility delegate locks the asset.
+ await lockV1(umi, {
+ mint: editionMint.publicKey,
+ authority: utilityDelegate,
+ tokenStandard: TokenStandard.ProgrammableNonFungibleEdition,
+ token: editionAsset.token.publicKey,
+ tokenRecord: editionAsset.tokenRecord?.publicKey,
+ payer: editionOwner,
+ }).sendAndConfirm(umi);
+
+ // Then the token state was successfully updated.
+ t.like(
+ await fetchDigitalAssetWithAssociatedToken(
+ umi,
+ editionMint.publicKey,
+ editionOwner.publicKey
+ ),
+ <DigitalAssetWithToken>{ tokenRecord: { state: TokenState.Locked } }
+ );
+});
+
 test('it can freeze a NonFungible', async (t) => {
  // Given a NonFungible with a standard delegate.
  const umi = await createUmi();

diff --git a/clients/js/test/unlockV1.test.ts b/clients/js/test/unlockV1.test.ts
@@ -1,5 +1,12 @@
-import { TokenState as SplTokenState } from '@metaplex-foundation/mpl-toolbox';
-import { generateSigner, transactionBuilder } from '@metaplex-foundation/umi';
+import {
+ setComputeUnitLimit,
+ TokenState as SplTokenState,
+} from '@metaplex-foundation/mpl-toolbox';
+import {
+ generateSigner,
+ percentAmount,
+ transactionBuilder,
+} from '@metaplex-foundation/umi';
 import test from 'ava';
 import {
  DigitalAssetWithToken,
@@ -9,6 +16,8 @@ import {
  delegateUtilityV1,
  fetchDigitalAssetWithAssociatedToken,
  lockV1,
+ printSupply,
+ printV2,
  unlockV1,
 } from '../src';
 import {
@@ -53,6 +62,94 @@ test('it can unlock a ProgrammableNonFungible', async (t) => {
  >{ tokenRecord: { state: TokenState.Unlocked } });
 });
 
+test('it can unlock a ProgrammableNonFungibleEdition', async (t) => {
+ // Given a ProgrammableNonFungible with a utility delegate.
+ const umi = await createUmi();
+ const utilityDelegate = generateSigner(umi);
+ const originalOwner = generateSigner(umi);
+ const originalMint = await createDigitalAssetWithToken(umi, {
+ name: 'My NFT',
+ symbol: 'MNFT',
+ uri: 'https://example.com/nft.json',
+ sellerFeeBasisPoints: percentAmount(5.42),
+ tokenOwner: originalOwner.publicKey,
+ printSupply: printSupply('Limited', [10]),
+ tokenStandard: TokenStandard.ProgrammableNonFungible,
+ });
+
+ // When we print a new edition of the asset.
+ const editionMint = generateSigner(umi);
+ const editionOwner = generateSigner(umi);
+ await printV2(umi, {
+ masterTokenAccountOwner: originalOwner,
+ masterEditionMint: originalMint.publicKey,
+ editionMint,
+ editionTokenAccountOwner: editionOwner.publicKey,
+ editionNumber: 1,
+ tokenStandard: TokenStandard.ProgrammableNonFungible,
+ })
+ .prepend(
+ setComputeUnitLimit(umi, {
+ units: 400000,
+ })
+ )
+ .sendAndConfirm(umi);
+
+ const editionAsset = await fetchDigitalAssetWithAssociatedToken(
+ umi,
+ editionMint.publicKey,
+ editionOwner.publicKey
+ );
+
+ await delegateUtilityV1(umi, {
+ mint: editionMint.publicKey,
+ delegate: utilityDelegate.publicKey,
+ tokenStandard: TokenStandard.ProgrammableNonFungibleEdition,
+ token: editionAsset.token.publicKey,
+ tokenRecord: editionAsset.tokenRecord?.publicKey,
+ authority: editionOwner,
+ })
+ .add(
+ lockV1(umi, {
+ mint: editionMint.publicKey,
+ authority: utilityDelegate,
+ tokenStandard: TokenStandard.ProgrammableNonFungibleEdition,
+ token: editionAsset.token.publicKey,
+ tokenRecord: editionAsset.tokenRecord?.publicKey,
+ payer: editionOwner,
+ })
+ )
+ .sendAndConfirm(umi);
+ t.like(
+ await fetchDigitalAssetWithAssociatedToken(
+ umi,
+ editionMint.publicKey,
+ editionOwner.publicKey
+ ),
+ <DigitalAssetWithToken>{ tokenRecord: { state: TokenState.Locked } }
+ );
+
+ // When the utility delegate unlocks the asset.
+ await unlockV1(umi, {
+ mint: editionMint.publicKey,
+ authority: utilityDelegate,
+ tokenStandard: TokenStandard.ProgrammableNonFungibleEdition,
+ token: editionAsset.token.publicKey,
+ tokenRecord: editionAsset.tokenRecord?.publicKey,
+ payer: editionOwner,
+ }).sendAndConfirm(umi);
+
+ // Then the token state was successfully updated.
+ t.like(
+ await fetchDigitalAssetWithAssociatedToken(
+ umi,
+ editionMint.publicKey,
+ editionOwner.publicKey
+ ),
+ <DigitalAssetWithToken>{ tokenRecord: { state: TokenState.Unlocked } }
+ );
+});
+
 test('it can unfreeze a NonFungible', async (t) => {
  // Given a NonFungible with a standard delegate that has locked the asset.
  const umi = await createUmi();

diff --git a/programs/token-metadata/program/src/processor/state/mod.rs b/programs/token-metadata/program/src/processor/state/mod.rs
@@ -91,6 +91,7 @@ pub(crate) fn toggle_asset_state(
  if matches!(
  metadata.token_standard,
  Some(TokenStandard::ProgrammableNonFungible)
+ | Some(TokenStandard::ProgrammableNonFungibleEdition)
  ) {
  let AuthorityResponse { authority_type, .. } =
  AuthorityType::get_authority_type(AuthorityRequest {