adjust query to support ordering

schema.graphql

@@ -50,6 +50,9 @@
   hash: String!
   memo: String!
   authorizationKind: String!
+  sequenceNumber: Int! # TODO: Is it ok to make this required?
+  zkappAccountUpdateIds: [Int]!
+  zkappEventElementIds: [Int]!
 }
 
 type ActionStates {

src/blockchain/types.ts

@@ -41,6 +41,9 @@ export type TransactionInfo = {
   hash: string;
   memo: string;
   authorizationKind: string;
+  sequenceNumber: number;
+  zkappAccountUpdateIds: number[];
+  zkappEventElementIds: number[];
 };
 
 export type Events = {

src/blockchain/utils.ts

@@ -24,6 +24,9 @@ export function createTransactionInfo(
     hash: row.hash,
     memo: row.memo,
     authorizationKind: row.authorization_kind,
+    sequenceNumber: row.sequence_number,
+    zkappAccountUpdateIds: row.zkapp_account_updates_ids,
+    zkappEventElementIds: row.zkapp_event_element_ids,
   };
 }
 

src/db/sql/events-actions/queries.ts

@@ -108,6 +108,7 @@ function emittedZkAppCommandsCTE(db_client: postgres.Sql) {
     SELECT
       blocks_accessed.*,
       zkcu.id AS zkapp_account_update_id,
+      bzkc.sequence_no AS sequence_number,
       zkapp_fee_payer_body_id,
       zkapp_account_updates_ids,
       authorization_kind,

src/db/sql/events-actions/types.ts

@@ -33,6 +33,9 @@ export type ArchiveNodeDatabaseRow = {
   // Current status of the block within the chain.
   chain_status: string;
 
+  // Sequence number of the transaction within a block
+  sequence_number: number;
+
   // Hash representing the ledger state.
   ledger_hash: string;
 

src/resolvers-types.ts

@@ -124,7 +124,10 @@ export type TransactionInfo = {
   authorizationKind: Scalars['String']['output'];
   hash: Scalars['String']['output'];
   memo: Scalars['String']['output'];
+  sequenceNumber: Scalars['Int']['output'];
   status: Scalars['String']['output'];
+  zkappAccountUpdateIds: Array<Maybe<Scalars['Int']['output']>>;
+  zkappEventElementIds: Array<Maybe<Scalars['Int']['output']>>;
 };
 
 export type ResolverTypeWrapper<T> = Promise<T> | T;
@@ -448,7 +451,18 @@ export type TransactionInfoResolvers<
   >;
   hash?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   memo?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  sequenceNumber?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
   status?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  zkappAccountUpdateIds?: Resolver<
+    Array<Maybe<ResolversTypes['Int']>>,
+    ParentType,
+    ContextType
+  >;
+  zkappEventElementIds?: Resolver<
+    Array<Maybe<ResolversTypes['Int']>>,
+    ParentType,
+    ContextType
+  >;
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 

src/services/actions-service/actions-service.ts

@@ -143,7 +143,7 @@ class ActionsService implements IActionsService {
       }
       actions.push({
         blockInfo,
-        actionData: actionsData.flat(),
+        actionData: this.sortActions(actionsData.flat()),
         actionState: {
           /* eslint-disable */
           actionStateOne: action_state_value1!,
@@ -157,4 +157,26 @@ class ActionsService implements IActionsService {
     }
     return actions;
   }
+
+  sortActions(actions: Action[]): Action[] {
+    return actions.sort((a, b) => {
+      // Sort by sequence number
+      if (
+        a.transactionInfo.sequenceNumber !== b.transactionInfo.sequenceNumber
+      ) {
+        return (
+          a.transactionInfo.sequenceNumber - b.transactionInfo.sequenceNumber
+        );
+      }
+
+      // Sort by account update index if sequence number is the same
+      const aIndex = a.transactionInfo.zkappAccountUpdateIds.indexOf(
+        Number(a.accountUpdateId)
+      );
+      const bIndex = b.transactionInfo.zkappAccountUpdateIds.indexOf(
+        Number(b.accountUpdateId)
+      );
+      return aIndex - bIndex;
+    });
+  }
 }

tests/makeActionsRequest.ts

@@ -0,0 +1,66 @@
+import { createYoga, createSchema } from 'graphql-yoga';
+import { loadSchemaSync } from '@graphql-tools/load';
+import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
+import { buildHTTPExecutor } from '@graphql-tools/executor-http';
+import { parse } from 'graphql';
+import { resolvers } from '../src/resolvers.js';
+import { buildContext, GraphQLContext } from '../src/context.js';
+
+const PG_CONN = 'postgresql://postgres:postgres@localhost:5432/archive ';
+const zkappAccount = 'B62qmBrPiukbHj4VnXdgMzjj2zpoQZeSBxZA6JDYMeeShApRAKaorto';
+
+const actionsQuery = `
+query getActions($input: ActionFilterOptionsInput!) {
+  actions(input: $input) {
+    blockInfo {
+      stateHash
+      timestamp
+      height
+      parentHash
+      chainStatus
+      distanceFromMaxBlockHeight
+      globalSlotSinceGenesis
+    }
+    actionState {
+      actionStateOne
+      actionStateTwo
+      actionStateThree
+      actionStateFour
+      actionStateFive
+    }
+    actionData {
+      data
+      accountUpdateId
+      transactionInfo {
+        status
+        hash
+        memo
+        sequenceNumber
+        zkappAccountUpdateIds
+        zkappEventElementIds
+      }
+    }
+  }
+}
+`;
+
+const schema = createSchema({
+  typeDefs: loadSchemaSync('./schema.graphql', {
+    loaders: [new GraphQLFileLoader()],
+  }),
+  resolvers,
+});
+const context = await buildContext(PG_CONN);
+const yoga = createYoga<GraphQLContext>({ schema, context });
+const executor = buildHTTPExecutor({
+  fetch: yoga.fetch,
+});
+
+const results = await executor({
+  variables: {
+    input: { address: zkappAccount },
+  },
+  document: parse(`${actionsQuery}`),
+});
+
+console.log(JSON.stringify(results));

tests/resolvers.test.ts

@@ -5,7 +5,7 @@ import { loadSchemaSync } from '@graphql-tools/load';
 import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
 import { buildHTTPExecutor } from '@graphql-tools/executor-http';
 import { parse } from 'graphql';
-import { PrivateKey, Lightnet } from 'o1js';
+import { PrivateKey, Lightnet, Mina } from 'o1js';
 import { resolvers } from '../src/resolvers.js';
 import { buildContext, GraphQLContext } from '../src/context.js';
 import {
@@ -15,8 +15,10 @@ import {
   emitSingleEvent,
   setNetworkConfig,
   Keypair,
+  emitActionsFromMultipleSenders,
 } from '../zkapp/utils.js';
 import { HelloWorld } from '../zkapp/contract.js';
+import { Actions } from 'src/blockchain/types.js';
 
 const eventsQuery = `
 query getEvents($input: EventFilterOptionsInput!) {
@@ -69,6 +71,8 @@ query getActions($input: ActionFilterOptionsInput!) {
         status
         hash
         memo
+        sequenceNumber
+        zkappAccountUpdateIds
       }
     }
   }
@@ -85,27 +89,31 @@ describe('Query Resolvers', async () => {
   let zkApp: HelloWorld;
 
   before(async () => {
-    setNetworkConfig();
+    try {
+      setNetworkConfig();
 
-    const schema = createSchema({
-      typeDefs: loadSchemaSync('./schema.graphql', {
-        loaders: [new GraphQLFileLoader()],
-      }),
-      resolvers,
-    });
-    const context = await buildContext(PG_CONN);
-    const yoga = createYoga<GraphQLContext>({ schema, context });
-    executor = buildHTTPExecutor({
-      fetch: yoga.fetch,
-    });
+      const schema = createSchema({
+        typeDefs: loadSchemaSync('./schema.graphql', {
+          loaders: [new GraphQLFileLoader()],
+        }),
+        resolvers,
+      });
+      const context = await buildContext(PG_CONN);
+      const yoga = createYoga<GraphQLContext>({ schema, context });
+      executor = buildHTTPExecutor({
+        fetch: yoga.fetch,
+      });
 
-    zkAppKeypair = await Lightnet.acquireKeyPair();
-    senderKeypair = await Lightnet.acquireKeyPair();
-    zkApp = await deployContract(
-      zkAppKeypair,
-      senderKeypair,
-      /* fundNewAccount = */ false
-    );
+      zkAppKeypair = await Lightnet.acquireKeyPair();
+      senderKeypair = await Lightnet.acquireKeyPair();
+      zkApp = await deployContract(
+        zkAppKeypair,
+        senderKeypair,
+        /* fundNewAccount = */ false
+      );
+    } catch (error) {
+      console.error(error);
+    }
   });
 
   after(async () => {
@@ -253,5 +261,80 @@ describe('Query Resolvers', async () => {
       const lastAction = actions[actions.length - 1];
       assert.strictEqual(lastAction.actionData.length, 3);
     });
+
+    describe('Actions from different accounts', async () => {
+      const sendersCount = 5;
+      const actionsCount = 3;
+      const senders: Keypair[] = [];
+
+      before(async () => {
+        for (let i = 0; i < sendersCount; i++) {
+          senders.push(await Lightnet.acquireKeyPair());
+        }
+
+        await emitActionsFromMultipleSenders(zkApp, senders, {
+          numberOfEmits: actionsCount,
+        });
+      });
+
+      test('Emitting actions from many accounts should be fetchable in o1js', async () => {
+        await Mina.fetchActions(zkApp.address); // This line will throw if actions do not reproduce the correct action hash
+        assert(true);
+      });
+
+      test('Fetched actions have order metadata', async () => {
+        const results = await executor({
+          variables: {
+            input: {
+              address: zkApp.address,
+            },
+          },
+          document: parse(`${actionsQuery}`),
+        });
+        const actions: Actions = results.data.actions;
+        for (const block of actions) {
+          const actionData = block.actionData;
+          for (const action of actionData) {
+            assert.ok(action.transactionInfo.sequenceNumber);
+            assert(action.transactionInfo.zkappAccountUpdateIds.length > 0);
+          }
+        }
+      });
+
+      test('Fetched actions have correct order', async () => {
+        const results = await executor({
+          variables: {
+            input: {
+              address: zkApp.address,
+            },
+          },
+          document: parse(`${actionsQuery}`),
+        });
+        const actions: Actions = results.data.actions;
+
+        let testedAccountUpdateOrder = false;
+        for (const block of actions) {
+          const actionData = block.actionData;
+          for (let i = 1; i < actionData.length; i++) {
+            const previousAction = actionData[i - 1];
+            const currentAction = actionData[i];
+            assert.ok(
+              previousAction.transactionInfo.sequenceNumber <=
+                currentAction.transactionInfo.sequenceNumber
+            );
+            if (
+              previousAction.transactionInfo.sequenceNumber ===
+              currentAction.transactionInfo.sequenceNumber
+            ) {
+              testedAccountUpdateOrder = true;
+              assert.ok(
+                previousAction.accountUpdateId < currentAction.accountUpdateId
+              );
+            }
+          }
+        }
+        assert.ok(testedAccountUpdateOrder);
+      });
+    });
   });
 });