@silvana-one/nft 0.1.0

package/src/marketplace/bid.ts

@@ -0,0 +1,294 @@
+import {
+  AccountUpdate,
+  DeployArgs,
+  method,
+  Permissions,
+  PublicKey,
+  State,
+  state,
+  UInt64,
+  SmartContract,
+  Bool,
+  Field,
+  Struct,
+  Poseidon,
+  Provable,
+} from "o1js";
+import { Whitelist, OffChainList, Storage } from "@silvana-one/storage";
+import {
+  NFTAddress,
+  SellEvent,
+  DepositEvent,
+  WithdrawEvent,
+  BidEvent,
+} from "./types.js";
+import {
+  NFTCollectionBase,
+  NFTCollectionContractConstructor,
+  TransferParams,
+  UInt64Option,
+  NFTTransactionContext,
+} from "../interfaces/index.js";
+
+export class Bid extends Struct({
+  price: UInt64,
+  points: UInt64,
+}) {
+  pack() {
+    return Field.fromBits([
+      ...this.price.value.toBits(64),
+      ...this.points.value.toBits(64),
+    ]);
+  }
+  static unpack(field: Field): Bid {
+    const bits = field.toBits(64 + 64);
+    const price = UInt64.Unsafe.fromField(Field.fromBits(bits.slice(0, 64)));
+    const points = UInt64.Unsafe.fromField(
+      Field.fromBits(bits.slice(64, 64 + 64))
+    );
+    return new Bid({
+      price,
+      points,
+    });
+  }
+}
+
+export interface NonFungibleTokenBidContractDeployProps
+  extends Exclude<DeployArgs, undefined> {
+  /** The whitelist. */
+  whitelist: Field;
+  /** The offers. */
+  bids: Field;
+  /** The storage. */
+  storage: Storage;
+}
+
+export function BidFactory(params: {
+  collectionContract: () => NFTCollectionContractConstructor;
+}) {
+  const { collectionContract } = params;
+  class NonFungibleTokenBidContract extends SmartContract {
+    @state(PublicKey) buyer = State<PublicKey>();
+    @state(Field) whitelist = State<Field>();
+    @state(Field) bids = State<Field>();
+    @state(Storage) storage = State<Storage>();
+    @state(UInt64) maxPoints = State<UInt64>();
+    // We do not have concurrency here, but given that it is a single-user contract,
+    // we can use state to track the points that have been consumed
+    // In case of concurrency, we can use the tokens to track the points
+    @state(UInt64) consumedPoints = State<UInt64>();
+
+    async deploy(args: NonFungibleTokenBidContractDeployProps) {
+      await super.deploy(args);
+      this.whitelist.set(args.whitelist);
+      this.bids.set(args.bids);
+      this.storage.set(args.storage);
+      this.account.permissions.set({
+        ...Permissions.default(),
+        send: Permissions.proof(),
+        setVerificationKey:
+          Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+        setPermissions: Permissions.impossible(),
+      });
+    }
+
+    events = {
+      deposit: DepositEvent,
+      withdraw: WithdrawEvent,
+      sell: SellEvent,
+      updateWhitelist: Whitelist,
+      bid: BidEvent,
+    };
+
+    @method async initialize(amount: UInt64, maxPoints: UInt64) {
+      this.account.provedState.requireEquals(Bool(false));
+
+      const buyer = this.sender.getUnconstrained();
+      const buyerUpdate = AccountUpdate.createSigned(buyer);
+      // We use low-level subInPlace and addInPlace to decrease the number of AccountUpdates
+      buyerUpdate.balance.subInPlace(amount.add(UInt64.from(1_000_000_000)));
+      this.self.balance.addInPlace(amount);
+      buyerUpdate.body.useFullCommitment = Bool(true);
+
+      this.buyer.set(buyer);
+      this.maxPoints.set(maxPoints);
+      this.emitEvent(
+        "deposit",
+        new DepositEvent({
+          buyer,
+          amount,
+          maxPoints,
+        })
+      );
+    }
+
+    getCollectionContract(address: PublicKey): NFTCollectionBase {
+      const CollectionContract = collectionContract();
+      return new CollectionContract(address);
+    }
+
+    @method async deposit(amount: UInt64, maxPoints: UInt64) {
+      amount.equals(UInt64.from(0)).assertFalse();
+
+      const sender = this.sender.getUnconstrained();
+      const buyer = this.buyer.getAndRequireEquals();
+      sender.assertEquals(buyer);
+      const buyerUpdate = AccountUpdate.createSigned(buyer);
+      buyerUpdate.send({ to: this.address, amount });
+      buyerUpdate.body.useFullCommitment = Bool(true);
+
+      this.maxPoints.set(maxPoints);
+
+      this.emitEvent(
+        "deposit",
+        new DepositEvent({
+          buyer,
+          amount,
+          maxPoints,
+        })
+      );
+    }
+
+    @method async withdraw(amount: UInt64, maxPoints: UInt64) {
+      amount.equals(UInt64.from(0)).assertFalse();
+      this.account.balance.requireBetween(amount, UInt64.MAXINT());
+
+      const buyer = this.buyer.getAndRequireEquals();
+      const sender = this.sender.getUnconstrained();
+      const senderUpdate = AccountUpdate.createSigned(sender);
+      senderUpdate.body.useFullCommitment = Bool(true);
+      sender.assertEquals(buyer);
+
+      let bidUpdate = this.send({ to: senderUpdate, amount });
+      bidUpdate.body.useFullCommitment = Bool(true);
+      this.maxPoints.set(maxPoints);
+      this.emitEvent(
+        "withdraw",
+        new WithdrawEvent({
+          buyer,
+          amount,
+          maxPoints,
+        })
+      );
+    }
+
+    @method async sell(nftAddress: NFTAddress, price: UInt64) {
+      await this._sell(nftAddress, price);
+      const buyer = this.buyer.getAndRequireEquals();
+      const Collection = collectionContract();
+      const collection = new Collection(nftAddress.collection);
+      await collection.transferBySignature(
+        new TransferParams({
+          address: nftAddress.nft,
+          from: PublicKey.empty(),
+          to: buyer,
+          price: UInt64Option.fromValue(price),
+          context: new NFTTransactionContext({
+            custom: [Field(0), Field(0), Field(0)],
+          }),
+        })
+      );
+    }
+
+    @method async approvedSell(nftAddress: NFTAddress, price: UInt64) {
+      await this._sell(nftAddress, price);
+      const buyer = this.buyer.getAndRequireEquals();
+      const Collection = collectionContract();
+      const collection = new Collection(nftAddress.collection);
+      await collection.approvedTransferBySignature(
+        new TransferParams({
+          address: nftAddress.nft,
+          from: PublicKey.empty(),
+          to: buyer,
+          price: UInt64Option.fromValue(price),
+          context: new NFTTransactionContext({
+            custom: [Field(0), Field(0), Field(0)],
+          }),
+        })
+      );
+    }
+
+    async _sell(nftAddress: NFTAddress, price: UInt64) {
+      price.equals(UInt64.from(0)).assertFalse();
+      const key = Poseidon.hashPacked(NFTAddress, nftAddress);
+      const storage = this.storage.getAndRequireEquals();
+      const bids = new OffChainList({
+        root: this.bids.getAndRequireEquals(),
+        storage,
+      });
+      const bid = Bid.unpack(
+        (await bids.getValue(key, "bids")).assertSome("bid not found")
+      );
+
+      // We do not require the price to be equal to the bid price,
+      // because the price can be lower than the bid price
+      // and the seller can still be willing to sell the NFT
+      // as the deposit remaining is less than bid price
+      price.assertLessThanOrEqual(bid.price, "price is too high");
+      this.account.balance.requireBetween(price, UInt64.MAXINT());
+
+      const consumedPoints = this.consumedPoints.getAndRequireEquals();
+      const maxPoints = this.maxPoints.getAndRequireEquals();
+      const newConsumedPoints = consumedPoints.add(bid.points);
+      newConsumedPoints.assertLessThanOrEqual(
+        maxPoints,
+        "consumed points exceed max points"
+      );
+      this.consumedPoints.set(newConsumedPoints);
+
+      const seller = this.sender.getUnconstrained();
+      const sellerUpdate = AccountUpdate.createSigned(seller);
+      sellerUpdate.balance.addInPlace(price);
+      this.self.balance.subInPlace(price);
+      sellerUpdate.body.useFullCommitment = Bool(true);
+
+      const whitelist = new Whitelist({
+        list: new OffChainList({
+          root: this.whitelist.getAndRequireEquals(),
+          storage,
+        }),
+      });
+      const whitelistedAmount = await whitelist.getWhitelistedAmount(
+        seller,
+        "whitelist"
+      );
+      const whitelistDisabled = whitelist.isNone();
+      whitelistedAmount.isSome
+        .or(whitelistDisabled)
+        .assertTrue("Cannot buy from non-whitelisted address");
+      const maxPrice = Provable.if(
+        whitelistDisabled,
+        UInt64.MAXINT(),
+        whitelistedAmount.value
+      );
+      price.assertLessThanOrEqual(
+        maxPrice,
+        "price is higher than whitelisted price"
+      );
+
+      this.emitEvent(
+        "sell",
+        new SellEvent({
+          collection: nftAddress.collection,
+          nft: nftAddress.nft,
+          price,
+        })
+      );
+    }
+
+    @method async bid(bids: Field, whitelist: Field, storage: Storage) {
+      const buyer = this.buyer.getAndRequireEquals();
+      const sender = this.sender.getUnconstrained();
+      const senderUpdate = AccountUpdate.createSigned(sender);
+      senderUpdate.body.useFullCommitment = Bool(true);
+      sender.assertEquals(buyer);
+
+      this.bids.set(bids);
+      this.whitelist.set(whitelist);
+      this.storage.set(storage);
+      this.emitEvent("bid", new BidEvent({ bids, whitelist, storage }));
+    }
+  }
+
+  return NonFungibleTokenBidContract;
+}

