@silvana-one/nft 0.3.0 → 1.0.1

package/dist/web/contracts/collection.js

@@ -8,7 +8,7 @@
 import { __decorate, __metadata } from "tslib";
 import { Field, PublicKey, AccountUpdate, Bool, method, state, State, Permissions, TokenContract, VerificationKey, UInt32, UInt64, Mina, Provable, } from "o1js";
 import { NFT } from "./nft.js";
-import { MintParams, MintRequest, TransferParams, CollectionData, NFTUpdateProof, NFTStateStruct, MintEvent, TransferEvent, ApproveEvent, UpgradeVerificationKeyEvent, LimitMintingEvent, PauseNFTEvent, PauseEvent, OwnershipChangeEvent, UInt64Option, MAX_ROYALTY_FEE, TransferExtendedParams, } from "../interfaces/index.js";
+import { MintParams, MintRequest, TransferBySignatureParams, TransferByProofParams, CollectionData, NFTUpdateProof, NFTStateStruct, MintEvent, NFTUpdateEvent, TransferEvent, ApproveEvent, UpgradeVerificationKeyEvent, LimitMintingEvent, PauseNFTEvent, PauseEvent, SetNameEvent, SetBaseURLEvent, SetRoyaltyFeeEvent, SetTransferFeeEvent, SetAdminEvent, OwnershipChangeEvent, UInt64Option, MAX_ROYALTY_FEE, TransferExtendedParams, } from "../interfaces/index.js";
 import { mulDiv } from "../util/index.js";
 import { nftVerificationKeys } from "../vk.js";
 export { CollectionFactory, CollectionErrors };
@@ -34,6 +34,7 @@ const CollectionErrors = {
     onlyOwnerCanUpgradeVerificationKey: "Only owner can upgrade verification key",
     invalidRoyaltyFee: "Royalty fee is too high, cannot be more than 100%",
     invalidOracleAddress: "Oracle address is invalid",
+    pendingCreatorIsEmpty: "Pending creator address is empty",
 };
 /**
  * Creates a new NFT Collection Contract class.
@@ -63,27 +64,30 @@ function CollectionFactory(params) {
              * such as flags and fee configurations.
              */
             this.packedData = State();
