zkcloudworker 0.18.8 → 0.18.10

package/src/mina/token/FungibleTokenContract.ts

@@ -0,0 +1,327 @@
+import {
+  AccountUpdate,
+  AccountUpdateForest,
+  assert,
+  Bool,
+  DeployArgs,
+  Field,
+  Int64,
+  method,
+  Permissions,
+  Provable,
+  PublicKey,
+  SmartContract,
+  State,
+  state,
+  Struct,
+  TokenContract,
+  Types,
+  UInt64,
+  UInt8,
+  VerificationKey,
+} from "o1js";
+
+export type FungibleTokenAdminBase = SmartContract & {
+  canMint(accountUpdate: AccountUpdate): Promise<Bool>;
+  canChangeAdmin(admin: PublicKey): Promise<Bool>;
+  canPause(): Promise<Bool>;
+  canResume(): Promise<Bool>;
+};
+
+export type FungibleTokenAdminConstructor = new (
+  adminPublicKey: PublicKey
+) => FungibleTokenAdminBase;
+
+export interface FungibleTokenDeployProps
+  extends Exclude<DeployArgs, undefined> {
+  /** The token symbol. */
+  symbol: string;
+  /** A source code reference, which is placed within the `zkappUri` of the contract account.
+   * Typically a link to a file on github. */
+  src: string;
+}
+
+export const FungibleTokenErrors = {
+  noAdminKey: "could not fetch admin contract key",
+  noPermissionToChangeAdmin: "Not allowed to change admin contract",
+  tokenPaused: "Token is currently paused",
+  noPermissionToMint: "Not allowed to mint tokens",
+  noPermissionToPause: "Not allowed to pause token",
+  noPermissionToResume: "Not allowed to resume token",
+  noTransferFromCirculation: "Can't transfer to/from the circulation account",
+  noPermissionChangeAllowed:
+    "Can't change permissions for access or receive on token accounts",
+  flashMinting:
+    "Flash-minting or unbalanced transaction detected. Please make sure that your transaction is balanced, and that your `AccountUpdate`s are ordered properly, so that tokens are not received before they are sent.",
+  unbalancedTransaction: "Transaction is unbalanced",
+};
+
+export function FungibleTokenContract(
+  adminContract: FungibleTokenAdminConstructor
+) {
+  class FungibleToken extends TokenContract {
+    @state(UInt8)
+    decimals = State<UInt8>();
+    @state(PublicKey)
+    admin = State<PublicKey>();
+    @state(Bool)
+    paused = State<Bool>();
+
+    readonly events = {
+      SetAdmin: SetAdminEvent,
+      Pause: PauseEvent,
+      Mint: MintEvent,
+      Burn: BurnEvent,
+      BalanceChange: BalanceChangeEvent,
+    };
+
+    async deploy(props: FungibleTokenDeployProps) {
+      await super.deploy(props);
+      this.paused.set(Bool(true));
+      this.account.zkappUri.set(props.src);
+      this.account.tokenSymbol.set(props.symbol);
+
+      this.account.permissions.set({
+        ...Permissions.default(),
+        setVerificationKey:
+          Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+        setPermissions: Permissions.impossible(),
+        access: Permissions.proof(),
+      });
+    }
+
+    /** Update the verification key.
+     * Note that because we have set the permissions for setting the verification key to `impossibleDuringCurrentVersion()`, this will only be possible in case of a protocol update that requires an update.
+     */
+    @method
+    async updateVerificationKey(vk: VerificationKey) {
+      this.account.verificationKey.set(vk);
+    }
+
+    /** Initializes the account for tracking total circulation.
+     * @argument {PublicKey} admin - public key where the admin contract is deployed
+     * @argument {UInt8} decimals - number of decimals for the token
+     * @argument {Bool} startPaused - if set to `Bool(true), the contract will start in a mode where token minting and transfers are paused. This should be used for non-atomic deployments
+     */
+    @method
+    async initialize(admin: PublicKey, decimals: UInt8, startPaused: Bool) {
+      this.account.provedState.requireEquals(Bool(false));
+
+      this.admin.set(admin);
+      this.decimals.set(decimals);
+      this.paused.set(Bool(false));
+
+      this.paused.set(startPaused);
+
+      const accountUpdate = AccountUpdate.createSigned(
+        this.address,
+        this.deriveTokenId()
+      );
+      let permissions = Permissions.default();
+      // This is necessary in order to allow token holders to burn.
+      permissions.send = Permissions.none();
+      permissions.setPermissions = Permissions.impossible();
+      accountUpdate.account.permissions.set(permissions);
+    }
+
+    public async getAdminContract(): Promise<FungibleTokenAdminBase> {
+      const admin = await Provable.witnessAsync(PublicKey, async () => {
+        let pk = await this.admin.fetch();
+        assert(pk !== undefined, FungibleTokenErrors.noAdminKey);
+        return pk;
+      });
+      this.admin.requireEquals(admin);
+      return new adminContract(admin);
+    }
+
+    @method
+    async setAdmin(admin: PublicKey) {
+      const adminContract = await this.getAdminContract();
+      const canChangeAdmin = await adminContract.canChangeAdmin(admin);
+      canChangeAdmin.assertTrue(FungibleTokenErrors.noPermissionToChangeAdmin);
+      this.admin.set(admin);
+      this.emitEvent("SetAdmin", new SetAdminEvent({ adminKey: admin }));
+    }
+
+    @method.returns(AccountUpdate)
+    async mint(recipient: PublicKey, amount: UInt64): Promise<AccountUpdate> {
+      this.paused
+        .getAndRequireEquals()
+        .assertFalse(FungibleTokenErrors.tokenPaused);
+      const accountUpdate = this.internal.mint({ address: recipient, amount });
+      const adminContract = await this.getAdminContract();
+      const canMint = await adminContract.canMint(accountUpdate);
+      canMint.assertTrue(FungibleTokenErrors.noPermissionToMint);
+      recipient
+        .equals(this.address)
+        .assertFalse(FungibleTokenErrors.noTransferFromCirculation);
+      this.approve(accountUpdate);
+      this.emitEvent("Mint", new MintEvent({ recipient, amount }));
+      const circulationUpdate = AccountUpdate.create(
+        this.address,
+        this.deriveTokenId()
+      );
+      circulationUpdate.balanceChange = Int64.fromUnsigned(amount);
+      return accountUpdate;
+    }
+
+    @method.returns(AccountUpdate)
+    async burn(from: PublicKey, amount: UInt64): Promise<AccountUpdate> {
+      this.paused
+        .getAndRequireEquals()
+        .assertFalse(FungibleTokenErrors.tokenPaused);
+      const accountUpdate = this.internal.burn({ address: from, amount });
+      const circulationUpdate = AccountUpdate.create(
+        this.address,
+        this.deriveTokenId()
+      );
+      from
+        .equals(this.address)
+        .assertFalse(FungibleTokenErrors.noTransferFromCirculation);
+      circulationUpdate.balanceChange = Int64.fromUnsigned(amount).neg();
+      this.emitEvent("Burn", new BurnEvent({ from, amount }));
+      return accountUpdate;
+    }
+
+    @method
+    async pause() {
+      const adminContract = await this.getAdminContract();
+      const canPause = await adminContract.canPause();
+      canPause.assertTrue(FungibleTokenErrors.noPermissionToPause);
+      this.paused.set(Bool(true));
+      this.emitEvent("Pause", new PauseEvent({ isPaused: Bool(true) }));
+    }
+
+    @method
+    async resume() {
+      const adminContract = await this.getAdminContract();
+      const canResume = await adminContract.canResume();
+      canResume.assertTrue(FungibleTokenErrors.noPermissionToResume);
+      this.paused.set(Bool(false));
+      this.emitEvent("Pause", new PauseEvent({ isPaused: Bool(false) }));
+    }
+
+    @method
+    async transfer(from: PublicKey, to: PublicKey, amount: UInt64) {
+      this.paused
+        .getAndRequireEquals()
+        .assertFalse(FungibleTokenErrors.tokenPaused);
+      from
+        .equals(this.address)
+        .assertFalse(FungibleTokenErrors.noTransferFromCirculation);
+      to.equals(this.address).assertFalse(
+        FungibleTokenErrors.noTransferFromCirculation
+      );
+      this.internal.send({ from, to, amount });
+    }
+
+    checkPermissionsUpdate(update: AccountUpdate) {
+      let permissions = update.update.permissions;
+
+      let { access, receive } = permissions.value;
+      let accessIsNone = Provable.equal(
+        Types.AuthRequired,
+        access,
+        Permissions.none()
+      );
+      let receiveIsNone = Provable.equal(
+        Types.AuthRequired,
+        receive,
+        Permissions.none()
+      );
+      let updateAllowed = accessIsNone.and(receiveIsNone);
+
+      assert(
+        updateAllowed.or(permissions.isSome.not()),
+        FungibleTokenErrors.noPermissionChangeAllowed
+      );
+    }
+
+    /** Approve `AccountUpdate`s that have been created outside of the token contract.
+     *
+     * @argument {AccountUpdateForest} updates - The `AccountUpdate`s to approve. Note that the forest size is limited by the base token contract, @see TokenContract.MAX_ACCOUNT_UPDATES The current limit is 9.
+     */
+    @method
+    async approveBase(updates: AccountUpdateForest): Promise<void> {
+      this.paused
+        .getAndRequireEquals()
+        .assertFalse(FungibleTokenErrors.tokenPaused);
+      let totalBalance = Int64.from(0);
+      this.forEachUpdate(updates, (update, usesToken) => {
+        // Make sure that the account permissions are not changed
+        this.checkPermissionsUpdate(update);
+        this.emitEventIf(
+          usesToken,
+          "BalanceChange",
+          new BalanceChangeEvent({
+            address: update.publicKey,
+            amount: update.balanceChange,
+          })
+        );
+        // Don't allow transfers to/from the account that's tracking circulation
+        update.publicKey
+          .equals(this.address)
+          .and(usesToken)
+          .assertFalse(FungibleTokenErrors.noTransferFromCirculation);
+        totalBalance = Provable.if(
+          usesToken,
+          totalBalance.add(update.balanceChange),
+          totalBalance
+        );
+        totalBalance.isPositive().assertFalse(FungibleTokenErrors.flashMinting);
+      });
+      totalBalance.assertEquals(
+        Int64.zero,
+        FungibleTokenErrors.unbalancedTransaction
+      );
+    }
+
+    @method.returns(UInt64)
+    async getBalanceOf(address: PublicKey): Promise<UInt64> {
+      const account = AccountUpdate.create(
+        address,
+        this.deriveTokenId()
+      ).account;
+      const balance = account.balance.get();
+      account.balance.requireEquals(balance);
+      return balance;
+    }
+
+    /** Reports the current circulating supply
+     * This does take into account currently unreduced actions.
+     */
+    async getCirculating(): Promise<UInt64> {
+      let circulating = await this.getBalanceOf(this.address);
+      return circulating;
+    }
+
+    @method.returns(UInt8)
+    async getDecimals(): Promise<UInt8> {
+      return this.decimals.getAndRequireEquals();
+    }
+  }
+  return FungibleToken;
+}
+
+export class SetAdminEvent extends Struct({
+  adminKey: PublicKey,
+}) {}
+
+export class PauseEvent extends Struct({
+  isPaused: Bool,
+}) {}
+
+export class MintEvent extends Struct({
+  recipient: PublicKey,
+  amount: UInt64,
+}) {}
+
+export class BurnEvent extends Struct({
+  from: PublicKey,
+  amount: UInt64,
+}) {}
+
+export class BalanceChangeEvent extends Struct({
+  address: PublicKey,
+  amount: Int64,
+}) {}

