@silvana-one/abi 0.1.18 → 0.1.20

package/dist/node/index.cjs

@@ -23,6 +23,7 @@ __export(index_exports, {
   LAUNCH_FEE: () => LAUNCH_FEE,
   TRANSACTION_FEE: () => TRANSACTION_FEE,
   buildNftCollectionLaunchTransaction: () => buildNftCollectionLaunchTransaction,
+  buildNftMintTransaction: () => buildNftMintTransaction,
   buildNftTransaction: () => buildNftTransaction,
   buildTokenLaunchTransaction: () => buildTokenLaunchTransaction,
   buildTokenTransaction: () => buildTokenTransaction,
@@ -1259,6 +1260,142 @@ async function buildNftCollectionLaunchTransaction(params) {
   };
 }
 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");
+  if (args.sender === void 0 || typeof args.sender !== "string")
+    throw new Error("Sender is required");
+  if (args.collectionAddress === void 0 || typeof args.collectionAddress !== "string")
+    throw new Error("Collection address is required");
+  if (args.nftAddress === void 0 || typeof args.nftAddress !== "string")
+    throw new Error("NFT address is required");
+  const sender = import_o1js5.PublicKey.fromBase58(args.sender);
+  const collectionAddress = import_o1js5.PublicKey.fromBase58(args.collectionAddress);
+  if (txType === "nft:transfer" && args.nftTransferParams === void 0) {
+    throw new Error("NFT transfer params are required");
+  }
+  if (txType === "nft:sell" && args.nftSellParams === void 0) {
+    throw new Error("NFT sell params are required");
+  }
+  if (txType === "nft:buy" && args.nftBuyParams === void 0) {
+    throw new Error("NFT buy params are required");
+  }
+  const nftAddress = import_o1js5.PublicKey.fromBase58(args.nftAddress);
+  const to = "nftTransferParams" in args && args.nftTransferParams && args.nftTransferParams.to && typeof args.nftTransferParams.to === "string" ? import_o1js5.PublicKey.fromBase58(args.nftTransferParams.to) : void 0;
+  if (!to && txType === "nft:transfer")
+    throw new Error("To address is required");
+  let buyer = "nftBuyParams" in args && args.nftBuyParams && args.nftBuyParams.buyer && typeof args.nftBuyParams.buyer === "string" ? import_o1js5.PublicKey.fromBase58(args.nftBuyParams.buyer) : void 0;
+  if (!buyer && txType === "nft:buy")
+    buyer = sender;
+  const from = "nftTransferParams" in args && args.nftTransferParams && args.nftTransferParams.from && typeof args.nftTransferParams.from === "string" ? import_o1js5.PublicKey.fromBase58(args.nftTransferParams.from) : void 0;
+  if (!from && txType === "nft:transfer")
+    throw new Error("From address is required for nft:transfer");
+  const price = "nftSellParams" in args ? args.nftSellParams && args.nftSellParams.price && typeof args.nftSellParams.price === "number" ? import_o1js5.UInt64.from(Math.round(args.nftSellParams.price * 1e9)) : void 0 : "nftTransferParams" in args && args.nftTransferParams && args.nftTransferParams.price && typeof args.nftTransferParams.price === "number" ? import_o1js5.UInt64.from(Math.round(args.nftTransferParams.price * 1e9)) : void 0;
+  if (price === void 0 && txType === "nft:sell")
+    throw new Error("Price is required for nft:sell");
+  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, collectionName, nftName, storage, metadataRoot } = await getNftSymbolAndAdmin({
+    txType,
+    collectionAddress,
+    chain,
+    nftAddress
+  });
+  if (storage === void 0)
+    throw new Error("storage is required, but not provided");
+  if (metadataRoot === void 0)
+    throw new Error("metadataRoot is required");
+  if (nftName === void 0)
+    throw new Error("nftName is required");
+  const memo = args.memo ?? `${txType.split(":")[1]} ${symbol} ${nftName}`;
+  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();
+  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 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:transfer":
+        if (!from || !to)
+          throw new Error("From and to are required for nft:transfer");
+        const context = args.nftTransferParams?.context?.custom ? new import_nft.NFTTransactionContext({
+          custom: args.nftTransferParams.context.custom.map((x) => import_o1js5.Field.fromJSON(x))
+        }) : new import_nft.NFTTransactionContext({
+          custom: [(0, import_o1js5.Field)(0), (0, import_o1js5.Field)(0), (0, import_o1js5.Field)(0)]
+        });
+        const transferParams = {
+          address: nftAddress,
+          from,
+          to,
+          price: price ? import_nft.UInt64Option.from(price) : import_nft.UInt64Option.none(),
+          context
+        };
+        if (args.nftTransferParams.requireApproval === true)
+          await zkCollection.approvedTransferBySignature(transferParams);
+        else
+          await zkCollection.transferBySignature(transferParams);
+        break;
+      case "nft:approve":
+        if (!to)
+          throw new Error("To address is required for nft:approve");
+        await zkCollection.approveAddress(nftAddress, to);
+        break;
+      default:
+        throw new Error(`Unknown transaction type: ${txType}`);
+    }
+  });
+  return {
+    request: args,
+    tx,
+    adminType,
+    adminContractAddress,
+    symbol,
+    collectionName,
+    nftName,
+    verificationKeyHashes,
+    metadataRoot,
+    privateMetadata: void 0,
+    storage,
+    map: void 0
+  };
+}
+async function buildNftMintTransaction(params) {
   const { chain, args } = params;
   const { nonce, txType } = args;
   if (nonce === void 0)
@@ -1380,6 +1517,9 @@ async function getNftSymbolAndAdmin(params) {
   const { txType, collectionAddress, chain, nftAddress } = params;
   const vk = tokenVerificationKeys[chain === "mainnet" ? "mainnet" : "devnet"].vk;
   let verificationKeyHashes = [];
+  let nftName = void 0;
+  let storage = void 0;
+  let metadataRoot = void 0;
   await fetchMinaAccount({ publicKey: collectionAddress, force: true });
   if (!import_o1js5.Mina.hasAccount(collectionAddress)) {
     throw new Error("Collection contract account not found");
@@ -1394,6 +1534,21 @@ async function getNftSymbolAndAdmin(params) {
     if (!import_o1js5.Mina.hasAccount(nftAddress, tokenId)) {
       throw new Error("NFT account not found");
     }
+    const nftAccount = import_o1js5.Mina.getAccount(nftAddress, tokenId);
+    const verificationKey2 = nftAccount.zkapp?.verificationKey;
+    if (!verificationKey2) {
+      throw new Error("NFT contract verification key not found");
+    }
+    if (!verificationKeyHashes.includes(verificationKey2.hash.toJSON())) {
+      verificationKeyHashes.push(verificationKey2.hash.toJSON());
+    }
+    if (nftAccount.zkapp?.appState === void 0) {
+      throw new Error("NFT contract state not found");
+    }
+    const nft = new import_nft.NFT(nftAddress, tokenId);
+    nftName = (0, import_nft.fieldToString)(nft.name.get());
+    storage = nft.storage.get().toString();
+    metadataRoot = nft.metadata.get().toJSON();
   }
   const account = import_o1js5.Mina.getAccount(collectionAddress);
   const verificationKey = account.zkapp?.verificationKey;
@@ -1465,7 +1620,10 @@ async function getNftSymbolAndAdmin(params) {
     symbol,
     collectionName,
     adminType,
-    verificationKeyHashes
+    verificationKeyHashes,
+    nftName,
+    storage,
+    metadataRoot
   };
 }
 
@@ -1495,6 +1653,7 @@ var contractList = {
   LAUNCH_FEE,
   TRANSACTION_FEE,
   buildNftCollectionLaunchTransaction,
+  buildNftMintTransaction,
   buildNftTransaction,
   buildTokenLaunchTransaction,
   buildTokenTransaction,

package/dist/node/nft/build.d.ts

@@ -1,5 +1,5 @@
 import { IndexedMapSerialized } from "@silvana-one/storage";
-import { NftTransactionType, NftTransactionParams, LaunchNftCollectionStandardAdminParams, LaunchNftCollectionAdvancedAdminParams } from "@silvana-one/api";
+import { NftTransactionType, NftTransactionParams, LaunchNftCollectionStandardAdminParams, LaunchNftCollectionAdvancedAdminParams, NftMintTransactionParams } from "@silvana-one/api";
 import { blockchain } from "../types.js";
 import { PublicKey, Transaction } from "o1js";
 export type NftAdminType = "standard" | "advanced" | "unknown";
@@ -23,12 +23,32 @@ export declare function buildNftCollectionLaunchTransaction(params: {
 }>;
 export declare function buildNftTransaction(params: {
     chain: blockchain;
-    args: Exclude<NftTransactionParams, LaunchNftCollectionStandardAdminParams | LaunchNftCollectionAdvancedAdminParams>;
+    args: Exclude<NftTransactionParams, LaunchNftCollectionStandardAdminParams | LaunchNftCollectionAdvancedAdminParams | NftMintTransactionParams>;
     developerAddress?: string;
     provingKey?: string;
     provingFee?: number;
 }): Promise<{
-    request: Exclude<NftTransactionParams, LaunchNftCollectionStandardAdminParams | LaunchNftCollectionAdvancedAdminParams>;
+    request: Exclude<NftTransactionParams, LaunchNftCollectionStandardAdminParams | LaunchNftCollectionAdvancedAdminParams | NftMintTransactionParams>;
+    tx: Transaction<false, false>;
+    adminType: NftAdminType;
+    adminContractAddress: PublicKey;
+    symbol: string;
+    collectionName: string;
+    nftName: string;
+    verificationKeyHashes: string[];
+    metadataRoot: string;
+    storage: string;
+    privateMetadata?: string;
+    map?: IndexedMapSerialized;
+}>;
+export declare function buildNftMintTransaction(params: {
+    chain: blockchain;
+    args: NftMintTransactionParams;
+    developerAddress?: string;
+    provingKey?: string;
+    provingFee?: number;
+}): Promise<{
+    request: NftMintTransactionParams;
     tx: Transaction<false, false>;
     adminType: NftAdminType;
     adminContractAddress: PublicKey;
@@ -52,4 +72,7 @@ export declare function getNftSymbolAndAdmin(params: {
     collectionName: string;
     adminType: NftAdminType;
     verificationKeyHashes: string[];
+    nftName?: string;
+    storage?: string;
+    metadataRoot?: string;
 }>;