package/src/marketplace/index.ts

@@ -0,0 +1,5 @@
+export * from "./bid.js";
+export * from "./offer.js";
+export * from "./auction.js";
+export * from "./types.js";
+export * from "./nft-shares.js";

package/src/marketplace/nft-shares.ts

@@ -0,0 +1,388 @@
+import {
+  AccountUpdate,
+  Bool,
+  DeployArgs,
+  method,
+  Permissions,
+  PublicKey,
+  SmartContract,
+  State,
+  state,
+  VerificationKey,
+  UInt64,
+  Field,
+  Struct,
+  Provable,
+  TokenId,
+} from "o1js";
+import {
+  FungibleTokenAdminBase,
+  FungibleTokenContract,
+} from "@silvana-one/token";
+import { NFTOwnerBase, TransferExtendedParams } from "../interfaces/index.js";
+import { Auction, AuctionFactory } from "./auction.js";
+
+export interface NFTSharesAdminDeployProps
+  extends Exclude<DeployArgs, undefined> {
+  admin: PublicKey;
+  owner: PublicKey; // The owner of the NFT
+}
+
+export interface NFTSharesOwnerDeployProps
+  extends Exclude<DeployArgs, undefined> {
+  admin: PublicKey;
+  owner: PublicKey;
+  collection: PublicKey;
+  nft: PublicKey;
+  auction: PublicKey;
+  maxBuyPrice: UInt64;
+  minSellPrice: UInt64;
+  uri: string;
+}
+
+export class NFTSharesDataPacked extends Struct({
+  adminX: Field,
+  ownerX: Field,
+  collectionX: Field,
+  nftX: Field,
+  auctionX: Field,
+  data: Field,
+}) {}
+
+export class NFTSharesData extends Struct({
+  admin: PublicKey,
+  owner: PublicKey,
+  collection: PublicKey,
+  nft: PublicKey,
+  auction: PublicKey,
+  maxBuyPrice: UInt64,
+  minSellPrice: UInt64,
+}) {
+  pack(): NFTSharesDataPacked {
+    const data = Field.fromBits([
+      ...this.maxBuyPrice.value.toBits(64),
+      ...this.minSellPrice.value.toBits(64),
+      this.admin.isOdd,
+      this.owner.isOdd,
+      this.collection.isOdd,
+      this.nft.isOdd,
+      this.auction.isOdd,
+    ]);
+    return new NFTSharesDataPacked({
+      adminX: this.admin.x,
+      ownerX: this.owner.x,
+      collectionX: this.collection.x,
+      nftX: this.nft.x,
+      auctionX: this.auction.x,
+      data,
+    });
+  }
+  static unpack(packed: NFTSharesDataPacked): NFTSharesData {
+    const bits = packed.data.toBits(64 + 64 + 5);
+    const adminIsOdd = bits[64 + 64];
+    const ownerIsOdd = bits[64 + 64 + 1];
+    const collectionIsOdd = bits[64 + 64 + 2];
+    const nftIsOdd = bits[64 + 64 + 3];
+    const auctionIsOdd = bits[64 + 64 + 4];
+    const adminX = packed.adminX;
+    const ownerX = packed.ownerX;
+    const collectionX = packed.collectionX;
+    const nftX = packed.nftX;
+    const auctionX = packed.auctionX;
+    const admin = PublicKey.from({ x: adminX, isOdd: adminIsOdd });
+    const owner = PublicKey.from({ x: ownerX, isOdd: ownerIsOdd });
+    const collection = PublicKey.from({
+      x: collectionX,
+      isOdd: collectionIsOdd,
+    });
+    const nft = PublicKey.from({ x: nftX, isOdd: nftIsOdd });
+    const auction = PublicKey.from({ x: auctionX, isOdd: auctionIsOdd });
+    const maxBuyPrice = UInt64.Unsafe.fromField(
+      Field.fromBits(bits.slice(0, 64))
+    );
+    const minSellPrice = UInt64.Unsafe.fromField(
+      Field.fromBits(bits.slice(64, 64 + 64))
+    );
+    return new NFTSharesData({
+      admin,
+      owner,
+      collection,
+      nft,
+      auction,
+      maxBuyPrice,
+      minSellPrice,
+    });
+  }
+}
+
+export type DefineNFTSharesFactory = (params: {
+  auctionContract: () => ReturnType<typeof AuctionFactory>;
+}) => ReturnType<typeof NFTSharesFactory>;
+
+export function NFTSharesFactory(params: {
+  auctionContract: () => ReturnType<typeof AuctionFactory>;
+}) {
+  const { auctionContract } = params;
+
+  class NFTSharesAdmin extends SmartContract implements FungibleTokenAdminBase {
+    @state(PublicKey) admin = State<PublicKey>();
+    @state(PublicKey) owner = State<PublicKey>();
+
+    async deploy(props: NFTSharesAdminDeployProps) {
+      await super.deploy(props);
+      this.admin.set(props.admin);
+      this.owner.set(props.owner);
+      this.account.permissions.set({
+        ...Permissions.default(),
+        setVerificationKey:
+          Permissions.VerificationKey.proofDuringCurrentVersion(),
+        setPermissions: Permissions.impossible(),
+      });
+    }
+
+    @method
+    async updateVerificationKey(vk: VerificationKey) {
+      this.ensureAdminSignature();
+      this.account.verificationKey.set(vk);
+    }
+
+    ensureAdminSignature(): AccountUpdate {
+      const admin = this.admin.getAndRequireEquals();
+      return AccountUpdate.createSigned(admin);
+    }
+
+    getOwner(): NFTSharesOwner {
+      return new NFTSharesOwner(this.owner.getAndRequireEquals());
+    }
+
+    @method.returns(Bool)
+    public async canMint(_accountUpdate: AccountUpdate) {
+      const owner = this.getOwner();
+      return await owner.canMint(_accountUpdate);
+    }
+
+    @method.returns(Bool)
+    public async canChangeAdmin(_admin: PublicKey) {
+      this.ensureAdminSignature();
+      return Bool(true);
+    }
+
+    @method.returns(Bool)
+    public async canPause(): Promise<Bool> {
+      this.ensureAdminSignature();
+      return Bool(true);
+    }
+
+    @method.returns(Bool)
+    public async canResume(): Promise<Bool> {
+      this.ensureAdminSignature();
+      return Bool(true);
+    }
+
+    @method.returns(Bool)
+    public async canChangeVerificationKey(_vk: VerificationKey): Promise<Bool> {
+      this.ensureAdminSignature();
+      return Bool(true);
+    }
+  }
+
+  const FungibleToken = FungibleTokenContract(NFTSharesAdmin);
+
+  class NFTSharesOwner extends SmartContract implements NFTOwnerBase {
+    /**
+     * The public key of the contract's administrator.
+     * This account has the authority to perform administrative actions such as pausing the contract or upgrading the verification key.
+     */
+    @state(NFTSharesDataPacked) data = State<NFTSharesDataPacked>(); // FungibleTokenAdmin
+    @state(Bool) subscriptionOpen = State<Bool>(Bool(true));
+    @state(UInt64) sharesOutstanding = State<UInt64>(UInt64.zero);
+
+    /**
+     * Deploys the contract with initial settings.
+     * @param props - Deployment properties including admin, upgradeAuthority, uri, canPause, and isPaused.
+     */
+    async deploy(props: NFTSharesOwnerDeployProps) {
+      await super.deploy(props);
+      this.data.set(
+        new NFTSharesData({
+          admin: props.admin,
+          owner: props.owner,
+          collection: props.collection,
+          nft: props.nft,
+          auction: props.auction,
+          maxBuyPrice: props.maxBuyPrice,
+          minSellPrice: props.minSellPrice,
+        }).pack()
+      );
+      this.account.zkappUri.set(props.uri);
+      this.subscriptionOpen.set(Bool(true));
+      this.sharesOutstanding.set(UInt64.zero);
+      this.account.permissions.set({
+        ...Permissions.default(),
+        // Allow the upgrade authority to set the verification key even without a protocol upgrade,
+        // enabling upgrades in case of o1js breaking changes.
+        setVerificationKey:
+          Permissions.VerificationKey.proofDuringCurrentVersion(),
+        setPermissions: Permissions.impossible(),
+      });
+    }
+
+    /**
+     * Ensures that the transaction is authorized by the contract owner.
+     * @returns A signed `AccountUpdate` from the admin.
+     */
+    ensureOwnerSignature(): NFTSharesData {
+      const data = NFTSharesData.unpack(this.data.getAndRequireEquals());
+      const adminUpdate = AccountUpdate.createSigned(data.admin);
+      adminUpdate.body.useFullCommitment = Bool(true); // Prevent memo and fee change
+      return data;
+    }
+
+    getAuction(auction: PublicKey) {
+      return new (auctionContract())(auction);
+    }
+    /**
+     * Allows the owner to mint shares.
+     * This method should NOT called directly, but through the FungibleToken.mint()
+     *
+     * @param _accountUpdate - The account update containing the sender's information.
+     * @returns A boolean indicating if the minting is allowed.
+     */
+    @method.returns(Bool)
+    async canMint(_accountUpdate: AccountUpdate): Promise<Bool> {
+      const subscriptionOpen = this.subscriptionOpen.getAndRequireEquals();
+      subscriptionOpen.assertEquals(Bool(true), "Subscription is closed");
+      const address = _accountUpdate.publicKey;
+      const amount = _accountUpdate.balanceChange.magnitude;
+      const senderUpdate = AccountUpdate.createSigned(address);
+      // 1 share = 1 MINA
+      senderUpdate.balance.subInPlace(amount);
+      this.balance.addInPlace(amount);
+      const sharesOutstanding = this.sharesOutstanding.getAndRequireEquals();
+      this.sharesOutstanding.set(sharesOutstanding.add(amount));
+      return Bool(true);
+    }
+
+    @method
+    async withdraw(shares: UInt64) {
+      const subscriptionOpen = this.subscriptionOpen.getAndRequireEquals();
+      subscriptionOpen.assertEquals(
+        Bool(false),
+        "Subscription is not closed, cannot withdraw"
+      );
+      const sharesOutstanding = this.sharesOutstanding.getAndRequireEquals();
+      const balance = this.account.balance.getAndRequireEquals();
+      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 sender = this.sender.getUnconstrained();
+      const senderUpdate = AccountUpdate.createSigned(sender);
+      senderUpdate.balance.addInPlace(amountInMina);
+      this.balance.subInPlace(amountInMina);
+      senderUpdate.body.useFullCommitment = Bool(true);
+      this.sharesOutstanding.set(sharesOutstanding.sub(shares));
+      const data = NFTSharesData.unpack(this.data.getAndRequireEquals());
+      const token = new FungibleToken(data.owner);
+      await token.burn(sender, shares);
+    }
+
+    @method
+    async closeSubscription() {
+      const data = this.ensureOwnerSignature();
+      const maxBuyPrice = data.maxBuyPrice;
+      this.account.balance.requireBetween(maxBuyPrice, UInt64.MAXINT());
+      this.subscriptionOpen.set(Bool(false));
+    }
+
+    @method
+    async bid(price: UInt64) {
+      const data = NFTSharesData.unpack(this.data.getAndRequireEquals());
+      const maxBuyPrice = data.maxBuyPrice;
+      price.assertLessThanOrEqual(maxBuyPrice, "Price is too high");
+      this.account.balance.requireBetween(price, UInt64.MAXINT());
+      this.subscriptionOpen.set(Bool(false));
+      const sharesOutstanding = this.sharesOutstanding.getAndRequireEquals();
+      const auction = this.getAuction(data.auction);
+      const sender = this.sender.getUnconstrained();
+      const senderUpdate = AccountUpdate.createSigned(sender);
+      const tokenId = TokenId.derive(data.owner);
+      const tokenUpdate = AccountUpdate.create(sender, tokenId);
+      const tokenBalance = tokenUpdate.account.balance.getAndRequireEquals();
+      const token = new FungibleToken(data.owner);
+      await token.approveAccountUpdate(tokenUpdate);
+
+      tokenBalance
+        .mul(4)
+        .assertGreaterThanOrEqual(
+          sharesOutstanding,
+          "Not enough shares to bid, minimum is 25% of the shares outstanding"
+        );
+
+      senderUpdate.balance.addInPlace(price);
+      this.balance.subInPlace(price);
+      senderUpdate.body.useFullCommitment = Bool(true);
+      await auction.bid(price, this.address);
+    }
+
+    @method.returns(Bool)
+    async canTransfer(params: TransferExtendedParams): Promise<Bool> {
+      const data = NFTSharesData.unpack(this.data.getAndRequireEquals());
+      params.collection.assertEquals(data.collection);
+      params.nft.assertEquals(data.nft);
+      const amount = params.price.assertSome();
+      amount.assertGreaterThanOrEqual(data.minSellPrice, "Price is too low");
+      const sender = this.sender.getUnconstrained();
+      const senderUpdate = AccountUpdate.createSigned(sender);
+      senderUpdate.balance.subInPlace(amount);
+      senderUpdate.body.useFullCommitment = Bool(true);
+      this.balance.addInPlace(amount);
+      return Bool(true);
+    }
+
+    @method.returns(Bool)
+    async canPause(collection: PublicKey, nft: PublicKey): Promise<Bool> {
+      this.ensureOwnerSignature();
+      return Bool(true);
+    }
+
+    @method.returns(Bool)
+    async canResume(collection: PublicKey, nft: PublicKey): Promise<Bool> {
+      this.ensureOwnerSignature();
+      return Bool(true);
+    }
+
+    @method.returns(Bool)
+    async canChangeVerificationKey(
+      collection: PublicKey,
+      nft: PublicKey,
+      vk: VerificationKey
+    ): Promise<Bool> {
+      this.ensureOwnerSignature();
+      return Bool(true);
+    }
+
+    @method.returns(Bool)
+    async canApproveAddress(
+      collection: PublicKey,
+      nft: PublicKey,
+      approved: PublicKey
+    ): Promise<Bool> {
+      this.ensureOwnerSignature();
+      return Bool(true);
+    }
+  }
+
+  return {
+    NFTSharesAdmin,
+    NFTSharesOwner,
+    FungibleToken,
+  };
+}