@silvana-one/nft 0.1.0

package/src/metadata/tree.ts

@@ -0,0 +1,128 @@
+import { MerkleTree, Field } from "o1js";
+
+/**
+ * Represents a metadata tree using a Merkle tree structure.
+ *
+ * The `MetadataTree` class is used to manage a set of key-value pairs representing metadata,
+ * storing them in a Merkle tree for efficient verification and integrity checks.
+ *
+ * This class is a utility within the NFT standard on Mina Protocol, enabling secure and verifiable
+ * storage of metadata. By leveraging the Merkle tree, clients can prove the inclusion of specific
+ * metadata entries without exposing the entire dataset.
+ */
+export class MetadataTree {
+  /**
+   * The list of key-value pairs stored in the tree.
+   * Each key is a `bigint` representing the index in the Merkle tree,
+   * and each value is a `Field` element from o1js.
+   */
+  readonly values: { key: bigint; value: Field }[];
+
+  /**
+   * The height of the Merkle tree.
+   * Determines the maximum number of elements the tree can hold.
+   */
+  readonly height: number;
+
+  /**
+   * The root of the Merkle tree.
+   * Used for verifying the integrity of the tree and its contents.
+   */
+  readonly root: Field;
+
+  /**
+   * Constructs a new `MetadataTree` with the specified height and key-value pairs.
+   *
+   * @param height - The height of the Merkle tree (must be between 1 and 254).
+   * @param values - An array of key-value pairs to store in the tree.
+   *
+   * @throws Will throw an error if the number of values exceeds the maximum capacity of the tree.
+   * @throws Will throw an error if any key is out of bounds for the tree height.
+   */
+  constructor(height: number, values: { key: bigint; value: Field }[]) {
+    this.values = values;
+    this.height = height;
+    const tree = new MerkleTree(height);
+    const maxElements = tree.leafCount;
+
+    if (values.length > tree.leafCount) {
+      throw new Error(
+        `Tree height ${height} can only have ${maxElements} elements`
+      );
+    }
+
+    for (const { key, value } of values) {
+      if (key >= maxElements) {
+        throw new Error(
+          `Key ${key} is out of bounds for tree height ${height}`
+        );
+      }
+      tree.setLeaf(key, value);
+    }
+
+    this.root = tree.getRoot();
+  }
+
+  /**
+   * Serializes the `MetadataTree` to a JSON object.
+   *
+   * @returns An object containing the tree's height, root, and values.
+   */
+  public toJSON(): {
+    height: number;
+    root: string;
+    values: { key: string; value: string }[];
+  } {
+    return {
+      height: this.height,
+      root: this.root.toJSON(),
+      values: this.values.map(({ key, value }) => ({
+        key: key.toString(),
+        value: value.toJSON(),
+      })),
+    };
+  }
+
+  /**
+   * Deserializes a JSON object into a `MetadataTree` instance.
+   *
+   * @param json - The JSON object containing the tree data.
+   *
+   * @returns A new `MetadataTree` instance constructed from the JSON data.
+   *
+   * @throws Will throw an error if the JSON data is invalid or inconsistent.
+   */
+  static fromJSON(json: {
+    height: number;
+    root: string;
+    values: { key: string; value: string }[];
+  }): MetadataTree {
+    const { height, values, root } = json;
+
+    if (typeof height !== "number" || height < 1 || height > 254)
+      throw new Error(`Invalid tree height`);
+
+    if (!root || typeof root !== "string") throw new Error(`Invalid tree root`);
+
+    if (!values || !Array.isArray(values))
+      throw new Error(`Tree values are required`);
+
+    for (const { key, value } of values) {
+      if (!key || typeof key !== "string") throw new Error(`Invalid tree key`);
+      if (!value || typeof value !== "string")
+        throw new Error(`Invalid tree value`);
+    }
+
+    const tree = new MetadataTree(
+      height,
+      values.map(({ key, value }) => ({
+        key: BigInt(key),
+        value: Field.fromJSON(value),
+      }))
+    );
+
+    if (tree.root.toJSON() !== root) throw new Error("Invalid tree json");
+
+    return tree;
+  }
+}

package/src/vk.ts

