feat: add session keys (alias) for offchain spaces

.changeset/thick-carrots-brush.md

@@ -0,0 +1,5 @@
+---
+"@snapshot-labs/sx": patch
+---
+
+add setAlias to OffchainEthereumSig

apps/ui/package.json

@@ -34,6 +34,7 @@
     "@ethersproject/abstract-signer": "^5.7.0",
     "@ethersproject/address": "^5.7.0",
     "@ethersproject/bignumber": "^5.7.0",
+    "@ethersproject/bytes": "^5.7.0",
     "@ethersproject/constants": "^5.7.0",
     "@ethersproject/contracts": "^5.7.0",
     "@ethersproject/hash": "^5.7.0",

apps/ui/src/composables/useActions.ts

@@ -19,6 +19,7 @@ const offchainNetworkId = offchainNetworks.filter(network => enabledNetworks.inc
 export function useActions() {
   const { mixpanel } = useMixpanel();
   const uiStore = useUiStore();
+  const alias = useAlias();
   const { web3 } = useWeb3();
   const { getCurrentFromDuration } = useMetaStore();
   const { modalAccountOpen } = useModal();
@@ -105,6 +106,14 @@ export function useActions() {
     modalAccountOpen.value = true;
   }
 
+  async function aliasSigner() {
+    const network = getNetwork(offchainNetworkId);
+
+    return alias.getAliasWallet(address =>
+      wrapPromise(offchainNetworkId, network.actions.setAlias(auth.web3, address))
+    );
+  }
+
   async function predictSpaceAddress(networkId: NetworkID, salt: string): Promise<string | null> {
     if (!web3.value.account) {
       forceLogin();
@@ -505,10 +514,9 @@ export function useActions() {
     try {
       await wrapPromise(
         offchainNetworkId,
-        network.actions.followSpace(auth.web3, networkId, spaceId)
+        network.actions.followSpace(await aliasSigner(), networkId, spaceId, web3.value.account)
       );
     } catch (e) {
-      console.log(e);
       uiStore.addNotification('error', e.message);
       return false;
     }
@@ -527,7 +535,7 @@ export function useActions() {
     try {
       await wrapPromise(
         offchainNetworkId,
-        network.actions.unfollowSpace(auth.web3, networkId, spaceId)
+        network.actions.unfollowSpace(await aliasSigner(), networkId, spaceId, web3.value.account)
       );
     } catch (e) {
       uiStore.addNotification('error', e.message);

apps/ui/src/composables/useAlias.ts

@@ -0,0 +1,54 @@
+import { Wallet } from '@ethersproject/wallet';
+import { getDefaultProvider } from '@ethersproject/providers';
+import { isHexString } from '@ethersproject/bytes';
+import { enabledNetworks, getNetwork, offchainNetworks } from '@/networks';
+import pkg from '../../package.json';
+
+const ALIAS_AVAILABILITY_PERIOD = 60 * 60 * 24 * 30; // 30 days
+const ALIAS_AVAILABILITY_BUFFER = 60 * 5; // 5 minutes
+
+const aliases = useStorage(`${pkg.name}.aliases`, {} as Record<string, string>);
+
+const networkId = offchainNetworks.filter(network => enabledNetworks.includes(network))[0];
+const network = getNetwork(networkId);
+
+export function useAlias() {
+  const provider = getDefaultProvider();
+  const { web3 } = useWeb3();
+
+  async function create(networkCreateActionFn: (address: string) => Promise<unknown>) {
+    const newAliasWallet = Wallet.createRandom();
+
+    await networkCreateActionFn(newAliasWallet.address);
+
+    aliases.value = {
+      ...aliases.value,
+      ...{
+        [web3.value.account]: newAliasWallet.privateKey
+      }
+    };
+
+    return new Wallet(newAliasWallet.privateKey, provider);
+  }
+
+  async function existingAliasWallet(privateKey: string) {
+    if (!isHexString(privateKey)) return null;
+
+    const registeredAlias = await network.api.loadAlias(
+      web3.value.account,
+      new Wallet(privateKey, provider).address,
+      Math.floor(Date.now() / 1000) - ALIAS_AVAILABILITY_PERIOD + ALIAS_AVAILABILITY_BUFFER
+    );
+
+    return registeredAlias ? new Wallet(privateKey, provider) : null;
+  }
+
+  async function getAliasWallet(networkCreateActionFn: (address: string) => Promise<unknown>) {
+    return (
+      (await existingAliasWallet(aliases.value[web3.value.account])) ||
+      (await create(networkCreateActionFn))
+    );
+  }
+
+  return { getAliasWallet };
+}

apps/ui/src/networks/common/graphqlApi/index.ts

@@ -475,6 +475,9 @@ export function createApi(uri: string, networkId: NetworkID, opts: ApiOptions =
     },
     loadFollows: async () => {
       return [] as Follow[];
+    },
+    loadAlias: async () => {
+      return null;
     }
   };
 }

apps/ui/src/networks/evm/actions.ts

@@ -623,6 +623,7 @@ export function createActions(
       );
     },
     followSpace: () => {},
-    unfollowSpace: () => {}
+    unfollowSpace: () => {},
+    setAlias: () => {}
   };
 }

apps/ui/src/networks/offchain/actions.ts

@@ -11,7 +11,8 @@ import { EDITOR_APP_NAME, EDITOR_SNAPSHOT_OFFSET } from './constants';
 import { getUrl } from '@/helpers/utils';
 import { getProvider } from '@/helpers/provider';
 import { getSwapLink } from '@/helpers/link';
-import type { Web3Provider } from '@ethersproject/providers';
+import { Web3Provider } from '@ethersproject/providers';
+import type { Wallet } from '@ethersproject/wallet';
 import type { StrategyParsedMetadata, Choice, Proposal, Space, VoteType, NetworkID } from '@/types';
 import type {
   ReadOnlyNetworkActions,
@@ -202,16 +203,27 @@ export function createActions(
         };
       });
     },
