@rango-dev/provider-walletconnect-2 0.1.1-next.0

package/src/session.ts

@@ -0,0 +1,308 @@
+import { AccountId } from 'caip';
+import { Networks, timeout } from '@rango-dev/wallets-shared';
+import type { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import {
+  PairingTypes,
+  SessionTypes,
+  SignClientTypes,
+} from '@walletconnect/types';
+import { Web3Modal } from '@web3modal/standalone';
+import { getSdkError } from '@walletconnect/utils';
+
+import {
+  generateOptionalNamespace,
+  generateRequiredNamespace,
+  getChainIdByNetworkName,
+  solanaChainIdToNetworkName,
+} from './helpers';
+import { PING_TIMEOUT, PROJECT_ID } from './constants';
+import { ConnectParams, CreateSessionParams, WCInstance } from './types';
+
+/**
+ * Create a Web3Modal instance
+ */
+const web3Modal = new Web3Modal({
+  projectId: PROJECT_ID,
+  themeMode: 'light',
+  walletConnectVersion: 2,
+});
+
+export function getLastSession(client: SignClient) {
+  return client.session.values[client.session.values.length - 1];
+}
+
+/**
+ *
+ * Try to ping the wallet, if wallet responded with `pong`, session is a valid and we will use the session.
+ * If the wallet didn't respond during 10 seconds (PING_TIME), we assume the wallet isn't available and we need to create a new session.
+ *
+ */
+export async function restoreSession(
+  client: SignClient,
+  pairing: PairingTypes.Struct
+): Promise<SessionTypes.Struct | undefined> {
+  await timeout(
+    client.ping({
+      topic: pairing.topic,
+    }),
+    PING_TIMEOUT
+  );
+
+  // We assume last session is the correct session, beacuse we are doing clean up and keeps only one pairing/session.
+  const session = getLastSession(client);
+  return session;
+}
+
+/**
+ *
+ * Getting a  pair of required and optional namespaces then tries to show a modal and connect (pair)
+ * To the wallet.
+ * @param client
+ * @param options
+ * @returns
+ */
+export async function createSession(
+  client: SignClient,
+  options: CreateSessionParams
+): Promise<SessionTypes.Struct> {
+  const { requiredNamespaces, optionalNamespaces, pairingTopic } = options;
+
+  try {
+    const { uri, approval } = await client.connect({
+      requiredNamespaces,
+      optionalNamespaces,
+      pairingTopic,
+    });
+
+    // Open QRCode modal if a URI was returned (i.e. we're not connecting an existing pairing).
+    if (uri) {
+      // Create a flat array of all requested chains across namespaces.
+      const allNamespaces = {
+        ...(requiredNamespaces || {}),
+        ...(optionalNamespaces || {}),
+      };
+
+      const standaloneChains = Object.values(allNamespaces)
+        .map((namespace) => namespace.chains)
+        .flat() as string[];
+
+      web3Modal.openModal({ uri, standaloneChains });
+    }
+
+    const session = await approval();
+    return session;
+  } catch (e) {
+    console.error(e);
+    throw e;
+  } finally {
+    web3Modal.closeModal();
+  }
+}
+
+/**
+ *
+ * A user (client) can have multiple pairings (to different wallets), we are assuming
+ * the last pairing is the active pairing for now. A better UX can be showing a list of pairings
+ * and let the user to choose the right pairing manually. Because we don't have that yet, we will pick up the last one.
+ *
+ */
+export function tryGetPairing(
+  client: SignClient
+): PairingTypes.Struct | undefined {
+  const pairings = client.pairing.getAll({ active: true });
+  const lastPairing =
+    pairings.length > 0 ? pairings[pairings.length - 1] : undefined;
+
+  return lastPairing;
+}
+
+/**
+ *
+ * Try to restore the session first, if couldn't, create a new session by showing a modal.
+ *
+ */
+export async function tryConnect(
+  client: SignClient,
+  params: ConnectParams
+): Promise<SessionTypes.Struct> {
+  const { network, meta } = params;
+
+  const requiredNamespaces = generateRequiredNamespace(meta, network);
+  /**
+   * We try to get all of our supported chains as optional.
+   * Currently, it only works on Trust Wallet (Note: the response is buggy and only returns eip155 optional namespaces).
+   */
+  const optionalNamespaces = generateOptionalNamespace(meta);
+
+  if (!requiredNamespaces) {
+    throw new Error(`Couldn't generate required namespace for ${network}`);
+  }
+
+  // Check if the user has a session, if yes, restore the session and use it.
+  let session: SessionTypes.Struct | undefined;
+  const pairing = tryGetPairing(client);
+  if (pairing) {
+    try {
+      session = await restoreSession(client, pairing);
+    } catch (e) {
+      await disconnectSessions(client);
+    }
+  }
+
+  // In case of connecting for the first time or session couldn't be restored, we will create a new session.
+  if (!session) {
+    session = await createSession(client, {
+      requiredNamespaces,
+      optionalNamespaces,
+    });
+  }
+
+  return session;
+}
+
+/**
+ * Wallet connect is a multichain protocol and we can not determine the connected wallet
+ * supports which wallet, `extend`ing session doesn't work during a bug in their utils packages.
+ * So we will try to make a new session with `network` that user needs to switch.
+ */
+export async function trySwitchByCreatingNewSession(
+  instance: WCInstance,
+  params: ConnectParams
+): Promise<SessionTypes.Struct> {
+  const { client, session } = instance;
+  const { network, meta } = params;
+
+  if (!session) {
+    throw new Error(
+      'For switching network, you need to have an active session!'
+    );
+  }
+
+  // If a session has the chain id in its namespace, we can use that session.
+  const chainId = getChainIdByNetworkName(network, params.meta) || network;
+  const requestedSession = getSessionByChainId(client, chainId);
+  if (requestedSession) {
+    return requestedSession;
+  }
+
+  // Creating a new session for requested network.
+  const requiredNamespaces = generateRequiredNamespace(meta, network);
+  if (!requiredNamespaces) {
+    throw new Error(`Couldn't generate requiredNamespaces for ${network}`);
+  }
+
+  const createdSession = await createSession(client, { requiredNamespaces });
+
+  return createdSession;
+}
+
+/**
+ *
+ * Looking for a chainId in sessions and return the session if found.
+ *
+ */
+function getSessionByChainId(
+  client: WCInstance['client'],
+  chainId: string
+): SessionTypes.Struct | undefined {
+  const sessions = client.session.getAll();
+  const requestedSession = sessions.find((session) => {
+    const accounts = getAccountsFromSession(session);
+    return accounts.find((account) => account.chainId === chainId);
+  });
+
+  return requestedSession;
+}
+
+/**
+ *
+ * Try to find sessions with a topic id and expire them.
+ *
+ */
+export async function cleanupSingleSession(client: SignClient, topic: string) {
+  const sessions = client.session.getAll();
+  const pairings = client.pairing.getAll();
+
+  sessions.forEach((session) => {
+    if (session.topic === topic || session.pairingTopic === topic) {
+      const requestForDeleteTopic =
+        session.pairingTopic === topic ? session.pairingTopic : session.topic;
+      client.core.expirer.set(requestForDeleteTopic, 0);
+    }
+  });
+
+  pairings.forEach((pairing) => {
+    if (pairing.topic === topic) {
+      client.core.expirer.set(topic, 0);
+    }
+  });
+}
+
+/**
+ *
+ * Disconnect means to delete the session on both parties (dApp & wallet) at the same time.
+ *
+ */
+export async function disconnectSessions(client: SignClient) {
+  const allPromises = [];
+
+  const sessions = client.session.getAll();
+  for (const session of sessions) {
+    allPromises.push(
+      client.disconnect({
+        topic: session.topic,
+        reason: getSdkError('USER_DISCONNECTED'),
+      })
+    );
+  }
+
+  const pairings = client.pairing.getAll();
+  for (const pairing of pairings) {
+    allPromises.push(
+      client.disconnect({
+        topic: pairing.topic,
+        reason: getSdkError('USER_DISCONNECTED'),
+      })
+    );
+  }
+
+  return await Promise.all(allPromises);
+}
+
+export function getAccountsFromSession(session: SessionTypes.Struct) {
+  const accounts = Object.values(session.namespaces)
+    .map((namespace) => namespace.accounts)
+    .flat()
+    .map((account) => {
+      const { address, chainId } = new AccountId(account);
+      // Note: Solana has a specific ID, we need to convert it back to network name.
+      // It will return the chain id itslef if it's not that specific ID.
+      const chain = solanaChainIdToNetworkName(chainId.reference);
+      return {
+        accounts: [address],
+        chainId: chain,
+      };
+    });
+
+  return accounts;
+}
+
+export function getAccountsFromEvent(
+  event: SignClientTypes.BaseEventArgs<{
+    namespaces: SessionTypes.Namespaces;
+  }>
+) {
+  const accounts = Object.values(event.params.namespaces)
+    .map((namespace) => namespace.accounts)
+    .flat()
+    .map((account) => {
+      const { address, chainId } = new AccountId(account);
+      return {
+        accounts: [address],
+        chainId:
+          chainId.namespace === 'solana' ? Networks.SOLANA : chainId.reference,
+      };
+    });
+
+  return accounts;
+}

package/src/signer.ts

@@ -0,0 +1,32 @@
+import {
+  DefaultSignerFactory,
+  SignerFactory,
+  TransactionType as TxType,
+} from 'rango-types';
+
+import { WCInstance } from './types';
+import EVMSigner from './signers/evm';
+import COSMOSSigner from './signers/cosmos';
+import SOLANASigner from './signers/solana';
+
+export default function getSigners(instance: WCInstance): SignerFactory {
+  if (!instance.session) {
+    throw new Error('Session is required for wallet connect signers.');
+  }
+
+  const signers = new DefaultSignerFactory();
+  signers.registerSigner(
+    TxType.EVM,
+    new EVMSigner(instance.client, instance.session)
+  );
+  signers.registerSigner(
+    TxType.COSMOS,
+    new COSMOSSigner(instance.client, instance.session)
+  );
+  signers.registerSigner(
+    TxType.SOLANA,
+    new SOLANASigner(instance.client, instance.session)
+  );
+
+  return signers;
+}

package/src/signers/cosmos.ts

@@ -0,0 +1,243 @@
+import { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import { SessionTypes } from '@walletconnect/types';
+import { AccountId, ChainId } from 'caip';
+import type { GenericSigner } from 'rango-types';
+import { SignerError, CosmosTransaction, SignerErrorCode } from 'rango-types';
+import { CosmosRPCMethods, NAMESPACES } from '../constants';
+import { getsignedTx, manipulateMsg } from '@rango-dev/signer-cosmos';
+import {
+  AminoSignResponse,
+  BroadcastMode,
+  makeSignDoc,
+} from '@cosmjs/launchpad';
+import { sendTx } from './helper';
+import { supportedChains } from './mock';
+import { uint8ArrayToHex } from '@rango-dev/wallets-shared';
+import { cosmos } from '@keplr-wallet/cosmos';
+import { formatDirectSignDoc, stringifySignDocValues } from 'cosmos-wallet';
+
+const NAMESPACE_NAME = NAMESPACES.COSMOS;
+type DirectSignResponse = {
+  signature: {
+    pub_key: {
+      type: string;
+      value: string;
+    };
+    signature: string;
+  };
+  signed: {
+    chainId: string;
+    accountNumber: string;
+    authInfoBytes: string;
+    bodyBytes: string;
+  };
+};
+class COSMOSSigner implements GenericSigner<CosmosTransaction> {
+  private client: SignClient;
+  private session: SessionTypes.Struct;
+
+  constructor(client: SignClient, session: SessionTypes.Struct) {
+    this.client = client;
+    this.session = session;
+  }
+
+  public async signMessage(): Promise<string> {
+    throw SignerError.UnimplementedError('signMessage');
+  }
+
+  async signAndSendTx(
+    tx: CosmosTransaction,
+    address: string,
+    chainId: string | null
+  ): Promise<{ hash: string }> {
+    console.log({ tx, address, chainId });
+
+    const requestedFor = this.isNetworkAndAccountExistInSession({
+      address,
+      chainId,
+    });
+    try {
+      const { memo, sequence, account_number, chainId, msgs, fee, signType } =
+        tx.data;
+      const msgsWithoutType = msgs.map((m) => ({
+        ...manipulateMsg(m),
+        __type: undefined,
+        '@type': undefined,
+      }));
+      if (!chainId)
+        throw SignerError.AssertionFailed('chainId is undefined from server');
+      if (!account_number)
+        throw SignerError.AssertionFailed(
+          'account_number is undefined from server'
+        );
+      if (!sequence)
+        throw SignerError.AssertionFailed('sequence is undefined from server');
+
+      if (signType === 'AMINO') {
+        const signDoc = makeSignDoc(
+          msgsWithoutType as any,
+          fee as any,
+          chainId,
+          memo || undefined,
+          account_number,
+          sequence
+        );
+        let signResponse;
+        try {
+          signResponse = await this.client.request<AminoSignResponse>({
+            topic: this.session.topic,
+            chainId: requestedFor.caipChainId,
+            request: {
+              method: CosmosRPCMethods.SIGN_AMINO,
+              params: {
+                signDoc,
+                signerAddress: tx.fromWalletAddress,
+              },
+            },
+          });
+        } catch (err) {
+          throw new SignerError(SignerErrorCode.SIGN_TX_ERROR, undefined, err);
+        }
+
+        const signedTx = getsignedTx(tx, signResponse);
+        const result = await sendTx(
+          chainId,
+          signedTx,
+          BroadcastMode.Async,
+          supportedChains
+        );
+        return { hash: uint8ArrayToHex(result) };
+      } else if (signType === 'DIRECT') {
+        let getAccounts;
+        try {
+          getAccounts = await this.client.request<
+            Array<{
+              address: string;
+              algo: string;
+              pubkey: string;
+            }>
+          >({
+            topic: this.session.topic,
+            chainId: requestedFor.caipChainId,
+            request: {
+              method: CosmosRPCMethods.GET_ACCOUNTS,
+              params: {},
+            },
+          });
+        } catch (err) {
+          throw new SignerError(SignerErrorCode.SIGN_TX_ERROR, undefined, err);
+        }
+        const pubkey =
+          getAccounts?.find(
+            (account) => account.address === tx.fromWalletAddress
+          )?.pubkey || '';
+
+        const bodyBytes = cosmos.tx.v1beta1.TxBody.encode({
+          messages: tx.data.protoMsgs.map((m) => ({
+            type_url: m.type_url,
+            value: new Uint8Array(m.value),
+          })),
+          memo,
+        }).finish();
+        console.log({ tx, bodyBytes });
+
+        const signDoc = formatDirectSignDoc(
+          fee?.amount || [],
+          pubkey,
+          parseInt(fee?.gas as string),
+          account_number,
+          parseInt(sequence),
+          uint8ArrayToHex(bodyBytes),
+          chainId
+        );
+        let signResponse;
+        try {
+          signResponse = await this.client.request<DirectSignResponse>({
+            topic: this.session.topic,
+            chainId: requestedFor.caipChainId,
+            request: {
+              method: CosmosRPCMethods.SIGN_DIRECT,
+              params: {
+                signDoc: stringifySignDocValues(signDoc),
+                signerAddress: tx.fromWalletAddress,
+              },
+            },
+          });
+        } catch (err) {
+          throw new SignerError(SignerErrorCode.SIGN_TX_ERROR, undefined, err);
+        }
+        console.log({ signResponse });
+        const signedTx = cosmos.tx.v1beta1.TxRaw.encode({
+          bodyBytes: new TextEncoder().encode(signResponse.signed.bodyBytes),
+          authInfoBytes: new TextEncoder().encode(
+            signResponse.signed.authInfoBytes
+          ),
+          signatures: [Buffer.from(signResponse.signature.signature, 'base64')],
+        }).finish();
+        console.log({ signedTx });
+        const result = await sendTx(
+          chainId,
+          signedTx,
+          BroadcastMode.Async,
+          supportedChains
+        );
+
+        console.log({ result });
+
+        return { hash: uint8ArrayToHex(result) };
+      } else {
+        throw new SignerError(
+          SignerErrorCode.OPERATION_UNSUPPORTED,
+          `Sign type for cosmos not supported, type: ${signType}`
+        );
+      }
+    } catch (err) {
+      if (SignerError.isSignerError(err)) throw err;
+      else throw new SignerError(SignerErrorCode.SEND_TX_ERROR, undefined, err);
+    }
+  }
+
+  private isNetworkAndAccountExistInSession(requestedFor: {
+    address: string;
+    chainId: string | null;
+  }) {
+    const { address, chainId } = requestedFor;
+
+    if (!chainId) {
+      throw new Error(
+        'You need to set your chain for signing message/transaction.'
+      );
+    }
+
+    const caipAddress = new AccountId({
+      chainId: {
+        namespace: NAMESPACE_NAME,
+        reference: chainId,
+      },
+      address,
+    });
+    const addresses = this.session.namespaces[NAMESPACE_NAME]?.accounts.map(
+      (address) => address.toLowerCase()
+    );
+
+    if (!addresses || !addresses.includes(caipAddress.toString())) {
+      console.warn(
+        'Available adresses and requested address:',
+        addresses,
+        caipAddress.toString()
+      );
+      throw new Error(
+        `Your requested address doesn't exist on your wallect connect session. Please reconnect your wallet.`
+      );
+    }
+
+    const caipChainId = new ChainId({
+      namespace: NAMESPACE_NAME,
+      reference: chainId,
+    });
+
+    return { chainId, address, caipChainId: caipChainId.toString() };
+  }
+}
+
+export default COSMOSSigner;

package/src/signers/evm.ts

@@ -0,0 +1,134 @@
+import { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import { SessionTypes } from '@walletconnect/types';
+import { AccountId, ChainId } from 'caip';
+import type { GenericSigner } from 'rango-types';
+import { EvmTransaction } from 'rango-types/lib/api/main';
+import * as encoding from '@walletconnect/encoding';
+import { EthereumRPCMethods, NAMESPACES } from '../constants';
+
+const NAMESPACE_NAME = NAMESPACES.ETHEREUM;
+
+class EVMSigner implements GenericSigner<EvmTransaction> {
+  private client: SignClient;
+  private session: SessionTypes.Struct;
+
+  constructor(client: SignClient, session: SessionTypes.Struct) {
+    this.client = client;
+    this.session = session;
+  }
+
+  public async signMessage(
+    msg: string,
+    address: string,
+    chainId: string | null
+  ): Promise<string> {
+    const requestedFor = this.isNetworkAndAccountExistInSession({
+      address,
+      chainId,
+    });
+
+    const caipChainId = new ChainId({
+      namespace: NAMESPACE_NAME,
+      reference: requestedFor.chainId,
+    });
+    const hexMsg = encoding.utf8ToHex(msg, true);
+
+    const params = [hexMsg, address];
+
+    // Send message to wallet (using relayer)
+    const signature: string = await this.client.request({
+      topic: this.session.topic,
+      chainId: caipChainId.toString(),
+      request: {
+        method: EthereumRPCMethods.PERSONAL_SIGN,
+        params,
+      },
+    });
+
+    // TODO: We can also verify the signature here
+    // Check web-examples: dapps/react-dapp-v2/src/contexts/JsonRpcContext.tsx
+
+    return signature;
+  }
+
+  async signAndSendTx(
+    tx: EvmTransaction,
+    address: string,
+    chainId: string | null
+  ): Promise<{ hash: string }> {
+    const requestedFor = this.isNetworkAndAccountExistInSession({
+      address,
+      chainId,
+    });
+
+    const signedTx: string = await this.client.request({
+      topic: this.session.topic,
+      chainId: requestedFor.caipChainId,
+      request: {
+        method: EthereumRPCMethods.SEND_TRANSACTION,
+        params: [tx],
+      },
+    });
+
+    return {
+      hash: signedTx,
+    };
+  }
+
+  private isNetworkAndAccountExistInSession(requestedFor: {
+    address: string;
+    chainId: string | null;
+  }) {
+    const { address, chainId } = requestedFor;
+
+    if (!chainId) {
+      console.log('isNetworkAndAccountExistInSession', requestedFor);
+      throw new Error(
+        'You need to set your chain for signing message/transaction.'
+      );
+    }
+
+    // TODO: We need to make sure we are using a single format for chain ids, it should be hex or number.
+    // This is a quick fix for evm.
+    const chainIdNumber = chainId.startsWith('0x')
+      ? String(parseInt(chainId))
+      : chainId;
+
+    const caipAddress = new AccountId({
+      chainId: {
+        namespace: NAMESPACE_NAME,
+        reference: chainIdNumber,
+      },
+      address,
+    });
+    const addresses = this.session.namespaces[NAMESPACE_NAME]?.accounts.map(
+      (address) => address.toLowerCase()
+    );
+
+    if (!addresses || !addresses.includes(caipAddress.toString())) {
+      console.warn(
+        'Available adresses and requested address:',
+        addresses,
+        caipAddress.toString(),
+        chainId,
+        address
+      );
+      throw new Error(
+        `Your requested address doesn't exist on your wallect connect session. Please reconnect your wallet.`
+      );
+    }
+
+    const caipChainId = new ChainId({
+      namespace: NAMESPACE_NAME,
+      reference: chainIdNumber,
+    });
+
+    return {
+      chainId: chainIdNumber,
+      address,
+      caipChainId: caipChainId.toString(),
+    };
+  }
+}
+
+export default EVMSigner;