zkcloudworker 0.18.29 → 0.20.0

package/src/mina/api/api.ts

@@ -1,4 +1,3 @@
-import axios, { all } from "axios";
 import chalk from "chalk";
 import { sleep } from "../../cloud/utils/index.js";
 import { LocalCloud, LocalStorage } from "../local/local.js";
@@ -576,8 +575,21 @@ export class zkCloudWorkerClient {
       };
 
       try {
-        const response = await axios.post(this.endpoint, apiData);
-        return { success: true, data: response.data };
+        const response = await fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify(apiData),
+        });
+        if (!response.ok) {
+          return {
+            success: false,
+            error: `fetch error: ${response.statusText} status: ${response.status}`,
+          };
+        }
+        const data = await response.json();
+        return { success: true, data: data };
       } catch (error: any) {
         console.error("apiHub error:", error.message ?? error);
         return { success: false, error: error };

package/src/mina/token/api.ts

@@ -211,10 +211,8 @@ export class TokenAPI {
   async getResult(jobId: string): Promise<FungibleTokenJobResult> {
     try {
       const callResult = await this.client.jobResult({ jobId });
-      // const jobStatus: JobStatus | undefined =
-      //   callResult?.success === true
-      //     ? callResult?.result?.jobStatus
-      //     : undefined;
+
+      // TODO: filter the repo and developer
       const jobStatus: JobStatus | undefined =
         typeof callResult?.result === "string"
           ? undefined

package/src/mina/token/index.ts

@@ -1,8 +1 @@
 export * from "./api.js";
-export * from "./bid.js";
-export * from "./build.js";
-export * from "./fee.js";
-export * from "./offer.js";
-export * from "./token.js";
-export * from "./vk.js";
-export * from "./whitelist.js";

package/src/mina/transactions/transaction.ts

@@ -1,6 +1,50 @@
 import { Field, PublicKey, Transaction, Mina, UInt64 } from "o1js";
+import { TransactionPayloads } from "@minatokens/api";
 import { fieldToBase64, fieldFromBase64 } from "../utils/base64.js";
 
+export function createTransactionPayloads(
+  tx: Mina.Transaction<false, false> | Mina.Transaction<false, true>
+): TransactionPayloads {
+  const transaction = tx.toJSON();
+  const txJSON = JSON.parse(transaction);
+  const signedData = JSON.stringify({ zkappCommand: txJSON });
+  const proverPayload = serializeTransaction(tx);
+  const fee = tx.transaction.feePayer.body.fee.toJSON();
+  const sender = tx.transaction.feePayer.body.publicKey.toBase58();
+  const nonce = Number(tx.transaction.feePayer.body.nonce.toBigint());
+  const memo = tx.transaction.memo;
+  const minaSignerPayload = {
+    zkappCommand: txJSON,
+    feePayer: {
+      feePayer: sender,
+      fee,
+      nonce,
+      memo,
+    },
+  };
+  const walletPayload = {
+    transaction,
+    nonce,
+    onlySign: true,
+    feePayer: {
+      fee,
+      memo,
+    },
+  };
+
+  return {
+    sender,
+    nonce,
+    memo,
+    fee,
+    walletPayload,
+    minaSignerPayload,
+    proverPayload,
+    signedData,
+    transaction,
+  };
+}
+
 interface ForestSerialized {
   length: number;
   restoredItems?: number;
@@ -13,15 +57,21 @@ interface ForestSerialized {
 }
 
 export function transactionParams(
-  serializedTransaction: string,
-  signedJson: any
+  params:
+    | {
+        proverPayload: string;
+        signedData: string;
+      }
+    | TransactionPayloads
 ): {
   fee: UInt64;
   sender: PublicKey;
   nonce: number;
   memo: string;
 } {
-  const { sender, nonce, tx } = JSON.parse(serializedTransaction);
+  const { proverPayload, signedData } = params;
+  const signedJson = JSON.parse(signedData);
+  const { sender, tx } = JSON.parse(proverPayload);
   const transaction = Mina.Transaction.fromJSON(JSON.parse(tx));
   const memo = transaction.transaction.memo;
   return {
@@ -32,20 +82,30 @@ export function transactionParams(
   };
 }
 
-export function deserializeTransaction(
-  serializedTransaction: string,
-  txNew: Mina.Transaction<false, false>,
-  signedJson: any
+export function parseTransactionPayloads(
+  params:
+    | {
+        proverPayload: string;
+        signedData: string;
+        txNew: Mina.Transaction<false, false> | Mina.Transaction<false, true>;
+      }
+    | {
+        payloads: TransactionPayloads;
+        txNew: Mina.Transaction<false, false> | Mina.Transaction<false, true>;
+      }
 ): Transaction<false, true> {
-  //console.log("new transaction", txNew);
-  const { tx, blindingValues, length, forestJSONs } = JSON.parse(
-    serializedTransaction
-  );
+  const { txNew } = params;
+  const proverPayload =
+    "payloads" in params ? params.payloads.proverPayload : params.proverPayload;
+  const signedData =
+    "payloads" in params ? params.payloads.signedData : params.signedData;
+  const signedJson = JSON.parse(signedData);
+  const { tx, blindingValues, length, forestJSONs } = JSON.parse(proverPayload);
   const transaction = Mina.Transaction.fromJSON(JSON.parse(tx));
   const forests: ForestSerialized[] = forestJSONs.map(
     (f: string) => JSON.parse(f) as ForestSerialized
   );
-  //console.log("transaction", transaction);
+
   if (length !== txNew.transaction.accountUpdates.length) {
     throw new Error("New Transaction length mismatch");
   }
@@ -106,7 +166,7 @@ export function deserializeTransaction(
 }
 
 export function serializeTransaction(
-  tx: Mina.Transaction<false, false>
+  tx: Mina.Transaction<false, false> | Mina.Transaction<false, true>
 ): string {
   const length = tx.transaction.accountUpdates.length;
   let i;

package/src/mina/token/FungibleTokenAdmin.ts

@@ -1,89 +0,0 @@
-import {
-  AccountUpdate,
-  assert,
-  Bool,
-  DeployArgs,
-  method,
-  Permissions,
-  Provable,
-  PublicKey,
-  SmartContract,
-  State,
-  state,
-  VerificationKey,
-} from "o1js";
-import { FungibleTokenAdminBase } from "./FungibleTokenContract.js";
-
-export interface FungibleTokenAdminDeployProps
-  extends Exclude<DeployArgs, undefined> {
-  adminPublicKey: PublicKey;
-}
-
-/** 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 FungibleTokenAdmin
-  extends SmartContract
-  implements FungibleTokenAdminBase
-{
-  @state(PublicKey)
-  private adminPublicKey = State<PublicKey>();
-
-  async deploy(props: FungibleTokenAdminDeployProps) {
-    await super.deploy(props);
-    this.adminPublicKey.set(props.adminPublicKey);
-    this.account.permissions.set({
-      ...Permissions.default(),
-      setVerificationKey:
-        Permissions.VerificationKey.impossibleDuringCurrentVersion(),
-      setPermissions: Permissions.impossible(),
-    });
-  }
-
-  /** 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) {
-    await this.ensureAdminSignature();
-    return Bool(true);
-  }
-
-  @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);
-  }
-}

package/src/mina/token/FungibleTokenContract.ts

@@ -1,327 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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);
-  }
-}