-    followSpace(web3: Web3Provider, networkId: NetworkID, spaceId: string) {
+    followSpace(web3: Web3Provider | Wallet, networkId: NetworkID, spaceId: string, from?: string) {
       return client.followSpace({
-        signer: web3.getSigner(),
-        data: { network: networkId, space: spaceId }
+        signer: web3 instanceof Web3Provider ? web3.getSigner() : web3,
+        data: { network: networkId, space: spaceId, ...(from ? { from } : {}) }
       });
     },
-    unfollowSpace(web3: Web3Provider, networkId: NetworkID, spaceId: string) {
+    unfollowSpace(
+      web3: Web3Provider | Wallet,
+      networkId: NetworkID,
+      spaceId: string,
+      from?: string
+    ) {
       return client.unfollowSpace({
+        signer: web3 instanceof Web3Provider ? web3.getSigner() : web3,
+        data: { network: networkId, space: spaceId, ...(from ? { from } : {}) }
+      });
+    },
+    setAlias(web3: Web3Provider, alias: string) {
+      return client.setAlias({
         signer: web3.getSigner(),
-        data: { network: networkId, space: spaceId }
+        data: { alias }
       });
     }
   };

apps/ui/src/networks/offchain/api/index.ts

@@ -6,7 +6,8 @@ import {
   PROPOSAL_QUERY,
   USER_VOTES_QUERY,
   USER_FOLLOWS_QUERY,
-  VOTES_QUERY
+  VOTES_QUERY,
+  ALIASES_QUERY
 } from './queries';
 import { PaginationOpts, SpacesFilter, NetworkApi, ProposalsFilter } from '@/networks/types';
 import { getNames } from '@/helpers/stamp';
@@ -19,7 +20,8 @@ import {
   NetworkID,
   ProposalState,
   SpaceMetadataTreasury,
-  Follow
+  Follow,
+  Alias
 } from '@/types';
 import { ApiSpace, ApiProposal, ApiVote } from './types';
 import { DEFAULT_VOTING_DELAY } from '../constants';
@@ -370,6 +372,24 @@ export function createApi(uri: string, networkId: NetworkID): NetworkApi {
       });
 
       return follows.map(follow => ({ ...follow, space: { ...follow.space, network: networkId } }));
+    },
+    loadAlias: async (
+      address: string,
+      aliasAddress: string,
+      created_gt: number
+    ): Promise<Alias | null> => {
+      const {
+        data: { aliases }
+      }: { data: { aliases: Alias[] } } = await apollo.query({
+        query: ALIASES_QUERY,
+        variables: {
+          address,
+          alias: aliasAddress,
+          created_gt
+        }
+      });
+
+      return aliases?.[0] ?? null;
     }
   };
 }

apps/ui/src/networks/offchain/api/queries.ts

@@ -183,3 +183,12 @@ export const VOTES_QUERY = gql`
     }
   }
 `;
+
+export const ALIASES_QUERY = gql`
+  query Aliases($address: String!, $alias: String!, $created_gt: Int) {
+    aliases(where: { address: $address, alias: $alias, created_gt: $created_gt }) {
+      address
+      alias
+    }
+  }
+`;

apps/ui/src/networks/starknet/actions.ts

@@ -582,6 +582,7 @@ export function createActions(
     },
     followSpace: () => {},
     unfollowSpace: () => {},
+    setAlias: () => {},
     send: (envelope: any) => starkSigClient.send(envelope) // TODO: extract it out of client to common helper
   };
 }

apps/ui/src/networks/types.ts

@@ -1,5 +1,6 @@
 import { FunctionalComponent } from 'vue';
 import type { Web3Provider } from '@ethersproject/providers';