@@ -0,0 +1,64 @@
+/**
+ * Type representing the supported network IDs for the Mina Protocol.
+ *
+ * Currently supports:
+ * - `"devnet"`: The Mina local blockchain and devnet
+ * - `"mainnet"`: The Mina mainnet
+ */
+export type SupportedNetworkId = "devnet" | "mainnet";
+
+/**
+ * An object containing the verification keys for the NFT Collection and NFT contracts on different networks.
+ *
+ *
+ * @remarks
+ * The `NFTVerificationKeys` object maps a `SupportedNetworkId` to the corresponding verification keys for the NFT Collection and NFT contracts.
+ *
+ * **Structure:**
+ * - `network`: The network identifier (`"devnet"` or `"mainnet"`).
+ *   - `collection`:
+ *     - `hash`: The hash of the verification key for the NFT Collection contract.
+ *     - `data`: The verification key data for the NFT Collection contract.
+ *   - `nft`:
+ *     - `hash`: The hash of the verification key for the NFT contract.
+ *     - `data`: The verification key data for the NFT contract.
+ *
+ * @example
+ * Accessing the verification key hash for the NFT Collection on testnet:
+ * ```typescript
+ * const testnetCollectionVKHash = NFTVerificationKeys["devnet"].collection.hash;
+ * ```
+ */
+export const nftVerificationKeys: {
+  [key in "mainnet" | "devnet"]: {
+    o1js: string;
+    vk: {
+      [key: string]: {
+        hash: string;
+        data: string;
+        type: "nft";
+      };
+    };
+  };
+} = {
+  devnet: {
+    o1js: "2.2.0",
+    vk: {
+      NFT: {
+        hash: "11840382732064931640435917684245815329181717734233274982467687213333743677377",
+        data: "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",
+        type: "nft",
+      },
+    },
+  },
+  mainnet: {
+    o1js: "2.2.0",
+    vk: {
+      NFT: {
+        hash: "11510318025893859422482952918693907155880273225165466507725691048640041393360",
+        data: "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",
+        type: "nft",
+      },
+    },
+  },
+};

package/src/zkprogram-example/game.ts

@@ -0,0 +1,136 @@
+/**
+ * NFTMatchProgram is a ZkProgram providing zero-knowledge proofs for matching NFT metadata to Smart Contract state.
+ *
+ * @module NFTMatchProgram
+ */
+
+import { ZkProgram, Field, Cache, PublicKey, SelfProof, Provable } from "o1js";
+import { NFTState } from "../interfaces/types.js";
+import { Metadata, MetadataMap, MetadataValue } from "../metadata/metadata.js";
+import { fieldFromString } from "../interfaces/encoding.js";
+import { createIpfsURL, Storage } from "@silvana-one/storage";
+export { NFTGameProgram };
+
+/**
+ * Defines the NFTProgram ZkProgram with methods for updating NFT metadata.
+ */
+const NFTGameProgram = ZkProgram({
+  name: "NFTGameProgram",
+  publicInput: NFTState,
+  publicOutput: NFTState,
+  methods: {
+    /**
+     * Updates the NFT's metadata map with a new key-value pairs.
+     *
+     * @returns {Promise<{ publicOutput: NFTState; auxiliaryOutput: MetadataMap }>} A promise resolving to an object containing the updated NFT state and auxiliary output.
+     *
+     * @remarks
+     * This method verifies that the provided signature is valid and corresponds to the NFT owner.
+     * It then inserts the new key-value pair into the metadata map, ensuring that the key does not already exist.
+     * The method returns an updated NFT state with the new metadata root and increments the version.
+     */
+    updateMetadataAndOwner: {
+      privateInputs: [MetadataMap, PublicKey, Field, Field, Storage, PublicKey],
+      auxiliaryOutput: MetadataMap,
+      async method(
+        initialState: NFTState,
+        metadata: MetadataMap,
+        contract: PublicKey,
+        score: Field,
+        color: Field,
+        storage: Storage,
+        owner: PublicKey
+      ): Promise<{ publicOutput: NFTState; auxiliaryOutput: MetadataMap }> {
+        metadata.root.assertEquals(initialState.metadata);
+        metadata.set(
+          fieldFromString("color"),
+          MetadataValue.new({ value: color, type: "field" }).hash()
+        );
+        metadata.set(
+          fieldFromString("score"),
+          MetadataValue.new({ value: score, type: "field" }).hash()
+        );
+        initialState.oracleAddress.assertEquals(contract);
+        initialState.context.custom[0].assertEquals(score);
+        initialState.context.custom[1].assertEquals(color);
+        MetadataValue.new({ value: contract.x, type: "field" })
+          .hash()
+          .assertEquals(metadata.get(fieldFromString("contractX")));
+        MetadataValue.new({
+          value: contract.isOdd.toField(),
+          type: "field",
+        })
+          .hash()
+          .assertEquals(metadata.get(fieldFromString("contractIsOdd")));
+
+        contract.assertEquals(initialState.oracleAddress);
+
+        // This code does NOT create a constraint on the storage as we use IPFS.
+        // It is used to verify that the storage that will be used is valid.
+        // After Project Untitled will be released, this code should be changed
+        // to create a constraint on the storage using Project Untitled.
+        const metadataRoot = await Provable.witnessAsync(Field, async () => {
+          const fetchResult = await fetch(
+            createIpfsURL({ hash: storage.toString() })
+          );
+          if (!fetchResult.ok) {
+            throw new Error("Failed to fetch metadata");
+          }
+          const json = await fetchResult.json();
+          if (!json) {
+            throw new Error("Failed to fetch metadata");
+          }
+
+          const metadata = Metadata.fromJSON({
+            json,
+            checkRoot: true,
+          });
+          return metadata.map.root;
+        });
+        metadataRoot.assertEquals(metadata.root);
+
+        // Owner can be updated only in case of a maximum score - 7 when the winner gets the NFT
+        owner
+          .equals(initialState.owner)
+          .or(score.equals(Field(7)))
+          .assertTrue();
+
+        return {
+          publicOutput: new NFTState({
+            metadata: metadata.root,
+            owner,
+            storage,
+            immutableState: initialState.immutableState,
+            approved: initialState.approved,
+            name: initialState.name,
+            isPaused: initialState.isPaused,
+            version: initialState.version.add(1),
+            metadataVerificationKeyHash:
+              initialState.metadataVerificationKeyHash,
+            creator: initialState.creator,
+            oracleAddress: initialState.oracleAddress,
+            context: initialState.context,
+          }),
+          auxiliaryOutput: metadata,
+        };
+      },
+    },
+
+    merge: {
+      privateInputs: [SelfProof, SelfProof],
+      async method(
+        initialState: NFTState,
+        proof1: SelfProof<NFTState, NFTState>,
+        proof2: SelfProof<NFTState, NFTState>
+      ) {
+        proof1.verify();
+        proof2.verify();
+        NFTState.assertEqual(initialState, proof1.publicInput);
+        NFTState.assertEqual(proof1.publicOutput, proof2.publicInput);
+        return {
+          publicOutput: proof2.publicOutput,
+        };
+      },
+    },
+  },
+});

