@silvana-one/abi 0.1.2 → 0.1.3

package/dist/node/{token/contracts.d.ts → compile.d.ts}

@@ -1,6 +1,6 @@
 import { Cache, Field } from "o1js";
 export type Compilable = {
-    compile({ cache }?: {
+    compile(options?: {
         cache: Cache;
     }): Promise<{
         verificationKey: {
@@ -9,7 +9,6 @@ export type Compilable = {
         };
     }>;
 };
-export declare const tokenContracts: Record<string, Compilable>;
 export type CompileDependencies = Record<
 /** Transaction type */
 string, 

package/dist/node/compile.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compile.js.map

package/dist/node/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","sourceRoot":"","sources":["../../src/compile.ts"],"names":[],"mappings":""}

package/dist/node/contracts.d.ts

@@ -1,17 +1,2 @@
-import { Cache, Field } from "o1js";
-export type Compilable = {
-    compile({ cache }?: {
-        cache: Cache;
-    }): Promise<{
-        verificationKey: {
-            data: string;
-            hash: Field;
-        };
-    }>;
-};
-export type CompileDependencies = Record<
-/** Transaction type */
-string, 
-/** List of contract names */
-string[]>;
+import { Compilable } from "./compile.js";
 export declare const contractList: Record<string, Compilable>;

package/dist/node/contracts.js

@@ -10,8 +10,8 @@ export const contractList = {
     FungibleTokenOfferContract: FungibleTokenOfferContract,
     FungibleTokenClaimContract: FungibleTokenClaimContract,
     NFT: NFT,
-    Collection: Collection, // TODO: better type
-    AdvancedCollection: AdvancedCollection, // TODO: better type
+    Collection: Collection,
+    AdvancedCollection: AdvancedCollection,
     NFTAdmin: NFTAdmin,
     NFTAdvancedAdmin: NFTAdvancedAdmin,
     VerificationKeyUpgradeAuthority: VerificationKeyUpgradeAuthority,

package/dist/node/contracts.js.map

@@ -1 +1 @@
-{"version":3,"file":"contracts.js","sourceRoot":"","sources":["../../src/contracts.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,EACxB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,GAAG,EACH,UAAU,EACV,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAkB1E,MAAM,CAAC,MAAM,YAAY,GAA+B;IACtD,aAAa,EAAE,aAAa;IAC5B,kBAAkB,EAAE,kBAAkB;IACtC,qBAAqB,EAAE,qBAAqB;IAC5C,0BAA0B,EAAE,0BAA0B;IACtD,wBAAwB,EAAE,wBAAwB;IAClD,0BAA0B,EAAE,0BAA0B;IACtD,0BAA0B,EAAE,0BAA0B;IACtD,GAAG,EAAE,GAAG;IACR,UAAU,EAAE,UAAmC,EAAE,oBAAoB;IACrE,kBAAkB,EAAE,kBAA2C,EAAE,oBAAoB;IACrF,QAAQ,EAAE,QAAQ;IAClB,gBAAgB,EAAE,gBAAgB;IAClC,+BAA+B,EAAE,+BAA+B;CACjE,CAAC"}
+{"version":3,"file":"contracts.js","sourceRoot":"","sources":["../../src/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,EACxB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,GAAG,EACH,UAAU,EACV,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAG1E,MAAM,CAAC,MAAM,YAAY,GAA+B;IACtD,aAAa,EAAE,aAAa;IAC5B,kBAAkB,EAAE,kBAAkB;IACtC,qBAAqB,EAAE,qBAAqB;IAC5C,0BAA0B,EAAE,0BAA0B;IACtD,wBAAwB,EAAE,wBAAwB;IAClD,0BAA0B,EAAE,0BAA0B;IACtD,0BAA0B,EAAE,0BAA0B;IACtD,GAAG,EAAE,GAAG;IACR,UAAU,EAAE,UAAU;IACtB,kBAAkB,EAAE,kBAAkB;IACtC,QAAQ,EAAE,QAAQ;IAClB,gBAAgB,EAAE,gBAAgB;IAClC,+BAA+B,EAAE,+BAA+B;CACjE,CAAC"}

package/dist/node/index.cjs

@@ -22,16 +22,19 @@ var index_exports = {};
 __export(index_exports, {
   LAUNCH_FEE: () => LAUNCH_FEE,
   TRANSACTION_FEE: () => TRANSACTION_FEE,
+  buildNftCollectionLaunchTransaction: () => buildNftCollectionLaunchTransaction,
+  buildNftTransaction: () => buildNftTransaction,
   buildTokenLaunchTransaction: () => buildTokenLaunchTransaction,
   buildTokenTransaction: () => buildTokenTransaction,
   checkAddress: () => checkAddress,
+  contractList: () => contractList,
   devnet: () => devnet,
   fetchMinaAccount: () => fetchMinaAccount,
   getContractInfo: () => getContractInfo,
+  getNftSymbolAndAdmin: () => getNftSymbolAndAdmin,
   getTokenSymbolAndAdmin: () => getTokenSymbolAndAdmin,
   mainnet: () => mainnet,
   tokenBalance: () => tokenBalance,
-  tokenContracts: () => tokenContracts,
   tokenVerificationKeys: () => tokenVerificationKeys
 });
 module.exports = __toCommonJS(index_exports);
@@ -900,20 +903,6 @@ async function getTokenSymbolAndAdmin(params) {
   };
 }
 
-// dist/node/token/contracts.js
-var import_token2 = require("@silvana-one/token");
-var tokenContracts = {
-  FungibleToken: import_token2.FungibleToken,
-  FungibleTokenAdmin: import_token2.FungibleTokenAdmin,
-  AdvancedFungibleToken: import_token2.AdvancedFungibleToken,
-  BondingCurveFungibleToken: import_token2.BondingCurveFungibleToken,
-  FungibleTokenAdvancedAdmin: import_token2.FungibleTokenAdvancedAdmin,
-  FungibleTokenBondingCurveAdmin: import_token2.FungibleTokenBondingCurveAdmin,
-  FungibleTokenBidContract: import_token2.FungibleTokenBidContract,
-  FungibleTokenOfferContract: import_token2.FungibleTokenOfferContract,
-  FungibleTokenClaimContract: import_token2.FungibleTokenClaimContract
-};
-
 // dist/node/token/info.js
 var import_o1js4 = require("o1js");
 
@@ -938,7 +927,7 @@ async function checkAddress(address) {
 }
 
 // dist/node/token/info.js
-var import_token3 = require("@silvana-one/token");
+var import_token2 = require("@silvana-one/token");
 async function getContractInfo(params) {
   const { address, chain, parentTokenId, decimals } = params;
   const vk = tokenVerificationKeys[chain].vk;
@@ -988,7 +977,7 @@ async function getContractInfo(params) {
     case "FungibleToken":
     case "AdvancedFungibleToken":
       {
-        const zkApp = new import_token3.FungibleToken(publicKey, tokenId);
+        const zkApp = new import_token2.FungibleToken(publicKey, tokenId);
         const admin = zkApp.admin.get();
         const decimals2 = zkApp.decimals.get();
         const paused = zkApp.paused.get();
@@ -1103,19 +1092,410 @@ async function tokenBalance(params) {
     };
   }
 }
+
+// dist/node/nft/build.js
+var import_storage2 = require("@silvana-one/storage");
+var import_nft = require("@silvana-one/nft");
+var import_o1js5 = require("o1js");
+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 === void 0) {
+    throw new Error("masterNFT is required");
+  }
+  if (masterNFT.metadata === void 0) {
+    throw new Error("masterNFT.metadata is required");
+  }
+  if (typeof masterNFT.metadata === "string" && masterNFT.storage === void 0) {
+    throw new Error("masterNFT.storage is required if metadata is a string");
+  }
+  const sender = import_o1js5.PublicKey.fromBase58(args.sender);
+  if (nonce === void 0)
+    throw new Error("Nonce is required");
+  if (typeof nonce !== "number")
+    throw new Error("Nonce must be a number");
+  const fee = 1e8;
+  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" ? import_nft.NFTAdvancedAdmin : import_nft.NFTAdmin;
+  const collectionContract = adminType === "advanced" ? import_nft.AdvancedCollection : import_nft.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.AdvancedCollection : vk.Collection;
+  if (!adminVerificationKey || !collectionVerificationKey)
+    throw new Error("Cannot get verification keys");
+  await fetchMinaAccount({
+    publicKey: sender,
+    force: true
+  });
+  if (!import_o1js5.Mina.hasAccount(sender)) {
+    throw new Error("Sender does not have account");
+  }
+  const whitelist = "whitelist" in args && args.whitelist ? typeof args.whitelist === "string" ? import_storage2.Whitelist.fromString(args.whitelist) : (await import_storage2.Whitelist.create({ list: args.whitelist, name: symbol })).whitelist : import_storage2.Whitelist.empty();
+  const collectionAddress = import_o1js5.PublicKey.fromBase58(args.collectionAddress);
+  const adminContractAddress = import_o1js5.PublicKey.fromBase58(args.adminContractAddress);
+  const creator = args.creator ? import_o1js5.PublicKey.fromBase58(args.creator) : sender;
+  const zkCollection = new collectionContract(collectionAddress);
+  const zkAdmin = new adminContract(adminContractAddress);
+  const metadataVerificationKeyHash = masterNFT.metadataVerificationKeyHash ? import_o1js5.Field.fromJSON(masterNFT.metadataVerificationKeyHash) : (0, import_o1js5.Field)(0);
+  const provingKey = params.provingKey ? import_o1js5.PublicKey.fromBase58(params.provingKey) : sender;
+  const provingFee = params.provingFee ? import_o1js5.UInt64.from(Math.round(params.provingFee)) : void 0;
+  const developerFee = args.developerFee ? import_o1js5.UInt64.from(Math.round(args.developerFee)) : void 0;
+  const developerAddress = params.developerAddress ? import_o1js5.PublicKey.fromBase58(params.developerAddress) : void 0;
+  const { name, ipfsHash, metadataRoot, privateMetadata, serializedMap } = typeof masterNFT.metadata === "string" ? {
+    name: masterNFT.name,
+    ipfsHash: masterNFT.storage,
+    metadataRoot: import_o1js5.Field.fromJSON(masterNFT.metadata),
+    privateMetadata: void 0,
+    serializedMap: void 0
+  } : await (0, import_nft.pinMetadata)(import_nft.Metadata.fromOpenApiJSON({ json: masterNFT.metadata }));
+  if (ipfsHash === void 0)
+    throw new Error("storage is required, but not provided");
+  if (metadataRoot === void 0)
+    throw new Error("metadataRoot is required");
+  const slot = chain === "local" ? import_o1js5.Mina.currentSlot() : chain === "zeko" ? import_o1js5.UInt32.zero : (await (0, import_o1js5.fetchLastBlock)()).globalSlotSinceGenesis;
+  const expiry = slot.add(import_o1js5.UInt32.from(chain === "mainnet" || chain === "devnet" ? 20 : 1e5));
+  const nftData = import_nft.NFTData.new({
+    owner: creator,
+    approved: void 0,
+    version: void 0,
+    id: masterNFT.data.id ? BigInt(masterNFT.data.id) : void 0,
+    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 import_nft.MintParams({
+    name: (0, import_nft.fieldFromString)(name),
+    address: collectionAddress,
+    tokenId: import_o1js5.TokenId.derive(collectionAddress),
+    data: nftData,
+    fee: args.masterNFT.fee ? import_o1js5.UInt64.from(Math.round(args.masterNFT.fee * 1e9)) : import_o1js5.UInt64.zero,
+    metadata: metadataRoot,
+    storage: import_storage2.Storage.fromString(ipfsHash),
+    metadataVerificationKeyHash,
+    expiry: masterNFT.expiry ? import_o1js5.UInt32.from(Math.round(masterNFT.expiry)) : expiry
+  });
+  const collectionData = import_nft.CollectionData.new(args.collectionData ?? {});
+  const tx = await import_o1js5.Mina.transaction({
+    sender,
+    fee,
+    memo: memo ?? `${args.collectionName} NFT collection launch`.substring(0, 30),
+    nonce
+  }, async () => {
+    const feeAccountUpdate = import_o1js5.AccountUpdate.createSigned(sender);
+    feeAccountUpdate.balance.subInPlace(3e9);
+    if (provingFee && provingKey)
+      feeAccountUpdate.send({
+        to: provingKey,
+        amount: provingFee
+      });
+    if (developerAddress && developerFee) {
+      feeAccountUpdate.send({
+        to: developerAddress,
+        amount: developerFee
+      });
+    }
+    if (zkAdmin instanceof import_nft.NFTAdvancedAdmin) {
+      throw new Error("Advanced admin is not supported");
+    } else if (zkAdmin instanceof import_nft.NFTAdmin) {
+      await zkAdmin.deploy({
+        admin: sender,
+        uri: `NFT Admin`,
+        verificationKey: adminVerificationKey
+      });
+      await zkCollection.deploy({
+        creator,
+        collectionName: (0, import_nft.fieldFromString)(args.collectionName),
+        baseURL: (0, import_nft.fieldFromString)(args.baseURL ?? "ipfs"),
+        admin: adminContractAddress,
+        symbol,
+        url,
+        verificationKey: collectionVerificationKey
+      });
+      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
+  };
+}
+async function buildNftTransaction(params) {
+  const { chain, args } = params;
+  const { nonce, txType } = args;
+  if (nonce === void 0)
+    throw new Error("Nonce is required");
+  if (typeof nonce !== "number")
+    throw new Error("Nonce must be a number");
+  if (txType === void 0)
+    throw new Error("Tx type is required");
+  if (typeof txType !== "string")
+    throw new Error("Tx type must be a string");
+  const sender = import_o1js5.PublicKey.fromBase58(args.sender);
+  const collectionAddress = import_o1js5.PublicKey.fromBase58(args.collectionAddress);
+  if (args.nftMintParams.address === void 0) {
+    throw new Error("NFT address is required");
+  }
+  const nftAddress = import_o1js5.PublicKey.fromBase58(args.nftMintParams.address);
+  await fetchMinaAccount({
+    publicKey: sender,
+    force: true
+  });
+  if (!import_o1js5.Mina.hasAccount(sender)) {
+    throw new Error("Sender does not have account");
+  }
+  const { symbol, adminContractAddress, adminType, verificationKeyHashes } = await getNftSymbolAndAdmin({
+    txType,
+    collectionAddress,
+    chain,
+    nftAddress: void 0
+    // TODO: add nft address
+  });
+  const memo = args.memo ?? `${txType} ${symbol} ${args.nftMintParams.name}`;
+  const fee = 1e8;
+  const provingKey = params.provingKey ? import_o1js5.PublicKey.fromBase58(params.provingKey) : sender;
+  const provingFee = params.provingFee ? import_o1js5.UInt64.from(Math.round(params.provingFee)) : void 0;
+  const developerFee = args.developerFee ? import_o1js5.UInt64.from(Math.round(args.developerFee)) : void 0;
+  const developerAddress = params.developerAddress ? import_o1js5.PublicKey.fromBase58(params.developerAddress) : void 0;
+  const advancedAdminContract = new import_nft.NFTAdvancedAdmin(adminContractAddress);
+  const adminContract = new import_nft.NFTAdmin(adminContractAddress);
+  const collectionContract = adminType === "advanced" ? import_nft.AdvancedCollection : import_nft.Collection;
+  const zkCollection = new collectionContract(collectionAddress);
+  const tokenId = zkCollection.deriveTokenId();
+  await fetchMinaAccount({
+    publicKey: nftAddress,
+    tokenId,
+    force: ["nft:transfer"].includes(txType)
+  });
+  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 { name, ipfsHash, metadataRoot, privateMetadata, serializedMap } = typeof args.nftMintParams.metadata === "string" ? {
+    name: args.nftMintParams.name,
+    ipfsHash: args.nftMintParams.storage,
+    metadataRoot: import_o1js5.Field.fromJSON(args.nftMintParams.metadata),
+    privateMetadata: void 0,
+    serializedMap: void 0
+  } : await (0, import_nft.pinMetadata)(import_nft.Metadata.fromOpenApiJSON({ json: args.nftMintParams.metadata }));
+  if (ipfsHash === void 0)
+    throw new Error("storage is required, but not provided");
+  if (metadataRoot === void 0)
+    throw new Error("metadataRoot is required");
+  const slot = chain === "local" ? import_o1js5.Mina.currentSlot() : chain === "zeko" ? import_o1js5.UInt32.zero : (await (0, import_o1js5.fetchLastBlock)()).globalSlotSinceGenesis;
+  const expiry = slot.add(import_o1js5.UInt32.from(chain === "mainnet" || chain === "devnet" ? 20 : 1e5));
+  const nftData = import_nft.NFTData.new(args.nftMintParams.data);
+  if (!args.nftMintParams.address)
+    throw new Error("NFT address is required");
+  const mintParams = new import_nft.MintParams({
+    name: (0, import_nft.fieldFromString)(name),
+    address: import_o1js5.PublicKey.fromBase58(args.nftMintParams.address),
+    tokenId: import_o1js5.TokenId.derive(collectionAddress),
+    data: nftData,
+    fee: args.nftMintParams.fee ? import_o1js5.UInt64.from(Math.round(args.nftMintParams.fee * 1e9)) : import_o1js5.UInt64.zero,
+    metadata: metadataRoot,
+    storage: import_storage2.Storage.fromString(ipfsHash),
+    metadataVerificationKeyHash: args.nftMintParams.metadataVerificationKeyHash ? import_o1js5.Field.fromJSON(args.nftMintParams.metadataVerificationKeyHash) : (0, import_o1js5.Field)(0),
+    expiry: args.nftMintParams.expiry ? import_o1js5.UInt32.from(Math.round(args.nftMintParams.expiry)) : expiry
+  });
+  const accountCreationFee = 0;
+  const tx = await import_o1js5.Mina.transaction({ sender, fee, memo, nonce }, async () => {
+    const feeAccountUpdate = import_o1js5.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
+  };
+}
+async function getNftSymbolAndAdmin(params) {
+  const { txType, collectionAddress, chain, nftAddress } = params;
+  const vk = tokenVerificationKeys[chain === "mainnet" ? "mainnet" : "devnet"].vk;
+  let verificationKeyHashes = [];
+  await fetchMinaAccount({ publicKey: collectionAddress, force: true });
+  if (!import_o1js5.Mina.hasAccount(collectionAddress)) {
+    throw new Error("Collection contract account not found");
+  }
+  const tokenId = import_o1js5.TokenId.derive(collectionAddress);
+  if (nftAddress) {
+    await fetchMinaAccount({
+      publicKey: nftAddress,
+      tokenId,
+      force: true
+    });
+    if (!import_o1js5.Mina.hasAccount(nftAddress, tokenId)) {
+      throw new Error("NFT account not found");
+    }
+  }
+  const account = import_o1js5.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 === void 0) {
+    throw new Error("Collection contract state not found");
+  }
+  const collection = new import_nft.Collection(collectionAddress);
+  const symbol = account.tokenSymbol;
+  const adminContractPublicKey = collection.admin.get();
+  await fetchMinaAccount({
+    publicKey: adminContractPublicKey,
+    force: true
+  });
+  if (!import_o1js5.Mina.hasAccount(adminContractPublicKey)) {
+    throw new Error("Admin contract account not found");
+  }
+  const adminContract = import_o1js5.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.NFTAdvancedAdmin.hash === adminVerificationKey.hash.toJSON() && vk.NFTAdvancedAdmin.data === adminVerificationKey.data) {
+    adminType = "advanced";
+  } else if (vk.NFTAdmin.hash === adminVerificationKey.hash.toJSON() && vk.NFTAdmin.data === adminVerificationKey.data) {
+    adminType = "standard";
+  } else {
+    console.error("Unknown admin verification key", {
+      hash: adminVerificationKey.hash.toJSON(),
+      symbol,
+      address: adminContractPublicKey.toBase58()
+    });
+  }
+  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);
+    }
+  }
+  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 === void 0 || typeB === void 0) {
+      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
+  };
+}
+
+// dist/node/contracts.js
+var import_token3 = require("@silvana-one/token");
+var import_nft2 = require("@silvana-one/nft");
+var import_upgradable = require("@silvana-one/upgradable");
+var contractList = {
+  FungibleToken: import_token3.FungibleToken,
+  FungibleTokenAdmin: import_token3.FungibleTokenAdmin,
+  AdvancedFungibleToken: import_token3.AdvancedFungibleToken,
+  FungibleTokenAdvancedAdmin: import_token3.FungibleTokenAdvancedAdmin,
+  FungibleTokenBidContract: import_token3.FungibleTokenBidContract,
+  FungibleTokenOfferContract: import_token3.FungibleTokenOfferContract,
+  FungibleTokenClaimContract: import_token3.FungibleTokenClaimContract,
+  NFT: import_nft2.NFT,
+  Collection: import_nft2.Collection,
+  AdvancedCollection: import_nft2.AdvancedCollection,
+  NFTAdmin: import_nft2.NFTAdmin,
+  NFTAdvancedAdmin: import_nft2.NFTAdvancedAdmin,
+  VerificationKeyUpgradeAuthority: import_upgradable.VerificationKeyUpgradeAuthority
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LAUNCH_FEE,
   TRANSACTION_FEE,
+  buildNftCollectionLaunchTransaction,
+  buildNftTransaction,
   buildTokenLaunchTransaction,
   buildTokenTransaction,
   checkAddress,
+  contractList,
   devnet,
   fetchMinaAccount,
   getContractInfo,
+  getNftSymbolAndAdmin,
   getTokenSymbolAndAdmin,
   mainnet,
   tokenBalance,
-  tokenContracts,
   tokenVerificationKeys
 });

package/dist/node/index.d.ts

@@ -4,3 +4,5 @@ export * from "./types.js";
 export * from "./fetch.js";
 export * from "./vk/index.js";
 export * from "./info/index.js";
+export * from "./nft/index.js";
+export * from "./contracts.js";

package/dist/node/index.js

@@ -4,4 +4,6 @@ export * from "./types.js";
 export * from "./fetch.js";
 export * from "./vk/index.js";
 export * from "./info/index.js";
+export * from "./nft/index.js";
+export * from "./contracts.js";
 //# sourceMappingURL=index.js.map

package/dist/node/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC"}

package/dist/node/nft/build.js

@@ -60,7 +60,7 @@ export async function buildNftCollectionLaunchTransaction(params) {
         !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;
+    const collectionVerificationKey = adminType === "advanced" ? vk.AdvancedCollection : vk.Collection;
     if (!adminVerificationKey || !collectionVerificationKey)
         throw new Error("Cannot get verification keys");
     await fetchMinaAccount({
@@ -173,6 +173,7 @@ export async function buildNftCollectionLaunchTransaction(params) {
             await zkAdmin.deploy({
                 admin: sender,
                 uri: `NFT Admin`,
+                verificationKey: adminVerificationKey,
             });
             // deploy() and initialize() create 2 account updates for the same publicKey, it is intended
             await zkCollection.deploy({
@@ -182,6 +183,7 @@ export async function buildNftCollectionLaunchTransaction(params) {
                 admin: adminContractAddress,
                 symbol,
                 url,
+                verificationKey: collectionVerificationKey,
             });
             await zkCollection.initialize(mintParams, collectionData);
         }
@@ -555,7 +557,7 @@ export async function buildNftTransaction(params) {
             ? UInt32.from(Math.round(args.nftMintParams.expiry))
             : expiry,
     });
-    const accountCreationFee = 1_000_000_000;
+    const accountCreationFee = 0;
     const tx = await Mina.transaction({ sender, fee, memo, nonce }, async () => {
         const feeAccountUpdate = AccountUpdate.createSigned(sender);
         if (accountCreationFee > 0) {
@@ -649,12 +651,12 @@ export async function getNftSymbolAndAdmin(params) {
         verificationKeyHashes.push(adminVerificationKey.hash.toJSON());
     }
     let adminType = "unknown";
-    if (vk.FungibleTokenAdvancedAdmin.hash === adminVerificationKey.hash.toJSON() &&
-        vk.FungibleTokenAdvancedAdmin.data === adminVerificationKey.data) {
+    if (vk.NFTAdvancedAdmin.hash === adminVerificationKey.hash.toJSON() &&
+        vk.NFTAdvancedAdmin.data === adminVerificationKey.data) {
         adminType = "advanced";
     }
-    else if (vk.FungibleTokenAdmin.hash === adminVerificationKey.hash.toJSON() &&
-        vk.FungibleTokenAdmin.data === adminVerificationKey.data) {
+    else if (vk.NFTAdmin.hash === adminVerificationKey.hash.toJSON() &&
+        vk.NFTAdmin.data === adminVerificationKey.data) {
         adminType = "standard";
     }
     else {