+import type { Wallet } from '@ethersproject/wallet';
 import type { MetaTransaction } from '@snapshot-labs/sx/dist/utils/encoding';
 import type {
   Space,
@@ -10,7 +11,8 @@ import type {
   Choice,
   NetworkID,
   StrategyParsedMetadata,
-  Follow
+  Follow,
+  Alias
 } from '@/types';
 
 export type PaginationOpts = { limit: number; skip?: number };
@@ -125,8 +127,9 @@ export type ReadOnlyNetworkActions = {
     proposal: Proposal,
     choice: Choice
   ): Promise<any>;
-  followSpace(web3: Web3Provider, networkId: NetworkID, spaceId: string);
-  unfollowSpace(web3: Web3Provider, networkId: NetworkID, spaceId: string);
+  followSpace(web3: Web3Provider | Wallet, networkId: NetworkID, spaceId: string, from?: string);
+  unfollowSpace(web3: Web3Provider | Wallet, networkId: NetworkID, spaceId: string, from?: string);
+  setAlias(web3: Web3Provider, alias: string);
   send(envelope: any): Promise<any>;
 };
 
@@ -212,6 +215,7 @@ export type NetworkApi = {
     sortBy?: 'vote_count-desc' | 'vote_count-asc' | 'proposal_count-desc' | 'proposal_count-asc'
   ): Promise<User[]>;
   loadFollows(userId?: string, spaceId?: string): Promise<Follow[]>;
+  loadAlias(address: string, alias: string, created_gt: number): Promise<Alias | null>;
 };
 
 export type NetworkConstants = {

apps/ui/src/types.ts

@@ -206,6 +206,11 @@ export type Follow = {
   created: number;
 };
 
+export type Alias = {
+  address: string;
+  alias: string;
+};
+
 export type Contact = {
   address: string;
   name: string;

packages/sx.js/src/clients/offchain/ethereum-sig/index.ts

@@ -12,25 +12,28 @@ import {
   updateProposalTypes,
   cancelProposalTypes,
   followSpaceTypes,
-  unfollowSpaceTypes
+  unfollowSpaceTypes,
+  aliasTypes
 } from './types';
 import type { Signer, TypedDataSigner, TypedDataField } from '@ethersproject/abstract-signer';
-import type {
-  SignatureData,
-  Envelope,
-  Vote,
-  Propose,
-  UpdateProposal,
-  CancelProposal,
-  FollowSpace,
-  UnfollowSpace,
-  EIP712Message,
-  EIP712VoteMessage,
-  EIP712ProposeMessage,
-  EIP712UpdateProposal,
-  EIP712CancelProposalMessage,
-  EIP712FollowSpaceMessage,
-  EIP712UnfollowSpaceMessage
+import {
+  type SignatureData,
+  type Envelope,
+  type Vote,
+  type Propose,
+  type UpdateProposal,
+  type CancelProposal,
+  type FollowSpace,
+  type UnfollowSpace,
+  type SetAlias,
+  type EIP712Message,
+  type EIP712VoteMessage,
+  type EIP712ProposeMessage,
+  type EIP712UpdateProposal,
+  type EIP712CancelProposalMessage,
+  type EIP712FollowSpaceMessage,
+  type EIP712UnfollowSpaceMessage,
+  type EIP712SetAliasMessage
 } from '../types';
 import type { OffchainNetworkConfig } from '../../../types';
 
@@ -61,6 +64,7 @@ export class EthereumSig {
       | EIP712CancelProposalMessage
       | EIP712FollowSpaceMessage
       | EIP712UnfollowSpaceMessage
+      | EIP712SetAliasMessage
   >(
     signer: Signer & TypedDataSigner,
     message: T,
@@ -86,7 +90,7 @@ export class EthereumSig {
 
   public async send(
     envelope: Envelope<
-      Vote | Propose | UpdateProposal | CancelProposal | FollowSpace | UnfollowSpace
+      Vote | Propose | UpdateProposal | CancelProposal | FollowSpace | UnfollowSpace | SetAlias
     >
   ) {
     const { address, signature: sig, domain, types, message } = envelope.signatureData!;
@@ -254,4 +258,19 @@ export class EthereumSig {
       data
     };
   }
+
+  public async setAlias({
+    signer,
+    data
+  }: {
+    signer: Signer & TypedDataSigner;
+    data: SetAlias;
+  }): Promise<Envelope<SetAlias>> {
+    const signatureData = await this.sign(signer, data, aliasTypes);
+
+    return {
+      signatureData,
+      data
+    };
+  }
 }

packages/sx.js/src/clients/offchain/ethereum-sig/types.ts

@@ -118,3 +118,11 @@ export const unfollowSpaceTypes = {
     { name: 'timestamp', type: 'uint64' }
   ]
 };
+
+export const aliasTypes = {
+  Alias: [
+    { name: 'from', type: 'address' },
+    { name: 'alias', type: 'address' },
+    { name: 'timestamp', type: 'uint64' }
+  ]
+};