+            /** The public key part (x) of the pending creator. The isOdd field is written to the packedData */
+            this.pendingCreatorX = State();
             /**
              * Defines the events emitted by the contract.
              */
             this.events = {
                 mint: MintEvent,
-                update: PublicKey,
+                update: NFTUpdateEvent,
                 transfer: TransferEvent,
                 approve: ApproveEvent,
                 upgradeNFTVerificationKey: UpgradeVerificationKeyEvent,
-                upgradeVerificationKey: Field,
+                upgradeVerificationKey: UpgradeVerificationKeyEvent,
                 limitMinting: LimitMintingEvent,
                 pause: PauseEvent,
                 resume: PauseEvent,
                 pauseNFT: PauseNFTEvent,
                 resumeNFT: PauseNFTEvent,
-                ownershipChange: OwnershipChangeEvent,
-                setName: Field,
-                setBaseURL: Field,
-                setRoyaltyFee: UInt32,
-                setTransferFee: UInt64,
-                setAdmin: PublicKey,
+                ownershipTransfer: OwnershipChangeEvent,
+                ownershipAccepted: OwnershipChangeEvent,
+                setName: SetNameEvent,
+                setBaseURL: SetBaseURLEvent,
+                setRoyaltyFee: SetRoyaltyFeeEvent,
+                setTransferFee: SetTransferFeeEvent,
+                setAdmin: SetAdminEvent,
             };
         }
         /**
@@ -101,6 +105,9 @@ function CollectionFactory(params) {
             this.packedData.set(CollectionData.new({
                 isPaused: true,
             }).pack());
+            this.pendingCreatorX.set(PublicKey.empty().x);
+            // Changes must be made if the number of state fields available on the Mina blockchain changes
+            // This function should initialize ALL state fields due to the logic in the initialize() method
             this.account.zkappUri.set(props.url);
             this.account.tokenSymbol.set(props.symbol);
             this.account.permissions.set({
@@ -109,8 +116,8 @@ function CollectionFactory(params) {
                 setPermissions: Permissions.impossible(),
                 access: Permissions.proof(),
                 send: Permissions.proof(),
-                setZkappUri: Permissions.none(),
-                setTokenSymbol: Permissions.none(),
+                setZkappUri: Permissions.proof(),
+                setTokenSymbol: Permissions.proof(),
             });
         }
         /**
@@ -120,6 +127,9 @@ function CollectionFactory(params) {
          * @param collectionData - Initial collection data including flags and configurations.
          */
         async initialize(masterNFT, collectionData) {
+            // Changes must be made if the number of state fields available on the Mina blockchain changes
+            // as the next line relies on the fact that the state size is 8 Fields
+            // and all 8 Field are initialized in deploy()
             this.account.provedState.requireEquals(Bool(false));
             collectionData.royaltyFee.assertLessThanOrEqual(UInt32.from(MAX_ROYALTY_FEE), CollectionErrors.invalidRoyaltyFee);
             this.packedData.set(collectionData.pack());
@@ -200,7 +210,9 @@ function CollectionFactory(params) {
          * @returns The packed data of the collection.
          */
         async ensureNotPaused() {
-            CollectionData.isPaused(this.packedData.getAndRequireEquals()).assertFalse(CollectionErrors.collectionPaused);
+            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
+            collectionData.isPaused.assertFalse(CollectionErrors.collectionPaused);
+            return collectionData;
         }
         /**
          * Mints a new NFT directly by the creator.
@@ -217,7 +229,8 @@ function CollectionFactory(params) {
          * @param params - The mint parameters containing details of the NFT to be minted.
          */
         async mintByCreator(params) {
-            CollectionData.mintingIsLimited(this.packedData.getAndRequireEquals()).assertFalse(CollectionErrors.cannotMint);
+            const collectionData = await this.ensureNotPaused();
+            collectionData.mintingIsLimited.assertFalse(CollectionErrors.cannotMint);
             const creatorUpdate = await this.ensureCreatorSignature();
             // Pay 1 MINA fee for a new account
             creatorUpdate.balance.subInPlace(1_000_000_000);
@@ -229,10 +242,13 @@ function CollectionFactory(params) {
          * @param mintRequest - The minting request containing parameters and proofs.
          */
         async mint(mintRequest) {
-            CollectionData.mintingIsLimited(this.packedData.getAndRequireEquals()).assertFalse(CollectionErrors.cannotMint);
+            const collectionData = await this.ensureNotPaused();
+            collectionData.mintingIsLimited.assertFalse(CollectionErrors.cannotMint);
             const adminContract = this.getAdminContract();
             // The admin contract checks that the sender is allowed to mint
             const mintParams = (await adminContract.canMint(mintRequest)).assertSome(CollectionErrors.cannotMint);
+            mintParams.address.assertEquals(mintRequest.address);
+            mintParams.data.owner.assertEquals(mintRequest.owner);
             // Prevent minting the Master NFT using this method
             mintParams.address
                 .equals(this.address)
@@ -247,11 +263,16 @@ function CollectionFactory(params) {
          * @returns The MintEvent emitted.
          */
         async _mint(params) {
-            const { name, address, data, metadata, storage, metadataVerificationKeyHash, expiry, } = params;
+            const { name, address, data, metadata, storage, metadataVerificationKeyHash, expiry, fee, tokenId, } = params;
             this.network.globalSlotSinceGenesis.requireBetween(UInt32.zero, expiry);
-            data.version.assertEquals(UInt32.zero);
+            data.version.assertEquals(UInt64.zero);
+            data.isPaused
+                .equals(Bool(false))
+                .or(data.canPause.equals(Bool(true)))
+                .assertTrue(CollectionErrors.cannotMint);
             const packedData = data.pack();
-            const tokenId = this.deriveTokenId();
+            const collectionTokenId = this.deriveTokenId();
+            collectionTokenId.assertEquals(tokenId);
             const update = AccountUpdate.createSigned(address, tokenId);
             update.body.useFullCommitment = Bool(true); // Prevent memo and fee change
             update.account.isNew.getAndRequireEquals().assertTrue();
@@ -279,17 +300,14 @@ function CollectionFactory(params) {
             });
             const mainnetVerificationKeyHash = Field(nftVerificationKeys.mainnet.vk.NFT.hash);
             const devnetVerificationKeyHash = Field(nftVerificationKeys.devnet.vk.NFT.hash);
-            const isMainnet = Provable.witness(Bool, () => {
-                // This check does NOT create a constraint on the verification key
-                // as this witness can be replaced during runtime
-                // and is useful only for making sure that the verification key
-                // of the NFT will match the compiled verification key of the NFT
-                // at the time of the deployment of the Collection Contract
-                return Bool(Mina.getNetworkId() === "mainnet");
-            });
             // We check that the verification key hash is the same as the one
-            // that was compiled at the time of the deployment
-            verificationKey.hash.assertEquals(Provable.if(isMainnet, mainnetVerificationKeyHash, devnetVerificationKeyHash));
+            // that was compiled at the time of the collection deployment
+            if (Mina.getNetworkId() === "mainnet") {
+                verificationKey.hash.assertEquals(mainnetVerificationKeyHash);
+            }
+            else {
+                verificationKey.hash.assertEquals(devnetVerificationKeyHash);
+            }
             update.body.update.verificationKey = {
                 isSome: Bool(true),
                 value: verificationKey,
@@ -323,6 +341,8 @@ function CollectionFactory(params) {
             const event = new MintEvent({
                 initialState,
                 address,
+                tokenId,
+                fee,
             });
             this.emitEvent("mint", event);
             return event;
@@ -334,6 +354,12 @@ function CollectionFactory(params) {
          * @param vk - The verification key.
          */
         async update(proof, vk) {
+            // The oracle address is optional and can be empty, NFT ZkProgram can verify the address
+            // as it can be different for different NFTs. It should be empty for the update() call
+            const oracleAddress = proof.publicInput.oracleAddress;
+            oracleAddress
+                .equals(PublicKey.empty())
+                .assertTrue(CollectionErrors.invalidOracleAddress);
             await this._update(proof, vk);
         }
         /**
@@ -344,7 +370,7 @@ function CollectionFactory(params) {
          */
         async updateWithOracle(proof, vk) {
             // The oracle address is optional and can be empty, NFT ZkProgram can verify the address
-            // as it can be different for different NFTs
+            // as it can be different for different NFTs. It should be non-empty for the updateWithOracle() call
             const oracleAddress = proof.publicInput.oracleAddress;
             oracleAddress
                 .equals(PublicKey.empty())
@@ -374,7 +400,9 @@ function CollectionFactory(params) {
             // Verify the metadata update proof
             metadataVerificationKeyHash.assertEquals(vk.hash);
             proof.verify(vk);
-            this.emitEvent("update", proof.publicInput.immutableState.address);
+            this.emitEvent("update", new NFTUpdateEvent({
+                address: proof.publicInput.immutableState.address,
+            }));
         }
         /**
          * Approves an address to transfer an NFT.
@@ -393,10 +421,11 @@ function CollectionFactory(params) {
         /**
          * Transfers ownership of an NFT without admin approval.
          *
-         * @param address - The address of the NFT.
-         * @param to - The recipient's public key.
+         * @param nftAddress - The address of the NFT.
+         * @param approved - The approved public key.
          */
         async approveAddressByProof(nftAddress, approved) {
+            await this.ensureNotPaused();
             const tokenId = this.deriveTokenId();
             const nft = new NFT(nftAddress, tokenId);
             const owner = await nft.approveAddress(approved);
@@ -416,8 +445,7 @@ function CollectionFactory(params) {
          */
         async transferBySignature(params) {
             const { address, to, price, context } = params;
-            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
-            collectionData.isPaused.assertFalse(CollectionErrors.collectionPaused);
+            const collectionData = await this.ensureNotPaused();
             collectionData.requireTransferApproval.assertFalse(CollectionErrors.transferApprovalRequired);
             const transferEventDraft = new TransferExtendedParams({
                 from: PublicKey.empty(), // will be added later
@@ -445,8 +473,8 @@ function CollectionFactory(params) {
          */
         async transferByProof(params) {
             const { address, from, to, price, context } = params;
-            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
-            collectionData.isPaused.assertFalse(CollectionErrors.collectionPaused);
+            const collectionData = await this.ensureNotPaused();
+            collectionData.requireTransferApproval.assertFalse(CollectionErrors.transferApprovalRequired);
             const transferEventDraft = new TransferExtendedParams({
                 from,
                 to,
@@ -482,10 +510,9 @@ function CollectionFactory(params) {
          *
          * @param params - The transfer parameters.
          */
-        async approvedTransferByProof(params) {
+        async adminApprovedTransferByProof(params) {
             const { address, from, to, price, context } = params;
-            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
-            collectionData.isPaused.assertFalse(CollectionErrors.collectionPaused);
+            const collectionData = await this.ensureNotPaused();
             const transferEventDraft = new TransferExtendedParams({
                 from,
                 to,
@@ -524,10 +551,9 @@ function CollectionFactory(params) {
          * @param to - The recipient's public key.
          * @param price - The price of the NFT (optional).
          */
-        async approvedTransferBySignature(params) {
+        async adminApprovedTransferBySignature(params) {
             const { address, to, price, context } = params;
-            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
-            collectionData.isPaused.assertFalse(CollectionErrors.collectionPaused);
+            const collectionData = await this.ensureNotPaused();
             const transferEventDraft = new TransferExtendedParams({
                 from: PublicKey.empty(), // will be added later
                 to,
@@ -547,14 +573,21 @@ function CollectionFactory(params) {
             const adminContract = this.getAdminContract();
             const canTransfer = await adminContract.canTransfer(transferEvent);
             canTransfer.assertTrue();
-            this.emitEvent("transfer", transferEvent);
         }
         /**
          * Internal method to transfer an NFT.
          *
-         * @param address - The address of the NFT.
-         * @param to - The recipient's public key.
+         * This method handles the transfer logic and fee calculation. The fee is determined as follows:
+         * - If a price is provided, the fee is calculated as (price * royaltyFee / MAX_ROYALTY_FEE)
+         * - If no price is provided, the fixed transferFee is used to handle two cases:
+         *  when NFT is being sold and the price is not provided to the contract
+         *  when NFT is being transferred by the owner (without price)
+         * - If the sender is the creator, no fee is charged
+         * - The minimum fee is always the transferFee (unless sender is creator)
+         *
+         * @param transferEventDraft - The transfer event draft, containing the information about the transfer
          * @param transferFee - The transfer fee amount.
+         * @param royaltyFee - The royalty fee amount.
          * @returns The TransferEvent emitted.
          */
         async _transfer(params) {
@@ -567,7 +600,6 @@ function CollectionFactory(params) {
             const nft = new NFT(transferEventDraft.nft, tokenId);
             const transferEvent = await nft.transfer(transferEventDraft);
             const creator = this.creator.getAndRequireEquals();
-            // TODO: check is the owner is the creator
             let fee = Provable.if(transferEventDraft.price.isSome, 
             // We cannot check the price here, so we just rely on owner contract
             // Malicious owner contracts can be blocked by the admin contract
@@ -605,6 +637,7 @@ function CollectionFactory(params) {
          * @param vk - The new verification key.
          */
         async upgradeNFTVerificationKeyBySignature(address, vk) {
+            await this.ensureNotPaused();
             const sender = this.sender.getAndRequireSignature();
             const data = await this._upgrade(address, vk);
             data.owner
@@ -619,6 +652,7 @@ function CollectionFactory(params) {
          * @param vk - The new verification key.
          */
         async upgradeNFTVerificationKeyByProof(address, vk) {
+            await this.ensureNotPaused();
             const data = await this._upgrade(address, vk);
             const ownerContract = this.getOwnerContract(data.owner);
             const canUpgrade = await ownerContract.canChangeVerificationKey(this.address, address, vk);
@@ -645,19 +679,23 @@ function CollectionFactory(params) {
          * @param vk - The new verification key.
          */
         async upgradeVerificationKey(vk) {
+            await this.ensureNotPaused();
             const adminContract = this.getAdminContract();
             const canUpgrade = await adminContract.canChangeVerificationKey(vk, this.address, this.tokenId);
             canUpgrade.assertTrue(CollectionErrors.cannotUpgradeVerificationKey);
             this.account.verificationKey.set(vk);
-            this.emitEvent("upgradeVerificationKey", vk.hash);
+            this.emitEvent("upgradeVerificationKey", new UpgradeVerificationKeyEvent({
+                address: this.address,
+                tokenId: this.tokenId,
+                verificationKeyHash: vk.hash,
+            }));
         }
         /**
          * Limits further minting of NFTs in the collection.
          */
         async limitMinting() {
             await this.ensureCreatorSignature();
-            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
-            collectionData.isPaused.assertFalse(CollectionErrors.collectionPaused);
+            const collectionData = await this.ensureNotPaused();
             collectionData.mintingIsLimited = Bool(true);
             this.packedData.set(collectionData.pack());
             this.emitEvent("limitMinting", new LimitMintingEvent({ mintingLimited: Bool(true) }));
@@ -666,8 +704,7 @@ function CollectionFactory(params) {
          * Pauses the collection, disabling certain actions.
          */
         async pause() {
-            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
-            collectionData.isPaused.assertFalse(CollectionErrors.collectionPaused);
+            const collectionData = await this.ensureNotPaused();
             const adminContract = this.getAdminContract();
             const canPause = await adminContract.canPause();
             canPause.assertTrue(CollectionErrors.noPermissionToPause);
@@ -694,6 +731,7 @@ function CollectionFactory(params) {
          * @param address - The address of the NFT to pause.
          */
         async pauseNFTBySignature(address) {
+            await this.ensureNotPaused();
             const tokenId = this.deriveTokenId();
             const nft = new NFT(address, tokenId);
             const owner = await nft.pause();
@@ -706,6 +744,7 @@ function CollectionFactory(params) {
          * @param address - The address of the NFT to pause.
          */
         async pauseNFTByProof(address) {
+            await this.ensureNotPaused();
             const tokenId = this.deriveTokenId();
             const nft = new NFT(address, tokenId);
             const owner = await nft.pause();
@@ -720,6 +759,7 @@ function CollectionFactory(params) {
          * @param address - The address of the NFT to resume.
          */
         async resumeNFT(address) {
+            await this.ensureNotPaused();
             const tokenId = this.deriveTokenId();
             const nft = new NFT(address, tokenId);
             const owner = await nft.resume();
@@ -732,6 +772,7 @@ function CollectionFactory(params) {
          * @param address - The address of the NFT to resume.
          */
         async resumeNFTByProof(address) {
+            await this.ensureNotPaused();
             const tokenId = this.deriveTokenId();
             const nft = new NFT(address, tokenId);
             const owner = await nft.resume();
@@ -754,7 +795,7 @@ function CollectionFactory(params) {
             const canChangeName = await adminContract.canChangeName(name);
             canChangeName.assertTrue(CollectionErrors.noPermissionToChangeName);
             this.collectionName.set(name);
-            this.emitEvent("setName", name);
+            this.emitEvent("setName", new SetNameEvent({ name }));
         }
         /**
          * Updates the base URL for the collection's metadata.
@@ -770,7 +811,7 @@ function CollectionFactory(params) {
             const canChangeBaseUri = await adminContract.canChangeBaseUri(baseURL);
             canChangeBaseUri.assertTrue(CollectionErrors.noPermissionToChangeBaseUri);
             this.baseURL.set(baseURL);
-            this.emitEvent("setBaseURL", baseURL);
+            this.emitEvent("setBaseURL", new SetBaseURLEvent({ baseURL }));
         }
         /**
          * Sets a new admin address for the collection.
@@ -786,7 +827,7 @@ function CollectionFactory(params) {
             const canSetAdmin = await adminContract.canSetAdmin(admin);
             canSetAdmin.assertTrue(CollectionErrors.noPermissionToSetAdmin);
             this.admin.set(admin);
-            this.emitEvent("setAdmin", admin);
+            this.emitEvent("setAdmin", new SetAdminEvent({ admin }));
         }
         /**
          * Updates the royalty fee for the collection.
@@ -797,15 +838,14 @@ function CollectionFactory(params) {
          * @throws {Error} If caller lacks permission to change royalty fee
          */
         async setRoyaltyFee(royaltyFee) {
-            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
-            collectionData.isPaused.assertFalse(CollectionErrors.collectionPaused);
+            const collectionData = await this.ensureNotPaused();
             royaltyFee.assertLessThanOrEqual(UInt32.from(MAX_ROYALTY_FEE), CollectionErrors.invalidRoyaltyFee);
             const adminContract = this.getAdminContract();
             const canChangeRoyalty = await adminContract.canChangeRoyalty(royaltyFee);
             canChangeRoyalty.assertTrue(CollectionErrors.noPermissionToChangeRoyalty);
             collectionData.royaltyFee = royaltyFee;
             this.packedData.set(collectionData.pack());
-            this.emitEvent("setRoyaltyFee", royaltyFee);
+            this.emitEvent("setRoyaltyFee", new SetRoyaltyFeeEvent({ royaltyFee }));
         }
         /**
          * Updates the transfer fee for the collection.
@@ -816,35 +856,76 @@ function CollectionFactory(params) {
          * @throws {Error} If caller lacks permission to change transfer fee
          */
         async setTransferFee(transferFee) {
-            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
-            collectionData.isPaused.assertFalse(CollectionErrors.collectionPaused);
+            const collectionData = await this.ensureNotPaused();
             const adminContract = this.getAdminContract();
             const canChangeTransferFee = await adminContract.canChangeTransferFee(transferFee);
             canChangeTransferFee.assertTrue(CollectionErrors.noPermissionToChangeTransferFee);
             collectionData.transferFee = transferFee;
             this.packedData.set(collectionData.pack());
-            this.emitEvent("setTransferFee", transferFee);
+            this.emitEvent("setTransferFee", new SetTransferFeeEvent({ transferFee }));
         }
         /**
-         * Transfers ownership of the collection to a new owner.
+         * Transfers ownership of the collection to a new creator.
+         * This method is called transferOwnership as the Collection is implementing OwnableContract interface
+         * For the Collection, the creator is the owner of the collection
          *
-         * @param to - The public key of the new owner.
-         * @returns The public key of the old owner.
+         * @param to - The public key of the new creator.
+         * @returns The public key of the old creator.
          */
         async transferOwnership(to) {
             await this.ensureCreatorSignature();
-            await this.ensureNotPaused();
+            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
+            collectionData.isPaused.assertFalse(CollectionErrors.collectionNotPaused);
             const adminContract = this.getAdminContract();
             const canChangeCreator = await adminContract.canChangeCreator(to);
             canChangeCreator.assertTrue(CollectionErrors.noPermissionToChangeCreator);
             const from = this.creator.getAndRequireEquals();
-            this.creator.set(to);
-            this.emitEvent("ownershipChange", new OwnershipChangeEvent({
+            // Pending creator public key can be empty, it cancels the transfer
+            this.pendingCreatorX.set(to.x);
+            collectionData.pendingCreatorIsOdd = to.isOdd;
+            this.packedData.set(collectionData.pack());
+            this.emitEvent("ownershipTransfer", new OwnershipChangeEvent({
                 from,
                 to,
             }));
             return from;
         }
+        /**
+         * Transfers ownership of the collection to a new owner.
+         *
+         * @param to - The public key of the new owner.
+         * @returns The public key of the old owner.
+         */
+        async acceptOwnership() {
+            const collectionData = CollectionData.unpack(this.packedData.getAndRequireEquals());
+            collectionData.isPaused.assertFalse(CollectionErrors.collectionNotPaused);
+            const pendingCreatorX = this.pendingCreatorX.getAndRequireEquals();
+            const pendingCreator = PublicKey.from({
+                x: pendingCreatorX,
+                isOdd: collectionData.pendingCreatorIsOdd,
+            });
+            const emptyPublicKey = PublicKey.empty();
+            pendingCreator
+                .equals(emptyPublicKey)
+                .assertFalse(CollectionErrors.pendingCreatorIsEmpty);
+            // pendingCreator can be different from the sender, but it should sign the tx
+            const pendingCreatorUpdate = AccountUpdate.createSigned(pendingCreator);
+            pendingCreatorUpdate.body.useFullCommitment = Bool(true); // Prevent memo and fee change
+            // Check second time that the transfer is allowed
+            const adminContract = this.getAdminContract();
+            const canChangeCreator = await adminContract.canChangeCreator(pendingCreator);
+            canChangeCreator.assertTrue(CollectionErrors.noPermissionToChangeCreator);
+            const from = this.creator.getAndRequireEquals();
+            this.pendingCreatorX.set(emptyPublicKey.x);
+            collectionData.pendingCreatorIsOdd = Bool(emptyPublicKey.isOdd);
+            this.creator.set(pendingCreator);
+            this.packedData.set(collectionData.pack());
+            this.emitEvent("ownershipAccepted", new OwnershipChangeEvent({
+                from,
+                to: pendingCreator,
+            }));
+            return from;
+        }
         async getNFTState(address) {
             const tokenId = this.deriveTokenId();
             const nft = new NFT(address, tokenId);
@@ -872,6 +953,10 @@ function CollectionFactory(params) {
         state(Field),
         __metadata("design:type", Object)
     ], Collection.prototype, "packedData", void 0);
+    __decorate([
+        state(Field),
+        __metadata("design:type", Object)
+    ], Collection.prototype, "pendingCreatorX", void 0);
     __decorate([
         method,
         __metadata("design:type", Function),
@@ -921,27 +1006,27 @@ function CollectionFactory(params) {
     __decorate([
         method,
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [TransferParams]),
+        __metadata("design:paramtypes", [TransferBySignatureParams]),
         __metadata("design:returntype", Promise)
     ], Collection.prototype, "transferBySignature", null);
     __decorate([
         method,
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [TransferParams]),
+        __metadata("design:paramtypes", [TransferByProofParams]),
         __metadata("design:returntype", Promise)
     ], Collection.prototype, "transferByProof", null);
     __decorate([
         method,
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [TransferParams]),
+        __metadata("design:paramtypes", [TransferByProofParams]),
         __metadata("design:returntype", Promise)
-    ], Collection.prototype, "approvedTransferByProof", null);
+    ], Collection.prototype, "adminApprovedTransferByProof", null);
     __decorate([
         method,
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [TransferParams]),
+        __metadata("design:paramtypes", [TransferBySignatureParams]),
         __metadata("design:returntype", Promise)
-    ], Collection.prototype, "approvedTransferBySignature", null);
+    ], Collection.prototype, "adminApprovedTransferBySignature", null);
     __decorate([
         method,
         __metadata("design:type", Function),
@@ -1040,6 +1125,12 @@ function CollectionFactory(params) {
         __metadata("design:paramtypes", [PublicKey]),
         __metadata("design:returntype", Promise)
     ], Collection.prototype, "transferOwnership", null);
+    __decorate([
+        method.returns(PublicKey),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], Collection.prototype, "acceptOwnership", null);
     __decorate([
         method.returns(NFTStateStruct),
         __metadata("design:type", Function),