@silvana-one/token 0.1.0

package/src/bid.ts

@@ -0,0 +1,170 @@
+import {
+  AccountUpdate,
+  DeployArgs,
+  method,
+  Permissions,
+  PublicKey,
+  State,
+  state,
+  UInt64,
+  SmartContract,
+  Bool,
+  Field,
+  Struct,
+} from "o1js";
+import { Whitelist } from "@silvana-one/storage";
+import { FungibleToken } from "./FungibleToken.js";
+
+export interface FungibleTokenBidContractDeployProps
+  extends Exclude<DeployArgs, undefined> {
+  /** The whitelist. */
+  whitelist: Whitelist;
+}
+
+export class BidEvent extends Struct({
+  amount: UInt64,
+  address: PublicKey,
+}) {}
+
+export class FungibleTokenBidContract extends SmartContract {
+  @state(UInt64) price = State<UInt64>();
+  @state(PublicKey) buyer = State<PublicKey>();
+  @state(PublicKey) token = State<PublicKey>();
+  @state(Whitelist) whitelist = State<Whitelist>();
+
+  async deploy(args: FungibleTokenBidContractDeployProps) {
+    await super.deploy(args);
+    this.whitelist.set(args.whitelist);
+    this.account.permissions.set({
+      ...Permissions.default(),
+      send: Permissions.proof(),
+      setVerificationKey:
+        Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: Permissions.impossible(),
+    });
+  }
+
+  events = {
+    bid: BidEvent,
+    withdraw: BidEvent,
+    sell: BidEvent,
+    updateWhitelist: Whitelist,
+  };
+
+  @method async initialize(token: PublicKey, amount: UInt64, price: UInt64) {
+    this.account.provedState.requireEquals(Bool(false));
+    amount.equals(UInt64.from(0)).assertFalse();
+
+    const totalPriceField = price.value
+      .mul(amount.value)
+      .div(Field(1_000_000_000));
+    totalPriceField.assertLessThan(
+      UInt64.MAXINT().value,
+      "totalPrice overflow"
+    );
+    const totalPrice = UInt64.Unsafe.fromField(totalPriceField);
+
+    const buyer = this.sender.getUnconstrained();
+    const buyerUpdate = AccountUpdate.createSigned(buyer);
+    buyerUpdate.send({ to: this.address, amount: totalPrice });
+    buyerUpdate.body.useFullCommitment = Bool(true);
+
+    this.buyer.set(buyer);
+    this.price.set(price);
+    this.token.set(token);
+    this.emitEvent("bid", { amount, address: buyer } as BidEvent);
+  }
+
+  @method async bid(amount: UInt64, price: UInt64) {
+    amount.equals(UInt64.from(0)).assertFalse();
+
+    const balance = this.account.balance.getAndRequireEquals();
+    const oldPrice = this.price.getAndRequireEquals();
+    // Price can be changed only when the balance is 0
+    price
+      .equals(oldPrice)
+      .or(balance.equals(UInt64.from(0)))
+      .assertTrue();
+    this.price.set(price);
+
+    const totalPriceField = price.value
+      .mul(amount.value)
+      .div(Field(1_000_000_000));
+    totalPriceField.assertLessThan(
+      UInt64.MAXINT().value,
+      "totalPrice overflow"
+    );
+    const totalPrice = UInt64.Unsafe.fromField(totalPriceField);
+
+    const sender = this.sender.getUnconstrained();
+    const buyer = this.buyer.getAndRequireEquals();
+    sender.assertEquals(buyer);
+    const buyerUpdate = AccountUpdate.createSigned(buyer);
+    buyerUpdate.send({ to: this.address, amount: totalPrice });
+    buyerUpdate.body.useFullCommitment = Bool(true);
+
+    this.price.set(price);
+    this.emitEvent("bid", { amount, address: buyer } as BidEvent);
+  }
+
+  @method async withdraw(amountInMina: UInt64) {
+    amountInMina.equals(UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amountInMina, 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: amountInMina });
+    bidUpdate.body.useFullCommitment = Bool(true);
+    this.emitEvent("withdraw", {
+      amount: amountInMina,
+      address: buyer,
+    } as BidEvent);
+  }
+
+  @method async sell(amount: UInt64) {
+    amount.equals(UInt64.from(0)).assertFalse();
+    const price = this.price.getAndRequireEquals();
+    const totalPriceField = price.value
+      .mul(amount.value)
+      .div(Field(1_000_000_000));
+    totalPriceField.assertLessThan(
+      UInt64.MAXINT().value,
+      "totalPrice overflow"
+    );
+    const totalPrice = UInt64.Unsafe.fromField(totalPriceField);
+
+    this.account.balance.requireBetween(totalPrice, UInt64.MAXINT());
+    const buyer = this.buyer.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+
+    const seller = this.sender.getUnconstrained();
+    const sellerUpdate = this.send({ to: seller, amount: totalPrice });
+    sellerUpdate.body.useFullCommitment = Bool(true);
+    sellerUpdate.requireSignature();
+
+    const tokenContract = new FungibleToken(token);
+    await tokenContract.transfer(seller, buyer, amount);
+
+    const whitelist = this.whitelist.getAndRequireEquals();
+    const whitelistedAmount = await whitelist.getWhitelistedAmount(seller);
+    amount.assertLessThanOrEqual(
+      whitelistedAmount.assertSome("Cannot sell more than whitelisted amount")
+    );
+    this.emitEvent("sell", { amount, address: seller } as BidEvent);
+  }
+
+  @method async updateWhitelist(whitelist: Whitelist) {
+    const buyer = this.buyer.getAndRequireEquals();
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = Bool(true);
+    sender.assertEquals(buyer);
+
+    this.whitelist.set(whitelist);
+    this.emitEvent("updateWhitelist", whitelist);
+  }
+}

