Store nextEntryArgs after publish

src/p2panda-api/instance.ts

@@ -13,14 +13,12 @@ const create = async (
   fields: { message: string },
   { keyPair, schema, session }: InstanceArgs,
 ): Promise<void> => {
-  await session.init();
-
   const {
     MessageFields,
     encodeCreateMessage,
     signEncodeEntry,
     KeyPair,
-  } = session.p2panda;
+  } = await session.loadWasm();
 
   // Hard coded field type for now
   const FIELD_TYPE = 'text';
@@ -53,7 +51,11 @@ const create = async (
   );
 
   // Publish entry and store returned entryArgs for next entry
-  await session.publishEntry(entryEncoded, encodedMessage);
+  const nextEntryArgs = await session.publishEntry(
+    entryEncoded,
+    encodedMessage,
+  );
+  session.setNextEntryArgs(keyPair.publicKey(), schema, nextEntryArgs);
 };
 
 export default { create };

src/p2panda-api/session.ts

@@ -4,41 +4,62 @@ import p2panda from 'p2panda-js';
 import { Resolved } from '~/typescript/helpers';
 
 import { log } from '.';
-import { EntryArgs, EntryRecord, EntryRecordEncoded } from './types';
+import { Entry, EntryArgs, EntryRecord, EntryRecordEncoded } from './types';
 
 export default class Session {
   endpoint: string = null;
   private client = null;
   p2panda: Resolved<typeof p2panda> = null;
+  nextEntryArgs: { [cacheKey: string]: EntryArgs } = {};
 
   constructor(endpoint: Session['endpoint']) {
     this.endpoint = endpoint;
     const transport = new HTTPTransport(endpoint);
     this.client = new Client(new RequestManager([transport]));
+    this.loadWasm();
   }
 
-  // Load the WebAssembly p2panda library. Always await this function before
-  // using this.p2panda. Unfortunately this cannot be handled in the
-  // constructor as that cannot be asynchronous.
-  async init(): Promise<void> {
-    if (this.p2panda != null) return;
-    this.p2panda = await p2panda;
+  // Load and return the WebAssembly p2panda library.
+  //
+  // Always await this function before
+  // using `this.p2panda`. Unfortunately this cannot be handled in the
+  // constructor as the contructor cannot be async.
+  async loadWasm(): Promise<Session['p2panda']> {
+    if (this.p2panda == null) {
+      this.p2panda = await p2panda;
+    }
+    return this.p2panda;
   }
 
   async getNextEntryArgs(author: string, schema: string): Promise<EntryArgs> {
-    // do rpc call
-    const result = await this.client.request({
-      method: 'panda_getEntryArguments',
-      params: { author, schema },
-    });
-    log('panda_getEntryArguments', result);
-    return result;
+    const cacheKey = `${author}/${schema}`;
+    let rv = this.nextEntryArgs[cacheKey];
+    if (rv) {
+      // use cache
+      delete this.nextEntryArgs[cacheKey];
+      log('panda_getEntryArguments [cached]', rv);
+      return rv;
+    } else {
+      // do rpc call
+      rv = await this.client.request({
+        method: 'panda_getEntryArguments',
+        params: { author, schema },
+      });
+      log('panda_getEntryArguments', rv);
+    }
+
+    return rv;
+  }
+
+  setNextEntryArgs(author: string, schema: string, entryArgs: EntryArgs): void {
+    const cacheKey = `${author}/${schema}`;
+    this.nextEntryArgs[cacheKey] = entryArgs;
   }
 
   async publishEntry(
     entryEncoded: string,
     messageEncoded: string,
-  ): Promise<void> {
+  ): Promise<EntryArgs> {
     const result = await this.client.request({
       method: 'panda_publishEntry',
       params: { entryEncoded, messageEncoded },
@@ -57,16 +78,13 @@ export default class Session {
   }
 
   async queryEntries(schema: string): Promise<EntryRecord[]> {
-    await this.init();
+    const { decodeEntry } = await this.loadWasm();
 
     const result = await this.queryEntriesEncoded(schema);
     return Promise.all(
       result.map(async (entry) => ({
         ...entry,
-        decoded: await this.p2panda.decodeEntry(
-          entry.entryBytes,
-          entry.payloadBytes,
-        ),
+        decoded: await decodeEntry(entry.entryBytes, entry.payloadBytes),
       })),
     );
   }