@silvana-one/nft 0.1.1 → 0.1.3

package/src/interfaces/types.ts

@@ -315,7 +315,7 @@ class NFTData extends Struct({
     owner: string | PublicKey;
     approved?: string | PublicKey;
     version?: number;
-    id?: bigint;
+    id?: bigint | string;
     canChangeOwnerByProof?: boolean;
     canTransfer?: boolean;
     canApprove?: boolean;
@@ -351,7 +351,7 @@ class NFTData extends Struct({
           : approved
         : PublicKey.empty(),
       version: UInt32.from(version ?? 0),
-      id: UInt64.from(id ?? 0),
+      id: UInt64.from(BigInt(id ?? 0)),
       canChangeOwnerByProof: Bool(canChangeOwnerByProof ?? false),
       canTransfer: Bool(canTransfer ?? true),
       canApprove: Bool(canApprove ?? true),
@@ -470,7 +470,7 @@ class CollectionData extends Struct({
    */
   static new(params: {
     royaltyFee?: number;
-    transferFee?: number;
+    transferFee?: number | bigint | string;
     requireTransferApproval?: boolean;
     mintingIsLimited?: boolean;
     isPaused?: boolean;
@@ -484,7 +484,7 @@ class CollectionData extends Struct({
     } = params;
     return new CollectionData({
       royaltyFee: UInt32.from(royaltyFee ?? 0),
-      transferFee: UInt64.from(transferFee ?? 0),
+      transferFee: UInt64.from(BigInt(transferFee ?? 0)),
       requireTransferApproval: Bool(requireTransferApproval ?? false),
       mintingIsLimited: Bool(mintingIsLimited ?? false),
       isPaused: Bool(isPaused ?? false),

package/src/marketplace/auction.ts

@@ -25,6 +25,7 @@ import {
   TransferExtendedParams,
   TransferParams,
 } from "../interfaces/index.js";
+import { mulDiv } from "../util/index.js";
 
 const MAX_SALE_FEE = 100000;
 const MIN_STEP = 10; // 1% to previous bid
@@ -252,7 +253,11 @@ export function AuctionFactory(params: {
         UInt32.from(MAX_SALE_FEE),
         "Sale fee is too high"
       );
-      return price.div(MAX_SALE_FEE).mul(UInt64.from(saleFee));
+      return mulDiv({
+        value: price,
+        multiplier: UInt64.from(saleFee),
+        denominator: UInt64.from(MAX_SALE_FEE),
+      }).result;
     }
     // anyone can call this method to bid, paying the bid amount for the bidder
     @method.returns(Auction)
@@ -268,7 +273,13 @@ export function AuctionFactory(params: {
         "Bid should be greater or equal than the minimum price"
       );
       price.assertGreaterThan(
-        bidAmount.add(bidAmount.div(1000).mul(UInt64.from(MIN_STEP))),
+        bidAmount.add(
+          mulDiv({
+            value: bidAmount,
+            multiplier: UInt64.from(MIN_STEP),
+            denominator: UInt64.from(1000),
+          }).result
+        ),
         "Bid should be greater than the existing bid plus the minimum step"
       );
       this.network.globalSlotSinceGenesis.requireBetween(

package/src/marketplace/nft-shares.ts

@@ -21,6 +21,7 @@ import {
 } from "@silvana-one/token";
 import { NFTOwnerBase, TransferExtendedParams } from "../interfaces/index.js";
 import { Auction, AuctionFactory } from "./auction.js";
+import { mulDiv } from "../util/index.js";
 
 export interface NFTSharesAdminDeployProps
   extends Exclude<DeployArgs, undefined> {
@@ -275,14 +276,12 @@ export function NFTSharesFactory(params: {
       balance
         .equals(UInt64.zero)
         .assertFalse("Balance is zero, nothing to withdraw");
-      const amountInMinaField = shares.value
-        .mul(balance.value)
-        .div(sharesOutstanding.value);
-      amountInMinaField.assertLessThanOrEqual(
-        balance.value,
-        "Amount in Mina is greater than the balance"
-      );
-      const amountInMina = UInt64.Unsafe.fromField(amountInMinaField);
+      const amountInMina = mulDiv({
+        value: shares,
+        multiplier: balance,
+        denominator: sharesOutstanding,
+      }).result;
+
       const sender = this.sender.getUnconstrained();
       const senderUpdate = AccountUpdate.createSigned(sender);
       senderUpdate.balance.addInPlace(amountInMina);

package/src/metadata/address.ts

@@ -0,0 +1,50 @@
+import { Field, PublicKey, Poseidon } from "o1js";
+export { MinaAddress };
+
+/**
+/**
+ * The `MinaAddress` class represents a Mina address in the form of a Merkle tree. The address is converted to its
+ * hash and stored as a leaf in the Merkle tree. The root of the tree can be used as a compact representation
+ * of the address data in cryptographic proofs.
+ */
+class MinaAddress {
+  /**
+   * The original address.
+   */
+  readonly address: PublicKey;
+  /**
+   * The hash of the address.
+   */
+  readonly hash: Field;
+
+  /**
+   * Constructs a new `MinaAddress` instance by creating a Merkle tree from the given address.
+   * The address is converted to its hash and stored as a leaf in the tree.
+   *
+   * @param address - The address to be represented.
+   * @throws Will throw an error if the address is not a valid Mina address.
+   */
+  constructor(address: PublicKey | string) {
+    this.address =
+      typeof address === "string" ? PublicKey.fromBase58(address) : address;
+    this.hash = Poseidon.hashPacked(PublicKey, this.address);
+  }
+
+  /**
+   * Returns the original address.
+   *
+   * @returns The public key.
+   */
+  public toPublicKey(): PublicKey {
+    return this.address;
+  }
+
+  /**
+   * Returns the base58 representation of the address.
+   *
+   * @returns The base58 representation of the address.
+   */
+  public toString(): string {
+    return this.address.toBase58();
+  }
+}

package/src/metadata/index.ts

@@ -1,3 +1,4 @@
 export * from "./metadata.js";
 export * from "./tree.js";
 export * from "./text.js";
+export * from "./pin.js";

package/src/metadata/metadata.ts

@@ -1,6 +1,7 @@
-import { Field, Poseidon, Struct, Experimental } from "o1js";
+import { Field, Poseidon, Struct, Experimental, PublicKey, UInt64 } from "o1js";
 import { fieldFromString } from "../interfaces/index.js";
 import { Text } from "./text.js";
+import { MinaAddress } from "./address.js";
 import { MetadataTree } from "./tree.js";
 export {
   Metadata,
@@ -31,7 +32,9 @@ type MetadataFieldType =
   | "text"
   | "image"
   | "url"
-  | "field"
+  | "field" // Field
+  | "number" // UInt64
+  | "address" // PublicKey
   | "map"
   | "tree";
 
@@ -50,7 +53,7 @@ class MetadataValue extends Struct({
    * @returns A new MetadataValue.
    */
   static new(params: {
-    value: Field | Text | Metadata | MetadataTree;
+    value: Field | Text | Metadata | MetadataTree | PublicKey | UInt64;
     type: MetadataFieldType;
   }) {
     const { value, type } = params;
@@ -74,6 +77,18 @@ class MetadataValue extends Struct({
         if (!(value instanceof Field)) throw new Error(`Invalid value type`);
         valueField = value;
         break;
+      case "number":
+        if (!(value instanceof UInt64)) throw new Error(`Invalid value type`);
+        valueField = value.value;
+        break;
+      case "address":
+        if (!(value instanceof PublicKey))
+          throw new Error(`Invalid value type`);
+        const address = new MinaAddress(value);
+        valueField = address.hash;
+        length = Field(2);
+        height = Field(0);
+        break;
       case "map":
         if (!(value instanceof Metadata)) throw new Error(`Invalid value type`);
         valueField = value.map.root;
@@ -271,7 +286,14 @@ class Metadata {
   traits: {
     [key: string]: {
       type: string;
-      value: string | Field | Metadata | MetadataTree | unknown;
+      value:
+        | string
+        | Field
+        | Metadata
+        | MetadataTree
+        | UInt64
+        | PublicKey
+        | unknown;
       isPrivate: boolean;
     };
   } = {};
@@ -328,7 +350,16 @@ class Metadata {
   addTrait(params: {
     key: string;
     type: string;
-    value: string | Field | Metadata | MetadataTree | unknown;
+    value:
+      | string
+      | Field
+      | Metadata
+      | MetadataTree
+      | UInt64
+      | PublicKey
+      | bigint
+      | number
+      | unknown;
     isPrivate?: boolean;
   }): {
     key: Field;
@@ -340,7 +371,13 @@ class Metadata {
     let canonicalRepresentation: unknown = value;
 
     if (type in MetadataFieldTypeValues) {
-      let valueObject: Field | Text | Metadata | MetadataTree;
+      let valueObject:
+        | Field
+        | Text
+        | Metadata
+        | MetadataTree
+        | UInt64
+        | PublicKey;
       switch (type) {
         case "string":
           if (typeof value !== "string")
@@ -355,9 +392,34 @@ class Metadata {
           valueObject = new Text(value);
           break;
         case "field":
-          if (!(value instanceof Field))
+          if (
+            !(
+              value instanceof Field ||
+              typeof value === "bigint" ||
+              typeof value === "number" ||
+              typeof value === "string"
+            )
+          )
             throw new Error(`Invalid trait value type`);
-          valueObject = value;
+          valueObject = Field(value);
+          break;
+        case "number":
+          if (
+            !(
+              value instanceof UInt64 ||
+              typeof value === "bigint" ||
+              typeof value === "number" ||
+              typeof value === "string"
+            )
+          )
+            throw new Error(`Invalid trait value type`);
+          valueObject = UInt64.from(value);
+          break;
+        case "address":
+          if (!(value instanceof PublicKey || typeof value === "string"))
+            throw new Error(`Invalid trait value type`);
+          valueObject =
+            typeof value === "string" ? PublicKey.fromBase58(value) : value;
           break;
         case "map":
           if (!(value instanceof Metadata))
@@ -431,6 +493,16 @@ class Metadata {
                 throw new Error(`Invalid trait value type`);
               jsonValue = value.toJSON();
               break;
+            case "number":
+              if (!(value instanceof UInt64))
+                throw new Error(`Invalid trait value type`);
+              jsonValue = value.toJSON();
+              break;
+            case "address":
+              if (!(value instanceof PublicKey))
+                throw new Error(`Invalid trait value type`);
+              jsonValue = value.toBase58();
+              break;
             case "map":
               if (!(value instanceof Metadata))
                 throw new Error(`Invalid trait value type`);
@@ -470,7 +542,7 @@ class Metadata {
       description?: string;
       banner?: string;
       metadataRoot: string;
-      traits: {
+      traits?: {
         key: string;
         type: string;
         value: string | object;
@@ -481,7 +553,14 @@ class Metadata {
     plugins?: MetadataPlugin[];
   }): Metadata {
     const { json, checkRoot = false, plugins } = params;
-    const { name, description, image, banner, metadataRoot, traits } = json;
+    const {
+      name,
+      description,
+      image,
+      banner,
+      metadataRoot,
+      traits = [],
+    } = json;
     if (!name) throw new Error(`Metadata name is required`);
     if (typeof name !== "string") throw new Error(`Invalid metadata name`);
     if (!image || typeof image !== "string")
@@ -511,7 +590,14 @@ class Metadata {
       plugins,
     });
     for (const { key, type, value, isPrivate } of traits) {
-      let valueField: string | Field | Metadata | MetadataTree | unknown;
+      let valueField:
+        | string
+        | Field
+        | Metadata
+        | MetadataTree
+        | UInt64
+        | PublicKey
+        | unknown;
       switch (type) {
         case "string":
         case "text":
@@ -526,6 +612,16 @@ class Metadata {
             throw new Error(`Invalid trait value type`);
           valueField = Field.fromJSON(value);
           break;
+        case "number":
+          if (typeof value !== "string")
+            throw new Error(`Invalid trait value type`);
+          valueField = UInt64.fromJSON(value);
+          break;
+        case "address":
+          if (typeof value !== "string")
+            throw new Error(`Invalid trait value type`);
+          valueField = PublicKey.fromBase58(value);
+          break;
         case "map":
           if (typeof value !== "object")
             throw new Error(`Invalid trait value type`);
@@ -587,6 +683,133 @@ class Metadata {
 
     return metadata;
   }
+
+  /**
+   * Constructs a Metadata instance from OpenAPI JSON data (without calculated root).
+   * @param params - The parameters including json data, checkRoot flag, and plugins.
+   * @returns A new Metadata instance.
+   */
+  static fromOpenApiJSON(params: {
+    json: {
+      name: string;
+      image: string;
+      description?: string;
+      banner?: string;
+      traits?: {
+        key: string;
+        type: string;
+        value: string | object;
+        isPrivate?: boolean;
+      }[];
+    };
+    plugins?: MetadataPlugin[];
+  }): Metadata {
+    const { json, plugins } = params;
+    const { name, description, image, banner, traits = [] } = json;
+    if (!name) throw new Error(`Metadata name is required`);
+    if (typeof name !== "string") throw new Error(`Invalid metadata name`);
+    if (!image || typeof image !== "string")
+      throw new Error(`Invalid metadata image`);
+    if (description && typeof description !== "string")
+      throw new Error(`Invalid metadata description`);
+    if (banner && typeof banner !== "string")
+      throw new Error(`Invalid metadata banner`);
+    if (!traits || !Array.isArray(traits))
+      throw new Error(`Metadata traits are required`);
+    for (const { key, type, value, isPrivate } of traits) {
+      if (!key || typeof key !== "string") throw new Error(`Invalid trait key`);
+      if (!type || typeof type !== "string")
+        throw new Error(`Invalid trait type`);
+      if (!value || (typeof value !== "string" && typeof value !== "object"))
+        throw new Error(`Invalid trait value`);
+      if (isPrivate && typeof isPrivate !== "boolean")
+        throw new Error(`Invalid trait isPrivate`);
+    }
+    const metadata = new Metadata({
+      name,
+      description,
+      image,
+      banner,
+      plugins,
+    });
+    for (const { key, type, value, isPrivate } of traits) {
+      let valueField:
+        | string
+        | Field
+        | Metadata
+        | MetadataTree
+        | UInt64
+        | PublicKey
+        | unknown;
+      switch (type) {
+        case "string":
+        case "text":
+        case "image":
+        case "url":
+          if (typeof value !== "string")
+            throw new Error(`Invalid trait value type`);
+          valueField = value;
+          break;
+        case "field":
+          if (typeof value !== "string")
+            throw new Error(`Invalid trait value type`);
+          valueField = Field.fromJSON(value);
+          break;
+        case "number":
+          if (typeof value !== "string")
+            throw new Error(`Invalid trait value type`);
+          valueField = UInt64.fromJSON(value);
+          break;
+        case "address":
+          if (typeof value !== "string")
+            throw new Error(`Invalid trait value type`);
+          valueField = PublicKey.fromBase58(value);
+          break;
+        case "map":
+          if (typeof value !== "object")
+            throw new Error(`Invalid trait value type`);
+          valueField = Metadata.fromOpenApiJSON({
+            json: value as unknown as {
+              name: string;
+              image: string;
+              description?: string;
+              traits: {
+                key: string;
+                type: string;
+                value: string | object;
+                isPrivate?: boolean;
+              }[];
+            },
+          });
+          break;
+        case "tree":
+          if (typeof value !== "object")
+            throw new Error(`Invalid trait value type`);
+          valueField = MetadataTree.fromJSON(
+            value as unknown as {
+              height: number;
+              root: string;
+              values: { key: string; value: string }[];
+            }
+          );
+          break;
+        default:
+          const plugin = metadata.plugins.find(
+            (plugin) => plugin.name === type
+          );
+          if (!plugin) throw new Error(`Unknown trait type`);
+          valueField = plugin.fromJSON(value);
+      }
+      metadata.addTrait({
+        key,
+        type,
+        value: valueField,
+        isPrivate: isPrivate ?? false,
+      });
+    }
+
+    return metadata;
+  }
 }
 
 /**
@@ -600,4 +823,6 @@ const MetadataFieldTypeValues = {
   field: { code: 5n, inputType: Field, storedType: Field }, // Field
   map: { code: 6n, inputType: Metadata, storedType: Metadata }, // Metadata
   tree: { code: 7n, inputType: MetadataTree, storedType: MetadataTree }, // MetadataTree
+  number: { code: 8n, inputType: UInt64, storedType: UInt64 }, // UInt64
+  address: { code: 9n, inputType: PublicKey, storedType: MinaAddress }, // MinaAddress
 } as const;

package/src/metadata/pin.ts

@@ -0,0 +1,30 @@
+import { Metadata } from "./metadata.js";
+import {
+  pinJSON,
+  serializeIndexedMap,
+  IndexedMapSerialized,
+} from "@silvana-one/storage";
+import { Field } from "o1js";
+
+export async function pinMetadata(metadata: Metadata): Promise<{
+  name: string;
+  ipfsHash: string;
+  metadataRoot: Field;
+  privateMetadata: string;
+  serializedMap: IndexedMapSerialized;
+}> {
+  const privateMetadata = JSON.stringify(metadata.toJSON(true), null, 2);
+  const ipfsHash: string | undefined = await pinJSON({
+    data: metadata.toJSON(false),
+    name: "nft-metadata",
+  });
+  if (!ipfsHash) throw new Error("Failed to pin metadata");
+
+  return {
+    name: metadata.name,
+    ipfsHash,
+    metadataRoot: metadata.map.root,
+    privateMetadata,
+    serializedMap: serializeIndexedMap(metadata.map),
+  };
+}

package/src/metadata/tree.ts

@@ -94,7 +94,7 @@ export class MetadataTree {
    */
   static fromJSON(json: {
     height: number;
-    root: string;
+    root?: string;
     values: { key: string; value: string }[];
   }): MetadataTree {
     const { height, values, root } = json;
@@ -102,7 +102,7 @@ export class MetadataTree {
     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 (root && typeof root !== "string") throw new Error(`Invalid tree root`);
 
     if (!values || !Array.isArray(values))
       throw new Error(`Tree values are required`);
@@ -121,7 +121,8 @@ export class MetadataTree {
       }))
     );
 
-    if (tree.root.toJSON() !== root) throw new Error("Invalid tree json");
+    if (root && tree.root.toJSON() !== root)
+      throw new Error("Invalid tree json");
 
     return tree;
   }

package/src/util/div.ts

@@ -0,0 +1,44 @@
+import { Field, Provable, UInt64, Gadgets, Struct } from "o1js";
+
+export class MulDivResult extends Struct({
+  result: UInt64,
+  remainder: UInt64,
+}) {}
+
+class MulDivResultInternal extends Struct({
+  result: Field,
+  remainder: Field,
+}) {}
+
+export function mulDiv(params: {
+  value: UInt64;
+  multiplier: UInt64;
+  denominator: UInt64;
+}): MulDivResult {
+  const { value, multiplier, denominator } = params;
+  denominator.equals(UInt64.zero).assertFalse("division by zero"); // should fail in case the denominator is zero
+  const fields = Provable.witness(MulDivResultInternal, () => {
+    const valueBigInt = value.toBigInt();
+    const multiplierBigInt = multiplier.toBigInt();
+    const denominatorBigInt = denominator.toBigInt();
+    // handle division by zero for first pass of the prover that can pass zero instead of the real value
+    if (denominatorBigInt === 0n) {
+      return { result: Field.from(0n), remainder: Field.from(0n) };
+    }
+    const result = (valueBigInt * multiplierBigInt) / denominatorBigInt;
+    const remainder =
+      valueBigInt * multiplierBigInt - result * denominatorBigInt;
+    return { result: Field.from(result), remainder: Field.from(remainder) };
+  });
+  Gadgets.rangeCheck64(fields.result);
+  Gadgets.rangeCheck64(fields.remainder);
+  fields.remainder.assertLessThan(denominator.value); // should fail in case the denominator is zero
+  fields.result
+    .mul(denominator.value)
+    .add(fields.remainder)
+    .assertEquals(value.value.mul(multiplier.value)); // should fail in case the denominator is zero
+  return {
+    result: UInt64.Unsafe.fromField(fields.result),
+    remainder: UInt64.Unsafe.fromField(fields.remainder),
+  };
+}

package/src/util/index.ts

@@ -0,0 +1 @@
+export * from "./div.js";