package/src/claim.ts

@@ -0,0 +1,151 @@
+import {
+  AccountUpdate,
+  DeployArgs,
+  method,
+  Permissions,
+  PublicKey,
+  State,
+  state,
+  UInt64,
+  SmartContract,
+  Bool,
+  Field,
+  Struct,
+  Provable,
+} from "o1js";
+import { Whitelist } from "@silvana-one/storage";
+import { FungibleToken } from "./FungibleToken.js";
+
+class ClaimEvent extends Struct({
+  amount: UInt64,
+  address: PublicKey,
+}) {}
+
+export interface FungibleTokenClaimContractDeployProps
+  extends Exclude<DeployArgs, undefined> {
+  /** The whitelist. */
+  whitelist: Whitelist;
+  /** The maximum amount of tokens to claim in case the whitelist is empty. */
+  maxAmount?: UInt64;
+}
+export class FungibleTokenClaimContract extends SmartContract {
+  @state(PublicKey) owner = State<PublicKey>();
+  @state(PublicKey) token = State<PublicKey>();
+  @state(Whitelist) whitelist = State<Whitelist>();
+  @state(UInt64) maxAmount = State<UInt64>();
+
+  async deploy(args: FungibleTokenClaimContractDeployProps) {
+    await super.deploy(args);
+    this.whitelist.set(args.whitelist);
+    this.maxAmount.set(args.maxAmount ?? UInt64.MAXINT());
+    this.account.permissions.set({
+      ...Permissions.default(),
+      send: Permissions.proof(),
+      setVerificationKey:
+        Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: Permissions.impossible(),
+    });
+  }
+
+  events = {
+    offer: ClaimEvent,
+    withdraw: ClaimEvent,
+    claim: ClaimEvent,
+    updateWhitelist: Whitelist,
+  };
+
+  @method async initialize(
+    owner: PublicKey, // we are short of AccountUpdates here, so we use this parameter instead of this.sender.getUnconstrained()
+    token: PublicKey,
+    amount: UInt64
+  ) {
+    this.account.provedState.requireEquals(Bool(false));
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+    await tokenContract.transfer(owner, this.address, amount);
+
+    this.owner.set(owner);
+    this.token.set(token);
+    this.emitEvent("offer", { amount, address: owner } as ClaimEvent);
+  }
+
+  @method async offer(amount: UInt64) {
+    const owner = this.owner.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = Bool(true);
+    sender.assertEquals(owner);
+
+    await tokenContract.transfer(sender, this.address, amount);
+    this.emitEvent("offer", { amount, address: sender } as ClaimEvent);
+  }
+
+  @method async withdraw(amount: UInt64) {
+    amount.equals(UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amount, UInt64.MAXINT());
+
+    const owner = this.owner.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = AccountUpdate.createSigned(sender, tokenId);
+    senderUpdate.body.useFullCommitment = Bool(true);
+    sender.assertEquals(owner);
+
+    let offerUpdate = this.send({ to: senderUpdate, amount });
+    offerUpdate.body.mayUseToken = AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = Bool(true);
+    this.emitEvent("withdraw", { amount, address: sender } as ClaimEvent);
+  }
+
+  @method async claim(amount: UInt64) {
+    const maxAmount = this.maxAmount.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = AccountUpdate.createSigned(sender, tokenId);
+    senderUpdate.body.useFullCommitment = Bool(true);
+
+    const whitelist = this.whitelist.getAndRequireEquals();
+    const whiteListedAmount = await whitelist.getWhitelistedAmount(sender);
+    const maxClaimAmount = Provable.if(
+      whitelist.isSome(),
+      whiteListedAmount.assertSome("No tokens to claim"),
+      maxAmount
+    );
+    amount.assertLessThanOrEqual(maxClaimAmount);
+    this.account.balance.requireBetween(amount, UInt64.MAXINT());
+
+    let offerUpdate = this.send({ to: senderUpdate, amount });
+    offerUpdate.body.mayUseToken = AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = Bool(true);
+
+    this.emitEvent("claim", {
+      amount,
+      address: sender,
+    } as ClaimEvent);
+  }
+
+  @method async updateWhitelist(whitelist: Whitelist) {
+    const owner = this.owner.getAndRequireEquals();
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = Bool(true);
+    sender.assertEquals(owner);
+
+    this.whitelist.set(whitelist);
+    this.emitEvent("updateWhitelist", whitelist);
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from "./bid.js";
+export * from "./claim.js";
+export * from "./offer.js";
+export * from "./FungibleToken.js";
+export * from "./FungibleTokenStandardAdmin.js";
+export * from "./FungibleTokenAdvancedAdmin.js";
+export * from "./FungibleTokenContract.js";
+export * from "./BondingCurveAdmin.js";

package/src/offer.ts

@@ -0,0 +1,164 @@
+import {
+  AccountUpdate,
+  DeployArgs,
+  method,
+  Permissions,
+  PublicKey,
+  State,
+  state,
+  UInt64,
+  SmartContract,
+  Bool,
+  Field,
+  Struct,
+} from "o1js";
+import { Whitelist } from "@silvana-one/storage";
+import { FungibleToken } from "./FungibleToken.js";
+
+export interface FungibleTokenOfferContractDeployProps
+  extends Exclude<DeployArgs, undefined> {
+  /** The whitelist. */
+  whitelist: Whitelist;
+}
+
+export class OfferEvent extends Struct({
+  amount: UInt64,
+  address: PublicKey,
+}) {}
+
+export class FungibleTokenOfferContract extends SmartContract {
+  @state(UInt64) price = State<UInt64>();
+  @state(PublicKey) seller = State<PublicKey>();
+  @state(PublicKey) token = State<PublicKey>();
+  @state(Whitelist) whitelist = State<Whitelist>();
+
+  async deploy(args: FungibleTokenOfferContractDeployProps) {
+    await super.deploy(args);
+    this.whitelist.set(args.whitelist);
+    this.account.permissions.set({
+      ...Permissions.default(),
+      send: Permissions.proof(),
+      setVerificationKey:
+        Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: Permissions.impossible(),
+    });
+  }
+
+  events = {
+    offer: OfferEvent,
+    withdraw: OfferEvent,
+    buy: OfferEvent,
+    updateWhitelist: Whitelist,
+  };
+
+  @method async initialize(
+    seller: PublicKey, // we are short of AccountUpdates here, so we use this parameter instead of this.sender.getUnconstrained()
+    token: PublicKey,
+    amount: UInt64,
+    price: UInt64
+  ) {
+    this.account.provedState.requireEquals(Bool(false));
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+    await tokenContract.transfer(seller, this.address, amount);
+
+    this.seller.set(seller);
+    this.price.set(price);
+    this.token.set(token);
+    this.emitEvent("offer", { amount, address: seller } as OfferEvent);
+  }
+
+  @method async offer(amount: UInt64, price: UInt64) {
+    const seller = this.seller.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+
+    const balance = this.account.balance.getAndRequireEquals();
+    const oldPrice = this.price.getAndRequireEquals();
+    // Price can be changed only when the balance is 0
+    price
+      .equals(oldPrice)
+      .or(balance.equals(UInt64.from(0)))
+      .assertTrue();
+    this.price.set(price);
+
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = Bool(true);
+    sender.assertEquals(seller);
+
+    await tokenContract.transfer(sender, this.address, amount);
+    this.emitEvent("offer", { amount, address: sender } as OfferEvent);
+  }
+
+  @method async withdraw(amount: UInt64) {
+    amount.equals(UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amount, UInt64.MAXINT());
+
+    const seller = this.seller.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = AccountUpdate.createSigned(sender, tokenId);
+    senderUpdate.body.useFullCommitment = Bool(true);
+    sender.assertEquals(seller);
+
+    let offerUpdate = this.send({ to: senderUpdate, amount });
+    offerUpdate.body.mayUseToken = AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = Bool(true);
+    this.emitEvent("withdraw", { amount, address: sender } as OfferEvent);
+  }
+
+  @method async buy(amount: UInt64) {
+    amount.equals(UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amount, UInt64.MAXINT());
+    const seller = this.seller.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+    const price = this.price.getAndRequireEquals();
+    const totalPriceField = price.value
+      .mul(amount.value)
+      .div(Field(1_000_000_000));
+    totalPriceField.assertLessThan(
+      UInt64.MAXINT().value,
+      "totalPrice overflow"
+    );
+    const totalPrice = UInt64.Unsafe.fromField(totalPriceField);
+
+    const buyer = this.sender.getUnconstrained();
+    const buyerUpdate = AccountUpdate.createSigned(buyer);
+    buyerUpdate.send({ to: seller, amount: totalPrice });
+    buyerUpdate.body.useFullCommitment = Bool(true);
+
+    let offerUpdate = this.send({ to: buyer, amount });
+    offerUpdate.body.mayUseToken = AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = Bool(true);
+
+    const whitelist = this.whitelist.getAndRequireEquals();
+    const whitelistedAmount = await whitelist.getWhitelistedAmount(buyer);
+    amount.assertLessThanOrEqual(
+      whitelistedAmount.assertSome("Cannot buy more than whitelisted amount")
+    );
+
+    this.emitEvent("buy", { amount, address: buyer } as OfferEvent);
+  }
+
+  @method async updateWhitelist(whitelist: Whitelist) {
+    const seller = this.seller.getAndRequireEquals();
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = Bool(true);
+    sender.assertEquals(seller);
+
+    this.whitelist.set(whitelist);
+    this.emitEvent("updateWhitelist", whitelist);
+  }
+}