Tokens

MINA_COMMIT

@@ -1,2 +1,2 @@
 The mina commit used to generate the backends for node and chrome is
-97ff72a1d43cda02225d972031cdb0639f0abf84
+dea7b89becac85444610378dd579ea0216631349

src/examples/deploy/deploy.ts

@@ -1,4 +1,4 @@
-import { isReady, PrivateKey, deploy, shutdown, compile } from 'snarkyjs';
+import { isReady, PrivateKey, deploy, shutdown } from 'snarkyjs';
 import SimpleZkapp from './simple_zkapp';
 import { readFileSync, existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';

src/examples/fetch.ts

@@ -4,13 +4,18 @@ import {
   setGraphqlEndpoint,
   shutdown,
   fetchLastBlock,
+  PublicKey,
 } from 'snarkyjs';
 
 await isReady;
 setGraphqlEndpoint('https://proxy.berkeley.minaexplorer.com/graphql');
 
-let zkappAddress = 'B62qpRzFVjd56FiHnNfxokVbcHMQLT119My1FEdSq8ss7KomLiSZcan';
-let { account, error } = await fetchAccount(zkappAddress);
+let zkappAddress = PublicKey.fromBase58(
+  'B62qpRzFVjd56FiHnNfxokVbcHMQLT119My1FEdSq8ss7KomLiSZcan'
+);
+let { account, error } = await fetchAccount({
+  publicKey: zkappAddress,
+});
 console.log('account', JSON.stringify(account, null, 2));
 console.log('error', error);
 

src/examples/simple_zkapp_berkeley.ts

@@ -51,7 +51,7 @@ Mina.setActiveInstance(Berkeley);
 let feePayerKey = PrivateKey.fromBase58(
   'EKEQc95PPQZnMY9d9p1vq1MWLeDJKtvKj4V75UDG3rjnf32BerWD'
 );
-let response = await fetchAccount(feePayerKey.toPublicKey());
+let response = await fetchAccount({ publicKey: feePayerKey.toPublicKey() });
 if (response.error) throw Error(response.error.statusText);
 let { nonce, balance } = response.account;
 console.log(`Using fee payer account with nonce ${nonce}, balance ${balance}`);

src/index.ts

@@ -36,7 +36,14 @@ export {
 } from './lib/zkapp';
 export { state, State, declareState } from './lib/state';
 export { Proof, SelfProof, ZkProgram, verify } from './lib/proof_system';
-export { Party, Permissions, ZkappPublicInput } from './lib/party';
+export {
+  Token,
+  Party,
+  Permissions,
+  ZkappPublicInput,
+  getDefaultTokenId,
+  partiesToJson,
+} from './lib/party';
 export {
   fetchAccount,
   fetchLastBlock,

src/lib/fetch.ts

@@ -1,7 +1,12 @@
 import 'isomorphic-fetch';
-import { Bool, Field, Types } from '../snarky';
+import { Bool, Field, Types, Ledger } from '../snarky';
 import { UInt32, UInt64 } from './int';
-import { Permission, Permissions, ZkappStateLength } from './party';
+import {
+  getDefaultTokenId,
+  Permission,
+  Permissions,
+  ZkappStateLength,
+} from './party';
 import { PublicKey } from './signature';
 import { NetworkValue } from './precondition';
 
@@ -41,18 +46,24 @@ function setGraphqlEndpoint(graphqlEndpoint: string) {
  * @returns zkapp information on the specified account or an error is thrown
  */
 async function fetchAccount(
-  publicKey: string | PublicKey,
+  accountInfo: { publicKey: string | PublicKey; tokenId?: string },
   graphqlEndpoint = defaultGraphqlEndpoint,
   { timeout = defaultTimeout } = {}
 ): Promise<
   | { account: Account; error: undefined }
   | { account: undefined; error: FetchError }
 > {
   let publicKeyBase58 =
-    publicKey instanceof PublicKey ? publicKey.toBase58() : publicKey;
-  let response = await fetchAccountInternal(publicKeyBase58, graphqlEndpoint, {
-    timeout,
-  });
+    accountInfo.publicKey instanceof PublicKey
+      ? accountInfo.publicKey.toBase58()
+      : accountInfo.publicKey;
+  let response = await fetchAccountInternal(
+    { publicKey: publicKeyBase58, tokenId: accountInfo.tokenId },
+    graphqlEndpoint,
+    {
+      timeout,
+    }
+  );
   return response.error === undefined
     ? {
         account: parseFetchedAccount(response.account),
@@ -64,12 +75,16 @@ async function fetchAccount(
 // internal version of fetchAccount which does the same, but returns the original JSON version
 // of the account, to save some back-and-forth conversions when caching accounts
 async function fetchAccountInternal(
-  publicKey: string,
+  accountInfo: { publicKey: string; tokenId?: string },
   graphqlEndpoint = defaultGraphqlEndpoint,
   config?: FetchConfig
 ) {
+  const { publicKey, tokenId } = accountInfo;
   let [response, error] = await makeGraphqlRequest(
-    accountQuery(publicKey),
+    accountQuery(
+      publicKey,
+      tokenId ?? Ledger.fieldToBase58(getDefaultTokenId())
+    ),
     graphqlEndpoint,
     config
   );
@@ -123,6 +138,8 @@ function toPermission(p: AuthRequired): Permission {
 type FetchedAccount = {
   publicKey: string;
   nonce: string;
+  tokenId: string;
+  tokenSymbol: string;
   zkappUri?: string;
   zkappState: string[] | null;
   receiptChainHash?: string;
@@ -149,6 +166,8 @@ type Account = {
   publicKey: PublicKey;
   nonce: UInt32;
   balance: UInt64;
+  tokenId: Field;
+  tokenSymbol: string;
   zkapp?: { appState: Field[] };
   permissions?: Permissions;
   receiptChainHash?: Field;
@@ -160,13 +179,15 @@ type Account = {
 type FlexibleAccount = {
   publicKey: PublicKey | string;
   nonce: UInt32 | string | number;
+  tokenId?: string;
+  tokenSymbol?: string;
   balance?: UInt64 | string | number;
   zkapp?: { appState: (Field | string | number)[] };
 };
 
 // TODO provedState
-const accountQuery = (publicKey: string) => `{
-  account(publicKey: "${publicKey}") {
+const accountQuery = (publicKey: string, tokenId: string) => `{
+  account(publicKey: "${publicKey}", tokenId: "${tokenId}") {
     publicKey
     nonce
     zkappUri
@@ -188,6 +209,8 @@ const accountQuery = (publicKey: string) => `{
     balance { total }
     delegateAccount { publicKey }
     sequenceEvents
+    tokenId
+    tokenSymbol
   }
 }
 `;
@@ -206,6 +229,8 @@ function parseFetchedAccount({
   delegateAccount,
   receiptChainHash,
   sequenceEvents,
+  tokenId,
+  tokenSymbol,
 }: Partial<FetchedAccount>): Partial<Account> {
   return {
     publicKey:
@@ -228,11 +253,13 @@ function parseFetchedAccount({
     //     : undefined,
     delegate:
       delegateAccount && PublicKey.fromBase58(delegateAccount.publicKey),
+    tokenId: tokenId !== undefined ? Ledger.fieldOfBase58(tokenId) : undefined,
+    tokenSymbol: tokenSymbol !== undefined ? tokenSymbol : undefined,
   };
 }
 
 function stringifyAccount(account: FlexibleAccount): FetchedAccount {
-  let { publicKey, nonce, balance, zkapp } = account;
+  let { publicKey, nonce, balance, zkapp, tokenId, tokenSymbol } = account;
   return {
     publicKey:
       publicKey instanceof PublicKey ? publicKey.toBase58() : publicKey,
@@ -241,6 +268,8 @@ function stringifyAccount(account: FlexibleAccount): FetchedAccount {
       zkapp?.appState.map((s) => s.toString()) ??
       Array(ZkappStateLength).fill('0'),
     balance: { total: balance?.toString() ?? '0' },
+    tokenId: tokenId ?? Ledger.fieldToBase58(getDefaultTokenId()),
+    tokenSymbol: tokenSymbol ?? '',
   };
 }
 
@@ -262,15 +291,21 @@ let networkCache = {} as Record<
 >;
 let accountsToFetch = {} as Record<
   string,
-  { publicKey: string; graphqlEndpoint: string }
+  { publicKey: string; tokenId: string; graphqlEndpoint: string }
 >;
 let networksToFetch = {} as Record<string, { graphqlEndpoint: string }>;
 let cacheExpiry = 10 * 60 * 1000; // 10 minutes
 
-function markAccountToBeFetched(publicKey: PublicKey, graphqlEndpoint: string) {
+function markAccountToBeFetched(
+  publicKey: PublicKey,
+  tokenId: Field,
+  graphqlEndpoint: string
+) {
   let publicKeyBase58 = publicKey.toBase58();
-  accountsToFetch[`${publicKeyBase58};${graphqlEndpoint}`] = {
+  let tokenBase58 = Ledger.fieldToBase58(tokenId);
+  accountsToFetch[`${publicKeyBase58};${tokenBase58};${graphqlEndpoint}`] = {
     publicKey: publicKeyBase58,
+    tokenId: tokenBase58,
     graphqlEndpoint,
   };
 }
@@ -285,8 +320,11 @@ async function fetchMissingData(graphqlEndpoint: string) {
     let cachedAccount = accountCache[key];
     return cachedAccount === undefined || cachedAccount.timestamp < expired;
   });
-  let promises = accounts.map(async ([key, { publicKey }]) => {
-    let response = await fetchAccountInternal(publicKey, graphqlEndpoint);
+  let promises = accounts.map(async ([key, { publicKey, tokenId }]) => {
+    let response = await fetchAccountInternal(
+      { publicKey, tokenId },
+      graphqlEndpoint
+    );
     if (response.error === undefined) delete accountsToFetch[key];
   });
 
@@ -311,10 +349,15 @@ async function fetchMissingData(graphqlEndpoint: string) {
 
 function getCachedAccount(
   publicKey: PublicKey,
+  tokenId: Field,
   graphqlEndpoint = defaultGraphqlEndpoint
 ) {
   let account =
-    accountCache[`${publicKey.toBase58()};${graphqlEndpoint}`]?.account;
+    accountCache[
+      `${publicKey.toBase58()};${Ledger.fieldToBase58(
+        tokenId
+      )};${graphqlEndpoint}`
+    ]?.account;
   if (account !== undefined) return parseFetchedAccount(account);
 }
 function getCachedNetwork(graphqlEndpoint = defaultGraphqlEndpoint) {
@@ -329,6 +372,7 @@ function addCachedAccount(
     zkapp?: {
       appState: (string | number | Field)[];
     };
+    tokenId: string;
   },
   graphqlEndpoint = defaultGraphqlEndpoint
 ) {
@@ -339,7 +383,7 @@ function addCachedAccountInternal(
   account: FetchedAccount,
   graphqlEndpoint: string
 ) {
-  accountCache[`${account.publicKey};${graphqlEndpoint}`] = {
+  accountCache[`${account.publicKey};${account.tokenId};${graphqlEndpoint}`] = {
     account,
     graphqlEndpoint,
     timestamp: Date.now(),

src/lib/hash.ts

@@ -5,7 +5,7 @@ import { inCheckedComputation } from './proof_system';
 export { Poseidon };
 
 // internal API
-export { prefixes, emptyHashWithPrefix, hashWithPrefix };
+export { prefixes, emptyHashWithPrefix, hashWithPrefix, salt };
 
 class Sponge {
   private sponge: unknown;