package/src/mina/token/FungibleTokenWhitelistedAdmin.ts

@@ -0,0 +1,112 @@
+import {
+  AccountUpdate,
+  assert,
+  Bool,
+  DeployArgs,
+  method,
+  Permissions,
+  Provable,
+  PublicKey,
+  SmartContract,
+  State,
+  state,
+  UInt64,
+  VerificationKey,
+} from "o1js";
+import { Whitelist } from "./whitelist.js";
+import { FungibleTokenAdminBase } from "./FungibleTokenContract.js";
+
+export interface FungibleTokenWhitelistedAdminDeployProps
+  extends Exclude<DeployArgs, undefined> {
+  adminPublicKey: PublicKey;
+  whitelist: Whitelist;
+}
+
+/** A contract that grants permissions for administrative actions on a token.
+ *
+ * We separate this out into a dedicated contract. That way, when issuing a token, a user can
+ * specify their own rules for administrative actions, without changing the token contract itself.
+ *
+ * The advantage is that third party applications that only use the token in a non-privileged way
+ * can integrate against the unchanged token contract.
+ */
+export class FungibleTokenWhitelistedAdmin
+  extends SmartContract
+  implements FungibleTokenAdminBase
+{
+  @state(PublicKey) adminPublicKey = State<PublicKey>();
+  @state(Whitelist) whitelist = State<Whitelist>();
+
+  async deploy(props: FungibleTokenWhitelistedAdminDeployProps) {
+    await super.deploy(props);
+    this.adminPublicKey.set(props.adminPublicKey);
+    this.whitelist.set(props.whitelist);
+    this.account.permissions.set({
+      ...Permissions.default(),
+      setVerificationKey:
+        Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: Permissions.impossible(),
+    });
+  }
+
+  events = { updateWhitelist: Whitelist };
+
+  /** Update the verification key.
+   * Note that because we have set the permissions for setting the verification key to `impossibleDuringCurrentVersion()`, this will only be possible in case of a protocol update that requires an update.
+   */
+  @method
+  async updateVerificationKey(vk: VerificationKey) {
+    this.account.verificationKey.set(vk);
+  }
+
+  private async ensureAdminSignature() {
+    const admin = await Provable.witnessAsync(PublicKey, async () => {
+      let pk = await this.adminPublicKey.fetch();
+      assert(pk !== undefined, "could not fetch admin public key");
+      return pk;
+    });
+    this.adminPublicKey.requireEquals(admin);
+    return AccountUpdate.createSigned(admin);
+  }
+
+  @method.returns(Bool)
+  public async canMint(_accountUpdate: AccountUpdate) {
+    const address = _accountUpdate.body.publicKey;
+    const balanceChange = _accountUpdate.body.balanceChange;
+    balanceChange.isPositive().assertTrue();
+    const whitelist = this.whitelist.getAndRequireEquals();
+    const whitelistedAmount = await whitelist.getWhitelistedAmount(address);
+    return balanceChange.magnitude.lessThanOrEqual(
+      whitelistedAmount.orElse(UInt64.from(0)) // here can be a minimum amount allowed by travel rule instead of 0
+    );
+  }
+
+  @method.returns(Bool)
+  public async canChangeAdmin(_admin: PublicKey) {
+    await this.ensureAdminSignature();
+    return Bool(true);
+  }
+
+  @method.returns(Bool)
+  public async canPause(): Promise<Bool> {
+    await this.ensureAdminSignature();
+    return Bool(true);
+  }
+
+  @method.returns(Bool)
+  public async canResume(): Promise<Bool> {
+    await this.ensureAdminSignature();
+    return Bool(true);
+  }
+
+  @method async updateWhitelist(whitelist: Whitelist) {
+    const admin = this.adminPublicKey.getAndRequireEquals();
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = Bool(true);
+    admin.assertEquals(sender);
+
+    this.whitelist.set(whitelist);
+    this.emitEvent("updateWhitelist", whitelist);
+  }
+}

