@silvana-one/abi 0.1.1 → 0.1.2

package/dist/web/nft/build.js

@@ -0,0 +1,724 @@
+import { Whitelist, Storage, } from "@silvana-one/storage";
+import { fetchMinaAccount } from "../fetch.js";
+import { Collection, AdvancedCollection, NFTAdmin, NFTAdvancedAdmin, Metadata, pinMetadata, fieldFromString, CollectionData, MintParams, NFTData, } from "@silvana-one/nft";
+import { tokenVerificationKeys } from "../vk/index.js";
+import { PublicKey, Mina, AccountUpdate, UInt64, Field, TokenId, UInt32, fetchLastBlock, } from "o1js";
+export async function buildNftCollectionLaunchTransaction(params) {
+    const { chain, args } = params;
+    const { url = chain === "mainnet"
+        ? "https://minanft.io"
+        : `https://${chain}.minanft.io`, symbol = "NFT", memo, nonce, adminContract: adminType, masterNFT, } = args;
+    if (memo && typeof memo !== "string")
+        throw new Error("Memo must be a string");
+    if (memo && memo.length > 30)
+        throw new Error("Memo must be less than 30 characters");
+    if (!symbol || typeof symbol !== "string")
+        throw new Error("Symbol must be a string");
+    if (symbol.length >= 7)
+        throw new Error("Symbol must be less than 7 characters");
+    if (masterNFT === undefined) {
+        throw new Error("masterNFT is required");
+    }
+    if (masterNFT.metadata === undefined) {
+        throw new Error("masterNFT.metadata is required");
+    }
+    if (typeof masterNFT.metadata === "string" &&
+        masterNFT.storage === undefined) {
+        throw new Error("masterNFT.storage is required if metadata is a string");
+    }
+    const sender = PublicKey.fromBase58(args.sender);
+    if (nonce === undefined)
+        throw new Error("Nonce is required");
+    if (typeof nonce !== "number")
+        throw new Error("Nonce must be a number");
+    const fee = 100_000_000;
+    if (url && typeof url !== "string")
+        throw new Error("Url must be a string");
+    if (!args.collectionAddress || typeof args.collectionAddress !== "string")
+        throw new Error("collectionAddress is required");
+    if (!args.adminContractAddress ||
+        typeof args.adminContractAddress !== "string")
+        throw new Error("adminContractAddress is required");
+    const adminContract = adminType === "advanced" ? NFTAdvancedAdmin : NFTAdmin;
+    const collectionContract = adminType === "advanced" ? AdvancedCollection : Collection;
+    const vk = tokenVerificationKeys[chain === "mainnet" ? "mainnet" : "devnet"].vk;
+    if (!vk ||
+        !vk.Collection ||
+        !vk.Collection.hash ||
+        !vk.Collection.data ||
+        !vk.AdvancedCollection ||
+        !vk.AdvancedCollection.hash ||
+        !vk.AdvancedCollection.data ||
+        !vk.NFT ||
+        !vk.NFT.hash ||
+        !vk.NFT.data ||
+        !vk.NFTAdmin ||
+        !vk.NFTAdmin.hash ||
+        !vk.NFTAdmin.data ||
+        !vk.NFTAdvancedAdmin ||
+        !vk.NFTAdvancedAdmin.hash ||
+        !vk.NFTAdvancedAdmin.data)
+        throw new Error("Cannot get verification key from vk");
+    const adminVerificationKey = adminType === "advanced" ? vk.NFTAdvancedAdmin : vk.NFTAdmin;
+    const collectionVerificationKey = adminType === "advanced" ? vk.NFTAdvancedCollection : vk.NFTCollection;
+    if (!adminVerificationKey || !collectionVerificationKey)
+        throw new Error("Cannot get verification keys");
+    await fetchMinaAccount({
+        publicKey: sender,
+        force: true,
+    });
+    if (!Mina.hasAccount(sender)) {
+        throw new Error("Sender does not have account");
+    }
+    const whitelist = "whitelist" in args && args.whitelist
+        ? typeof args.whitelist === "string"
+            ? Whitelist.fromString(args.whitelist)
+            : (await Whitelist.create({ list: args.whitelist, name: symbol }))
+                .whitelist
+        : Whitelist.empty();
+    const collectionAddress = PublicKey.fromBase58(args.collectionAddress);
+    const adminContractAddress = PublicKey.fromBase58(args.adminContractAddress);
+    const creator = args.creator ? PublicKey.fromBase58(args.creator) : sender;
+    const zkCollection = new collectionContract(collectionAddress);
+    const zkAdmin = new adminContract(adminContractAddress);
+    const metadataVerificationKeyHash = masterNFT.metadataVerificationKeyHash
+        ? Field.fromJSON(masterNFT.metadataVerificationKeyHash)
+        : Field(0);
+    const provingKey = params.provingKey
+        ? PublicKey.fromBase58(params.provingKey)
+        : sender;
+    const provingFee = params.provingFee
+        ? UInt64.from(Math.round(params.provingFee))
+        : undefined;
+    const developerFee = args.developerFee
+        ? UInt64.from(Math.round(args.developerFee))
+        : undefined;
+    const developerAddress = params.developerAddress
+        ? PublicKey.fromBase58(params.developerAddress)
+        : undefined;
+    const { name, ipfsHash, metadataRoot, privateMetadata, serializedMap } = typeof masterNFT.metadata === "string"
+        ? {
+            name: masterNFT.name,
+            ipfsHash: masterNFT.storage,
+            metadataRoot: Field.fromJSON(masterNFT.metadata),
+            privateMetadata: undefined,
+            serializedMap: undefined,
+        }
+        : await pinMetadata(Metadata.fromOpenApiJSON({ json: masterNFT.metadata }));
+    if (ipfsHash === undefined)
+        throw new Error("storage is required, but not provided");
+    if (metadataRoot === undefined)
+        throw new Error("metadataRoot is required");
+    const slot = chain === "local"
+        ? Mina.currentSlot()
+        : chain === "zeko"
+            ? UInt32.zero
+            : (await fetchLastBlock()).globalSlotSinceGenesis;
+    const expiry = slot.add(UInt32.from(chain === "mainnet" || chain === "devnet" ? 20 : 100000));
+    const nftData = NFTData.new({
+        owner: creator,
+        approved: undefined,
+        version: undefined,
+        id: masterNFT.data.id ? BigInt(masterNFT.data.id) : undefined,
+        canChangeOwnerByProof: masterNFT.data.canChangeOwnerByProof,
+        canTransfer: masterNFT.data.canTransfer,
+        canApprove: masterNFT.data.canApprove,
+        canChangeMetadata: masterNFT.data.canChangeMetadata,
+        canChangeStorage: masterNFT.data.canChangeStorage,
+        canChangeName: masterNFT.data.canChangeName,
+        canChangeMetadataVerificationKeyHash: masterNFT.data.canChangeMetadataVerificationKeyHash,
+        canPause: masterNFT.data.canPause,
+        isPaused: masterNFT.data.isPaused,
+        requireOwnerAuthorizationToUpgrade: masterNFT.data.requireOwnerAuthorizationToUpgrade,
+    });
+    const mintParams = new MintParams({
+        name: fieldFromString(name),
+        address: collectionAddress,
+        tokenId: TokenId.derive(collectionAddress),
+        data: nftData,
+        fee: args.masterNFT.fee
+            ? UInt64.from(Math.round(args.masterNFT.fee * 1_000_000_000))
+            : UInt64.zero,
+        metadata: metadataRoot,
+        storage: Storage.fromString(ipfsHash),
+        metadataVerificationKeyHash,
+        expiry: masterNFT.expiry
+            ? UInt32.from(Math.round(masterNFT.expiry))
+            : expiry,
+    });
+    const collectionData = CollectionData.new(args.collectionData ?? {});
+    const tx = await Mina.transaction({
+        sender,
+        fee,
+        memo: memo ?? `${args.collectionName} NFT collection launch`.substring(0, 30),
+        nonce,
+    }, async () => {
+        const feeAccountUpdate = AccountUpdate.createSigned(sender);
+        feeAccountUpdate.balance.subInPlace(3_000_000_000);
+        if (provingFee && provingKey)
+            feeAccountUpdate.send({
+                to: provingKey,
+                amount: provingFee,
+            });
+        if (developerAddress && developerFee) {
+            feeAccountUpdate.send({
+                to: developerAddress,
+                amount: developerFee,
+            });
+        }
+        if (zkAdmin instanceof NFTAdvancedAdmin) {
+            throw new Error("Advanced admin is not supported");
+        }
+        else if (zkAdmin instanceof NFTAdmin) {
+            await zkAdmin.deploy({
+                admin: sender,
+                uri: `NFT Admin`,
+            });
+            // deploy() and initialize() create 2 account updates for the same publicKey, it is intended
+            await zkCollection.deploy({
+                creator,
+                collectionName: fieldFromString(args.collectionName),
+                baseURL: fieldFromString(args.baseURL ?? "ipfs"),
+                admin: adminContractAddress,
+                symbol,
+                url,
+            });
+            await zkCollection.initialize(mintParams, collectionData);
+        }
+    });
+    return {
+        request: adminType === "advanced"
+            ? {
+                ...args,
+                whitelist: whitelist.toString(),
+            }
+            : args,
+        tx,
+        adminType,
+        name: args.collectionName,
+        verificationKeyHashes: [
+            adminVerificationKey.hash,
+            collectionVerificationKey.hash,
+        ],
+        metadataRoot: metadataRoot.toJSON(),
+        storage: ipfsHash,
+        privateMetadata,
+        map: serializedMap,
+    };
+}
+export async function buildNftTransaction(params) {
+    const { chain, args } = params;
+    const { nonce, txType } = args;
+    if (nonce === undefined)
+        throw new Error("Nonce is required");
+    if (typeof nonce !== "number")
+        throw new Error("Nonce must be a number");
+    if (txType === undefined)
+        throw new Error("Tx type is required");
+    if (typeof txType !== "string")
+        throw new Error("Tx type must be a string");
+    const sender = PublicKey.fromBase58(args.sender);
+    const collectionAddress = PublicKey.fromBase58(args.collectionAddress);
+    if (args.nftMintParams.address === undefined) {
+        throw new Error("NFT address is required");
+    }
+    const nftAddress = PublicKey.fromBase58(args.nftMintParams.address);
+    // const offerAddress =
+    //   "offerAddress" in args && args.offerAddress
+    //     ? PublicKey.fromBase58(args.offerAddress)
+    //     : undefined;
+    // if (
+    //   !offerAddress &&
+    //   (txType === "token:offer:create" ||
+    //     txType === "token:offer:buy" ||
+    //     txType === "token:offer:withdraw")
+    // )
+    //   throw new Error("Offer address is required");
+    // const bidAddress =
+    //   "bidAddress" in args && args.bidAddress
+    //     ? PublicKey.fromBase58(args.bidAddress)
+    //     : undefined;
+    // if (
+    //   !bidAddress &&
+    //   (txType === "token:bid:create" ||
+    //     txType === "token:bid:sell" ||
+    //     txType === "token:bid:withdraw")
+    // )
+    //   throw new Error("Bid address is required");
+    // const to =
+    //   "to" in args && args.to ? PublicKey.fromBase58(args.to) : undefined;
+    // if (
+    //   !to &&
+    //   (txType === "token:transfer" ||
+    //     txType === "token:airdrop" ||
+    //     txType === "token:mint")
+    // )
+    //   throw new Error("To address is required");
+    // const from =
+    //   "from" in args && args.from ? PublicKey.fromBase58(args.from) : undefined;
+    // if (!from && txType === "token:burn")
+    //   throw new Error("From address is required for token:burn");
+    // const amount =
+    //   "amount" in args ? UInt64.from(Math.round(args.amount)) : undefined;
+    // const price =
+    //   "price" in args && args.price
+    //     ? UInt64.from(Math.round(args.price))
+    //     : undefined;
+    // const slippage = UInt32.from(
+    //   Math.round(
+    //     "slippage" in args && args.slippage !== undefined ? args.slippage : 50
+    //   )
+    // );
+    await fetchMinaAccount({
+        publicKey: sender,
+        force: true,
+    });
+    if (!Mina.hasAccount(sender)) {
+        throw new Error("Sender does not have account");
+    }
+    const { symbol, adminContractAddress, adminType, verificationKeyHashes } = await getNftSymbolAndAdmin({
+        txType,
+        collectionAddress,
+        chain,
+        nftAddress: undefined, // TODO: add nft address
+    });
+    const memo = args.memo ?? `${txType} ${symbol} ${args.nftMintParams.name}`;
+    const fee = 100_000_000;
+    const provingKey = params.provingKey
+        ? PublicKey.fromBase58(params.provingKey)
+        : sender;
+    const provingFee = params.provingFee
+        ? UInt64.from(Math.round(params.provingFee))
+        : undefined;
+    const developerFee = args.developerFee
+        ? UInt64.from(Math.round(args.developerFee))
+        : undefined;
+    const developerAddress = params.developerAddress
+        ? PublicKey.fromBase58(params.developerAddress)
+        : undefined;
+    //const adminContract = new FungibleTokenAdmin(adminContractAddress);
+    const advancedAdminContract = new NFTAdvancedAdmin(adminContractAddress);
+    const adminContract = new NFTAdmin(adminContractAddress);
+    const collectionContract = adminType === "advanced" ? AdvancedCollection : Collection;
+    // if (
+    //   (txType === "token:admin:whitelist" ||
+    //     txType === "token:bid:whitelist" ||
+    //     txType === "token:offer:whitelist") &&
+    //   !args.whitelist
+    // ) {
+    //   throw new Error("Whitelist is required");
+    // }
+    // const whitelist =
+    //   "whitelist" in args && args.whitelist
+    //     ? typeof args.whitelist === "string"
+    //       ? Whitelist.fromString(args.whitelist)
+    //       : (await Whitelist.create({ list: args.whitelist, name: symbol }))
+    //           .whitelist
+    //     : Whitelist.empty();
+    const zkCollection = new collectionContract(collectionAddress);
+    const tokenId = zkCollection.deriveTokenId();
+    // if (
+    //   txType === "nft:mint" &&
+    //   adminType === "standard" &&
+    //   adminAddress.toBase58() !== sender.toBase58()
+    // )
+    //   throw new Error(
+    //     "Invalid sender for FungibleToken mint with standard admin"
+    //   );
+    await fetchMinaAccount({
+        publicKey: nftAddress,
+        tokenId,
+        force: ["nft:transfer"].includes(txType),
+    });
+    // if (to) {
+    //   await fetchMinaAccount({
+    //     publicKey: to,
+    //     tokenId,
+    //     force: false,
+    //   });
+    // }
+    // if (from) {
+    //   await fetchMinaAccount({
+    //     publicKey: from,
+    //     tokenId,
+    //     force: false,
+    //   });
+    // }
+    // if (offerAddress)
+    //   await fetchMinaAccount({
+    //     publicKey: offerAddress,
+    //     tokenId,
+    //     force: (
+    //       [
+    //         "token:offer:whitelist",
+    //         "token:offer:buy",
+    //         "token:offer:withdraw",
+    //       ] satisfies TokenTransactionType[] as TokenTransactionType[]
+    //     ).includes(txType),
+    //   });
+    // if (bidAddress)
+    //   await fetchMinaAccount({
+    //     publicKey: bidAddress,
+    //     force: (
+    //       [
+    //         "token:bid:whitelist",
+    //         "token:bid:sell",
+    //         "token:bid:withdraw",
+    //       ] satisfies TokenTransactionType[] as TokenTransactionType[]
+    //     ).includes(txType),
+    //   });
+    // const offerContract = offerAddress
+    //   ? new FungibleTokenOfferContract(offerAddress, tokenId)
+    //   : undefined;
+    // const bidContract = bidAddress
+    //   ? new FungibleTokenBidContract(bidAddress)
+    //   : undefined;
+    // const offerContractDeployment = offerAddress
+    //   ? new FungibleTokenOfferContract(offerAddress, tokenId)
+    //   : undefined;
+    // const bidContractDeployment = bidAddress
+    //   ? new FungibleTokenBidContract(bidAddress)
+    //   : undefined;
+    const vk = tokenVerificationKeys[chain === "mainnet" ? "mainnet" : "devnet"].vk;
+    if (!vk ||
+        !vk.Collection ||
+        !vk.Collection.hash ||
+        !vk.Collection.data ||
+        !vk.AdvancedCollection ||
+        !vk.AdvancedCollection.hash ||
+        !vk.AdvancedCollection.data ||
+        !vk.NFT ||
+        !vk.NFT.hash ||
+        !vk.NFT.data ||
+        !vk.NFTAdmin ||
+        !vk.NFTAdmin.hash ||
+        !vk.NFTAdmin.data ||
+        !vk.NFTAdvancedAdmin ||
+        !vk.NFTAdvancedAdmin.hash ||
+        !vk.NFTAdvancedAdmin.data)
+        throw new Error("Cannot get verification key from vk");
+    // const offerVerificationKey = FungibleTokenOfferContract._verificationKey ?? {
+    //   hash: Field(vk.FungibleTokenOfferContract.hash),
+    //   data: vk.FungibleTokenOfferContract.data,
+    // };
+    // const bidVerificationKey = FungibleTokenBidContract._verificationKey ?? {
+    //   hash: Field(vk.FungibleTokenBidContract.hash),
+    //   data: vk.FungibleTokenBidContract.data,
+    // };
+    // const isNewBidOfferAccount =
+    //   txType === "token:offer:create" && offerAddress
+    //     ? !Mina.hasAccount(offerAddress, tokenId)
+    //     : txType === "token:bid:create" && bidAddress
+    //     ? !Mina.hasAccount(bidAddress)
+    //     : false;
+    // const isNewBuyAccount =
+    //   txType === "token:offer:buy" ? !Mina.hasAccount(sender, tokenId) : false;
+    // let isNewSellAccount: boolean = false;
+    // if (txType === "token:bid:sell") {
+    //   if (!bidAddress || !bidContract) throw new Error("Bid address is required");
+    //   await fetchMinaAccount({
+    //     publicKey: bidAddress,
+    //     force: true,
+    //   });
+    //   const buyer = bidContract.buyer.get();
+    //   await fetchMinaAccount({
+    //     publicKey: buyer,
+    //     tokenId,
+    //     force: false,
+    //   });
+    //   isNewSellAccount = !Mina.hasAccount(buyer, tokenId);
+    // }
+    // if (txType === "token:burn") {
+    //   await fetchMinaAccount({
+    //     publicKey: sender,
+    //     force: true,
+    //   });
+    //   await fetchMinaAccount({
+    //     publicKey: sender,
+    //     tokenId,
+    //     force: false,
+    //   });
+    //   if (!Mina.hasAccount(sender, tokenId))
+    //     throw new Error("Sender does not have tokens to burn");
+    // }
+    // const isNewTransferMintAccount =
+    //   (txType === "token:transfer" ||
+    //     txType === "token:airdrop" ||
+    //     txType === "token:mint") &&
+    //   to
+    //     ? !Mina.hasAccount(to, tokenId)
+    //     : false;
+    // const accountCreationFee =
+    //   (isNewBidOfferAccount ? 1_000_000_000 : 0) +
+    //   (isNewBuyAccount ? 1_000_000_000 : 0) +
+    //   (isNewSellAccount ? 1_000_000_000 : 0) +
+    //   (isNewTransferMintAccount ? 1_000_000_000 : 0) +
+    //   (isToNewAccount &&
+    //   txType === "token:mint" &&
+    //   adminType === "advanced" &&
+    //   advancedAdminContract.whitelist.get().isSome().toBoolean()
+    //     ? 1_000_000_000
+    //     : 0);
+    // console.log("accountCreationFee", accountCreationFee / 1_000_000_000);
+    // switch (txType) {
+    //   case "token:offer:buy":
+    //   case "token:offer:withdraw":
+    //   case "token:offer:whitelist":
+    //     if (offerContract === undefined)
+    //       throw new Error("Offer contract is required");
+    //     if (
+    //       Mina.getAccount(
+    //         offerContract.address,
+    //         tokenId
+    //       ).zkapp?.verificationKey?.hash.toJSON() !==
+    //       vk.FungibleTokenOfferContract.hash
+    //     )
+    //       throw new Error(
+    //         "Invalid offer verification key, offer contract has to be upgraded"
+    //       );
+    //     break;
+    // }
+    // switch (txType) {
+    //   case "token:bid:sell":
+    //   case "token:bid:withdraw":
+    //   case "token:bid:whitelist":
+    //     if (bidContract === undefined)
+    //       throw new Error("Bid contract is required");
+    //     if (
+    //       Mina.getAccount(
+    //         bidContract.address
+    //       ).zkapp?.verificationKey?.hash.toJSON() !==
+    //       vk.FungibleTokenBidContract.hash
+    //     )
+    //       throw new Error(
+    //         "Invalid bid verification key, bid contract has to be upgraded"
+    //       );
+    //     break;
+    // }
+    // switch (txType) {
+    //   case "token:mint":
+    //   case "token:burn":
+    //   case "token:redeem":
+    //   case "token:transfer":
+    //   case "token:airdrop":
+    //   case "token:offer:create":
+    //   case "token:bid:create":
+    //   case "token:offer:buy":
+    //   case "token:offer:withdraw":
+    //   case "token:bid:sell":
+    //     if (
+    //       Mina.getAccount(
+    //         zkToken.address
+    //       ).zkapp?.verificationKey?.hash.toJSON() !== vk.FungibleToken.hash
+    //     )
+    //       throw new Error(
+    //         "Invalid token verification key, token contract has to be upgraded"
+    //       );
+    //     break;
+    // }
+    const { name, ipfsHash, metadataRoot, privateMetadata, serializedMap } = typeof args.nftMintParams.metadata === "string"
+        ? {
+            name: args.nftMintParams.name,
+            ipfsHash: args.nftMintParams.storage,
+            metadataRoot: Field.fromJSON(args.nftMintParams.metadata),
+            privateMetadata: undefined,
+            serializedMap: undefined,
+        }
+        : await pinMetadata(Metadata.fromOpenApiJSON({ json: args.nftMintParams.metadata }));
+    if (ipfsHash === undefined)
+        throw new Error("storage is required, but not provided");
+    if (metadataRoot === undefined)
+        throw new Error("metadataRoot is required");
+    const slot = chain === "local"
+        ? Mina.currentSlot()
+        : chain === "zeko"
+            ? UInt32.zero
+            : (await fetchLastBlock()).globalSlotSinceGenesis;
+    const expiry = slot.add(UInt32.from(chain === "mainnet" || chain === "devnet" ? 20 : 100000));
+    const nftData = NFTData.new(args.nftMintParams.data);
+    if (!args.nftMintParams.address)
+        throw new Error("NFT address is required");
+    const mintParams = new MintParams({
+        name: fieldFromString(name),
+        address: PublicKey.fromBase58(args.nftMintParams.address),
+        tokenId: TokenId.derive(collectionAddress),
+        data: nftData,
+        fee: args.nftMintParams.fee
+            ? UInt64.from(Math.round(args.nftMintParams.fee * 1_000_000_000))
+            : UInt64.zero,
+        metadata: metadataRoot,
+        storage: Storage.fromString(ipfsHash),
+        metadataVerificationKeyHash: args.nftMintParams.metadataVerificationKeyHash
+            ? Field.fromJSON(args.nftMintParams.metadataVerificationKeyHash)
+            : Field(0),
+        expiry: args.nftMintParams.expiry
+            ? UInt32.from(Math.round(args.nftMintParams.expiry))
+            : expiry,
+    });
+    const accountCreationFee = 1_000_000_000;
+    const tx = await Mina.transaction({ sender, fee, memo, nonce }, async () => {
+        const feeAccountUpdate = AccountUpdate.createSigned(sender);
+        if (accountCreationFee > 0) {
+            feeAccountUpdate.balance.subInPlace(accountCreationFee);
+        }
+        if (provingKey && provingFee)
+            feeAccountUpdate.send({
+                to: provingKey,
+                amount: provingFee,
+            });
+        if (developerAddress && developerFee) {
+            feeAccountUpdate.send({
+                to: developerAddress,
+                amount: developerFee,
+            });
+        }
+        switch (txType) {
+            case "nft:mint":
+                await zkCollection.mintByCreator(mintParams);
+                break;
+            default:
+                throw new Error(`Unknown transaction type: ${txType}`);
+        }
+    });
+    return {
+        request: args,
+        tx,
+        adminType,
+        adminContractAddress,
+        symbol,
+        name,
+        verificationKeyHashes,
+        metadataRoot: metadataRoot.toJSON(),
+        privateMetadata,
+        storage: ipfsHash,
+        map: serializedMap,
+    };
+}
+export async function getNftSymbolAndAdmin(params) {
+    const { txType, collectionAddress, chain, nftAddress } = params;
+    const vk = tokenVerificationKeys[chain === "mainnet" ? "mainnet" : "devnet"].vk;
+    let verificationKeyHashes = [];
+    // if (bidAddress) {
+    //   verificationKeyHashes.push(vk.FungibleTokenBidContract.hash);
+    // }
+    // if (offerAddress) {
+    //   verificationKeyHashes.push(vk.FungibleTokenOfferContract.hash);
+    // }
+    await fetchMinaAccount({ publicKey: collectionAddress, force: true });
+    if (!Mina.hasAccount(collectionAddress)) {
+        throw new Error("Collection contract account not found");
+    }
+    const tokenId = TokenId.derive(collectionAddress);
+    if (nftAddress) {
+        await fetchMinaAccount({
+            publicKey: nftAddress,
+            tokenId,
+            force: true,
+        });
+        if (!Mina.hasAccount(nftAddress, tokenId)) {
+            throw new Error("NFT account not found");
+        }
+    }
+    const account = Mina.getAccount(collectionAddress);
+    const verificationKey = account.zkapp?.verificationKey;
+    if (!verificationKey) {
+        throw new Error("Collection contract verification key not found");
+    }
+    if (!verificationKeyHashes.includes(verificationKey.hash.toJSON())) {
+        verificationKeyHashes.push(verificationKey.hash.toJSON());
+    }
+    if (account.zkapp?.appState === undefined) {
+        throw new Error("Collection contract state not found");
+    }
+    const collection = new Collection(collectionAddress);
+    const symbol = account.tokenSymbol;
+    const adminContractPublicKey = collection.admin.get();
+    await fetchMinaAccount({
+        publicKey: adminContractPublicKey,
+        force: true,
+    });
+    if (!Mina.hasAccount(adminContractPublicKey)) {
+        throw new Error("Admin contract account not found");
+    }
+    const adminContract = Mina.getAccount(adminContractPublicKey);
+    const adminVerificationKey = adminContract.zkapp?.verificationKey;
+    if (!adminVerificationKey) {
+        throw new Error("Admin verification key not found");
+    }
+    if (!verificationKeyHashes.includes(adminVerificationKey.hash.toJSON())) {
+        verificationKeyHashes.push(adminVerificationKey.hash.toJSON());
+    }
+    let adminType = "unknown";
+    if (vk.FungibleTokenAdvancedAdmin.hash === adminVerificationKey.hash.toJSON() &&
+        vk.FungibleTokenAdvancedAdmin.data === adminVerificationKey.data) {
+        adminType = "advanced";
+    }
+    else if (vk.FungibleTokenAdmin.hash === adminVerificationKey.hash.toJSON() &&
+        vk.FungibleTokenAdmin.data === adminVerificationKey.data) {
+        adminType = "standard";
+    }
+    else {
+        console.error("Unknown admin verification key", {
+            hash: adminVerificationKey.hash.toJSON(),
+            symbol,
+            address: adminContractPublicKey.toBase58(),
+        });
+    }
+    // let isToNewAccount: boolean | undefined = undefined;
+    // if (to) {
+    //   if (adminType === "advanced") {
+    //     const adminTokenId = TokenId.derive(adminContractPublicKey);
+    //     await fetchMinaAccount({
+    //       publicKey: to,
+    //       tokenId: adminTokenId,
+    //       force: false,
+    //     });
+    //     isToNewAccount = !Mina.hasAccount(to, adminTokenId);
+    //   }
+    //   if (adminType === "bondingCurve") {
+    //     const adminTokenId = TokenId.derive(adminContractPublicKey);
+    //     await fetchMinaAccount({
+    //       publicKey: adminContractPublicKey,
+    //       tokenId: adminTokenId,
+    //       force: true,
+    //     });
+    //   }
+    // }
+    // const adminAddress0 = adminContract.zkapp?.appState[0];
+    // const adminAddress1 = adminContract.zkapp?.appState[1];
+    // if (adminAddress0 === undefined || adminAddress1 === undefined) {
+    //   throw new Error("Cannot fetch admin address from admin contract");
+    // }
+    // const adminAddress = PublicKey.fromFields([adminAddress0, adminAddress1]);
+    for (const hash of verificationKeyHashes) {
+        const found = Object.values(vk).some((key) => key.hash === hash);
+        if (!found) {
+            console.error(`Final check: unknown verification key hash: ${hash}`);
+            verificationKeyHashes = verificationKeyHashes.filter((h) => h !== hash);
+        }
+    }
+    // Sort verification key hashes by type
+    verificationKeyHashes.sort((a, b) => {
+        const typeA = Object.values(vk).find((key) => key.hash === a)?.type;
+        const typeB = Object.values(vk).find((key) => key.hash === b)?.type;
+        if (typeA === undefined || typeB === undefined) {
+            throw new Error("Unknown verification key hash");
+        }
+        const typeOrder = {
+            upgrade: 0,
+            nft: 1,
+            admin: 2,
+            collection: 3,
+            token: 4,
+            user: 5,
+        };
+        return typeOrder[typeA] - typeOrder[typeB];
+    });
+    return {
+        adminContractAddress: adminContractPublicKey,
+        symbol,
+        adminType,
+        verificationKeyHashes,
+    };
+}
+//# sourceMappingURL=build.js.map