package/src/zkprogram-example/index.ts

@@ -0,0 +1,2 @@
+export * from "./update.js";
+export * from "./game.js";

package/src/zkprogram-example/update.ts

@@ -0,0 +1,98 @@
+/**
+ * NFTProgram is a ZkProgram providing zero-knowledge proofs for updating NFT metadata.
+ * It includes methods for inserting metadata entries and merging proofs.
+ *
+ * @module NFTProgram
+ */
+
+import { ZkProgram, Field, Cache, SelfProof, Signature } from "o1js";
+import { NFTState } from "../interfaces/types.js";
+import { MetadataMap } from "../metadata/metadata.js";
+export { NFTProgram };
+
+/**
+ * Defines the NFTProgram ZkProgram with methods for updating NFT metadata.
+ */
+const NFTProgram = ZkProgram({
+  name: "NFTProgram",
+  publicInput: NFTState,
+  publicOutput: NFTState,
+  methods: {
+    /**
+     * Inserts a metadata key-value pair into the NFT's metadata map.
+     *
+     * @returns {Promise<{ publicOutput: NFTState; auxiliaryOutput: MetadataMap }>} A promise resolving to an object containing the updated NFT state and auxiliary output.
+     *
+     * @remarks
+     * This method verifies that the provided signature is valid and corresponds to the NFT owner.
+     * It then inserts the new key-value pair into the metadata map, ensuring that the key does not already exist.
+     * The method returns an updated NFT state with the new metadata root and increments the version.
+     */
+    insertMetadata: {
+      privateInputs: [MetadataMap, Field, Field, Signature],
+      auxiliaryOutput: MetadataMap,
+      async method(
+        initialState: NFTState,
+        metadata: MetadataMap,
+        key: Field,
+        value: Field,
+        signature: Signature
+      ): Promise<{ publicOutput: NFTState; auxiliaryOutput: MetadataMap }> {
+        signature
+          .verify(initialState.owner, [
+            ...NFTState.toFields(initialState),
+            key,
+            value,
+          ])
+          .assertTrue("Wrong owner signature");
+        metadata.insert(key, value); // Proves that key does not exist
+
+        return {
+          publicOutput: new NFTState({
+            immutableState: initialState.immutableState,
+            metadata: metadata.root,
+            owner: initialState.owner,
+            approved: initialState.approved,
+            name: initialState.name,
+            storage: initialState.storage,
+            isPaused: initialState.isPaused,
+            version: initialState.version.add(1),
+            metadataVerificationKeyHash:
+              initialState.metadataVerificationKeyHash,
+            creator: initialState.creator,
+            oracleAddress: initialState.oracleAddress,
+            context: initialState.context,
+          }),
+          auxiliaryOutput: metadata,
+        };
+      },
+    },
+    /**
+     * Merges two self-proofs to produce a new NFT state.
+     *
+     * @returns {Promise<{ publicOutput: NFTState }>} A promise resolving to an object containing the merged NFT state.
+     *
+     * @remarks
+     * This method verifies both proofs and asserts the consistency of their inputs and outputs.
+     * It ensures that the initial state matches the public input of the first proof,
+     * and that the public output of the first proof matches the public input of the second proof.
+     * The method returns the public output of the second proof as the new merged NFT state.
+     */
+    merge: {
+      privateInputs: [SelfProof, SelfProof],
+      async method(
+        initialState: NFTState,
+        proof1: SelfProof<NFTState, NFTState>,
+        proof2: SelfProof<NFTState, NFTState>
+      ) {
+        proof1.verify();
+        proof2.verify();
+        NFTState.assertEqual(initialState, proof1.publicInput);
+        NFTState.assertEqual(proof1.publicOutput, proof2.publicInput);
+        return {
+          publicOutput: proof2.publicOutput,
+        };
+      },
+    },
+  },
+});