package/src/mina/token/api.ts

@@ -26,7 +26,10 @@ export type FungibleTokenTransactionType =
   | "buy"
   | "sell"
   | "withdrawBid"
-  | "withdrawOffer";
+  | "withdrawOffer"
+  | "whitelistBid"
+  | "whitelistOffer"
+  | "whitelistAdmin";
 export interface FungibleTokenTransactionParams {
   txType: FungibleTokenTransactionType;
   tokenAddress: string;
@@ -35,7 +38,7 @@ export interface FungibleTokenTransactionParams {
   signedData: string;
   from: string;
   to: string;
-  amount: number;
+  amount?: number;
   price?: number;
   whitelist?: { address: string; amount?: number }[];
   sendTransaction: boolean;

package/src/mina/token/bid.ts

@@ -0,0 +1,173 @@
+import {
+  AccountUpdate,
+  DeployArgs,
+  method,
+  Permissions,
+  PublicKey,
+  State,
+  state,
+  UInt64,
+  SmartContract,
+  Bool,
+  Field,
+  assert,
+  Mina,
+  Struct,
+} from "o1js";
+import { Whitelist } from "./whitelist.js";
+import { FungibleToken, tokenVerificationKeys } from "./token.js";
+
+export interface FungibleTokenBidContractDeployProps
+  extends Exclude<DeployArgs, undefined> {
+  /** The whitelist. */
+  whitelist: Whitelist;
+}
+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);
+    const verificationKey =
+      args?.verificationKey ?? FungibleTokenBidContract._verificationKey;
+    assert(verificationKey !== undefined);
+    const hash =
+      typeof verificationKey.hash === "string"
+        ? verificationKey.hash
+        : verificationKey.hash.toJSON();
+    const networkId = Mina.getNetworkId();
+    assert(networkId === "mainnet" || networkId === "testnet");
+    assert(
+      hash === tokenVerificationKeys[networkId].vk.FungibleTokenBidContract.hash
+    );
+    assert(
+      verificationKey.data ===
+        tokenVerificationKeys[networkId].vk.FungibleTokenBidContract.data
+    );
+    this.whitelist.set(args.whitelist);
+    this.account.permissions.set({
+      ...Permissions.default(),
+      send: Permissions.proof(),
+      setVerificationKey:
+        Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: Permissions.impossible(),
+    });
+  }
+
+  events = {
+    bid: UInt64,
+    withdraw: UInt64,
+    sell: UInt64,
+    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);
+  }
+
+  @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);
+  }
+
+  @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", amountInMina);
+  }
+
+  @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);
+    this.emitEvent("sell", amount);
+  }
+
+  @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);
+  }
+}