Feat: new multisig operations subscription service

src/renderer/domains/collectives/model/referendum/model.ts

@@ -26,19 +26,19 @@ const { pending, subscribe, unsubscribe, received, fulfilled } = createDataSubsc
 >({
   initial: $list,
   fn: ({ api, palletType }, callback) => {
-    let currectAbortController = new AbortController();
+    let currentAbortController = new AbortController();
 
     const fetchPages = createPagesHandler({
       fn: () => referendaPallet.storage.referendumInfoForPaged(palletType, api, 200),
       map: mapReferendums,
     });
 
-    fetchPages(currectAbortController, callback);
+    fetchPages(currentAbortController, callback);
 
     const fn = () => {
-      currectAbortController.abort();
-      currectAbortController = new AbortController();
-      fetchPages(currectAbortController, callback);
+      currentAbortController.abort();
+      currentAbortController = new AbortController();
+      fetchPages(currentAbortController, callback);
     };
 
     /**
@@ -47,7 +47,7 @@ const { pending, subscribe, unsubscribe, received, fulfilled } = createDataSubsc
      * @see https://github.com/paritytech/polkadot-sdk/blob/43cd6fd4370d3043272f64a79aeb9e6dc0edd13f/substrate/frame/collective/src/lib.rs#L459
      */
     return polkadotjsHelpers.subscribeSystemEvents({ api, section: `${palletType}Referenda` }, fn).then(fn => () => {
-      currectAbortController.abort();
+      currentAbortController.abort();
       fn();
     });
   },

src/renderer/domains/multisig/index.ts

@@ -0,0 +1,7 @@
+import { multisigsDomainModel } from './model/multisigs/model';
+
+export const multisigDomain = {
+  multisigs: multisigsDomainModel,
+};
+
+export type { Multisig } from './model/multisigs/types';

src/renderer/domains/multisig/model/multisigs/model.ts

@@ -0,0 +1,153 @@
+import { type ApiPromise } from '@polkadot/api';
+import { createStore } from 'effector';
+import { cloneDeep } from 'lodash';
+
+import { type CallHash, type ChainId, type HexString } from '@/shared/core';
+import { createDataSource, createDataSubscription } from '@/shared/effector';
+import { nullable, setNestedValue } from '@/shared/lib/utils';
+import { multisigPallet } from '@/shared/pallet/multisig';
+import { polkadotjsHelpers } from '@/shared/polkadotjs-helpers';
+import { type AccountId } from '@/shared/polkadotjs-schemas';
+
+import { multisigOperationService } from './service';
+import { type Multisig, type MultisigEvent } from './types';
+
+type Store = Record<ChainId, Record<AccountId, Multisig[]>>;
+
+type RequestParams = {
+  accountId: AccountId;
+  api: ApiPromise;
+};
+
+const $multisigOperations = createStore<Store>({});
+
+const { request } = createDataSource<Store, RequestParams[], Record<ChainId, Multisig[]>>({
+  initial: $multisigOperations,
+  async fn(inputs) {
+    const result: Record<ChainId, Multisig[]> = {};
+
+    for (const { api, accountId } of inputs) {
+      const response = await multisigPallet.storage.multisigs(api, accountId);
+      const chainId = api.genesisHash.toHex();
+
+      for (const multisig of response) {
+        if (nullable(multisig.multisig)) continue;
+        result[chainId] = result[chainId] || [];
+
+        result[chainId].push({
+          status: 'pending',
+          accountId: multisig.key.accountId,
+          callHash: multisig.key.callHash as HexString,
+          depositor: multisig.multisig.depositor,
+          events: multisig.multisig.approvals.map(accountId => ({
+            accountId,
+            status: 'approved',
+            blockCreated: multisig.multisig!.when.height,
+            indexCreated: multisig.multisig!.when.index,
+          })),
+          blockCreated: multisig.multisig.when.height,
+          indexCreated: multisig.multisig.when.index,
+          deposit: multisig.multisig.deposit,
+        });
+      }
+    }
+
+    return result;
+  },
+  map(store, { params, result }) {
+    let newStore = {};
+
+    for (const { api, accountId } of params) {
+      const chainId = api.genesisHash.toHex();
+
+      newStore = setNestedValue(
+        store,
+        chainId,
+        accountId,
+        multisigOperationService.mergeMultisigOperations(store[chainId]?.[accountId] || [], result[chainId] || []),
+      );
+    }
+
+    return newStore;
+  },
+});
+
+const { subscribe, unsubscribe } = createDataSubscription<
+  Store,
+  RequestParams[],
+  { callHash: CallHash; multisigId: AccountId; chainId: ChainId } & MultisigEvent
+>({
+  initial: $multisigOperations,
+  fn: (params, callback) => {
+    const unsubscribe: Promise<void | (() => void)>[] = [];
+
+    for (const { accountId, api } of params) {
+      unsubscribe.push(
+        polkadotjsHelpers
+          .subscribeSystemEvents(
+            {
+              api,
+              section: `multisig`,
+              // TODO: add NewMultisig event
+              methods: ['MultisigApproval', 'MultisigExecuted', 'MultisigCancelled'],
+            },
+            event => {
+              const accountIdId = 0;
+              const timepointId = 1;
+              const multisigId = 2;
+              const callHashId = 3;
+
+              if (event.data[multisigId]?.toHex() !== accountId) return;
+
+              const blockCreated = (event.data[timepointId] as any).height.toNumber();
+              const indexCreated = (event.data[timepointId] as any).index.toNumber();
+
+              callback({
+                done: true,
+                value: {
+                  multisigId: accountId,
+                  chainId: api.genesisHash.toHex(),
+                  callHash: event.data[callHashId]!.toHex(),
+                  accountId: event.data[accountIdId]!.toHex() as AccountId,
+                  status: event.method === 'MultisigCancelled' ? 'rejected' : 'approved',
+                  indexCreated,
+                  blockCreated,
+                },
+              });
+            },
+          )
+          .then(unsubscribe => {
+            unsubscribe();
+          }),
+      );
+    }
+
+    return () => {
+      Promise.all(unsubscribe);
+    };
+  },
+  map: (store, { result: { callHash, multisigId, chainId, ...event } }) => {
+    const newStore = cloneDeep(store);
+
+    newStore[chainId] = newStore[chainId] || {};
+    newStore[chainId][multisigId] = newStore[chainId][multisigId] || [];
+
+    const multisig = newStore[chainId][multisigId].find(
+      multisig => multisig.callHash === callHash && multisig.status === 'pending',
+    );
+
+    if (multisig) {
+      multisig.events = multisigOperationService.mergeEvents(multisig.events, [event]);
+    }
+
+    return newStore;
+  },
+});
+
+export const multisigsDomainModel = {
+  $multisigOperations,
+
+  request,
+  subscribe,
+  unsubscribe,
+};

src/renderer/domains/multisig/model/multisigs/service.ts

@@ -0,0 +1,44 @@
+import { cloneDeep } from 'lodash';
+
+import { type Multisig, type MultisigEvent } from './types';
+
+export const multisigOperationService = {
+  isSameMultisig: (a: Multisig, b: Multisig) => {
+    const isSameCallHash = a.callHash === b.callHash;
+    const isSameTimepoint = a.blockCreated === b.blockCreated && a.indexCreated === b.indexCreated;
+    const isSameAccount = a.accountId === b.accountId;
+
+    return isSameCallHash && isSameTimepoint && isSameAccount;
+  },
+
+  isSameEvent: (a: MultisigEvent, b: MultisigEvent) => {
+    return a.accountId === b.accountId && a.blockCreated === b.blockCreated && a.indexCreated === b.indexCreated;
+  },
+
+  mergeEvents: (oldEvents: MultisigEvent[], newEvents: MultisigEvent[]) => {
+    return [...oldEvents, ...newEvents.filter(e => !oldEvents.find(o => multisigOperationService.isSameEvent(o, e)))];
+  },
+
+  mergeMultisig: (oldMultisig: Multisig, newMultisig: Multisig) => {
+    return {
+      ...oldMultisig,
+      events: multisigOperationService.mergeEvents(oldMultisig.events, newMultisig.events),
+    };
+  },
+
+  mergeMultisigOperations: (oldMultisigs: Multisig[], newMultisigs: Multisig[]): Multisig[] => {
+    const result = cloneDeep(oldMultisigs);
+
+    for (const newMultisig of newMultisigs) {
+      const oldMultisig = result.find(m => multisigOperationService.isSameMultisig(m, newMultisig));
+
+      if (oldMultisig) {
+        oldMultisig.events = multisigOperationService.mergeEvents(oldMultisig.events, newMultisig.events);
+      } else {
+        result.push(newMultisig);
+      }
+    }
+
+    return result;
+  },
+};

src/renderer/domains/multisig/model/multisigs/types.ts

@@ -0,0 +1,29 @@
+import { type BN } from '@polkadot/util';
+
+import { type CallData, type CallHash, type HexString } from '@/shared/core';
+import { type AccountId } from '@/shared/polkadotjs-schemas';
+
+export type Timepoint = {
+  height: number;
+  index: number;
+};
+
+export type MultisigEvent = {
+  accountId: AccountId;
+  status: 'approved' | 'rejected';
+  blockCreated: number;
+  indexCreated: number;
+  extrinsicHash?: HexString;
+};
+
+export type Multisig = {
+  status: 'pending' | 'cancelled' | 'executed' | 'error';
+  accountId: AccountId;
+  callHash: CallHash;
+  callData?: CallData;
+  deposit: BN;
+  depositor: AccountId;
+  blockCreated: number;
+  indexCreated: number;
+  events: MultisigEvent[];
+};

src/renderer/entities/governance/lib/governanceSubscribeService.ts

@@ -134,7 +134,7 @@ function subscribeVotingFor(
 }
 
 function subscribeReferendums(api: ApiPromise, callback: (referendums: IteratorResult<Referendum[], void>) => unknown) {
-  let currectAbortController = new AbortController();
+  let currentAbortController = new AbortController();
 
   const fetchPages = async (abort: AbortController) => {
     for await (const page of referendaPallet.storage.referendumInfoForPaged('governance', api, 500)) {
@@ -153,12 +153,12 @@ function subscribeReferendums(api: ApiPromise, callback: (referendums: IteratorR
     callback({ done: true, value: undefined });
   };
 
-  fetchPages(currectAbortController);
+  fetchPages(currentAbortController);
 
   const fn = () => {
-    currectAbortController.abort();
-    currectAbortController = new AbortController();
-    fetchPages(currectAbortController);
+    currentAbortController.abort();
+    currentAbortController = new AbortController();
+    fetchPages(currentAbortController);
   };
 
   const unsubscribeSystemReferenda = polkadotjsHelpers.subscribeSystemEvents({ api, section: 'referenda' }, fn);
@@ -174,7 +174,7 @@ function subscribeReferendums(api: ApiPromise, callback: (referendums: IteratorR
 
   return Promise.all([unsubscribeSystemReferenda, unsubscribeSystemConvictionVoting, unsubscribeExtrinsics]).then(
     (fns) => () => {
-      currectAbortController.abort();
+      currentAbortController.abort();
       for (const fn of fns) {
         fn();
       }

src/renderer/features/multisig-operations/constants.ts

@@ -0,0 +1,3 @@
+export const ERROR = {
+  networkDisabled: 'Network disabled',
+};

src/renderer/features/multisig-operations/index.ts

@@ -0,0 +1,8 @@
+import { operationsModel } from './model/list';
+
+export const multisigOperationsFeature = {
+  model: {
+    operations: operationsModel,
+  },
+  views: {},
+};

src/renderer/features/multisig-operations/model/list.ts

@@ -0,0 +1,24 @@
+import { sample } from 'effector';
+
+import { multisigDomain } from '@/domains/multisig';
+
+import { multisigOperationsFeatureStatus } from './status';
+
+sample({
+  clock: multisigOperationsFeatureStatus.running,
+  target: [multisigDomain.multisigs.request, multisigDomain.multisigs.subscribe],
+});
+
+sample({
+  clock: multisigOperationsFeatureStatus.stopped,
+  target: multisigDomain.multisigs.unsubscribe,
+});
+
+const $operations = multisigDomain.multisigs.$multisigOperations.map((list) => list ?? {});
+
+export const operationsModel = {
+  $operations,
+
+  $pending: multisigOperationsFeatureStatus.isStarting,
+  $fulfilled: multisigOperationsFeatureStatus.isRunning,
+};