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

package/dist/session.d.ts

@@ -0,0 +1,63 @@
+import type { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import { PairingTypes, SessionTypes, SignClientTypes } from '@walletconnect/types';
+import { ConnectParams, CreateSessionParams, WCInstance } from './types';
+export declare function getLastSession(client: SignClient): SessionTypes.Struct;
+/**
+ *
+ * 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 declare function restoreSession(client: SignClient, pairing: PairingTypes.Struct): Promise<SessionTypes.Struct | undefined>;
+/**
+ *
+ * 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 declare function createSession(client: SignClient, options: CreateSessionParams): Promise<SessionTypes.Struct>;
+/**
+ *
+ * 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 declare function tryGetPairing(client: SignClient): PairingTypes.Struct | undefined;
+/**
+ *
+ * Try to restore the session first, if couldn't, create a new session by showing a modal.
+ *
+ */
+export declare function tryConnect(client: SignClient, params: ConnectParams): Promise<SessionTypes.Struct>;
+/**
+ * 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 declare function trySwitchByCreatingNewSession(instance: WCInstance, params: ConnectParams): Promise<SessionTypes.Struct>;
+/**
+ *
+ * Try to find sessions with a topic id and expire them.
+ *
+ */
+export declare function cleanupSingleSession(client: SignClient, topic: string): Promise<void>;
+/**
+ *
+ * Disconnect means to delete the session on both parties (dApp & wallet) at the same time.
+ *
+ */
+export declare function disconnectSessions(client: SignClient): Promise<void[]>;
+export declare function getAccountsFromSession(session: SessionTypes.Struct): {
+    accounts: string[];
+    chainId: string;
+}[];
+export declare function getAccountsFromEvent(event: SignClientTypes.BaseEventArgs<{
+    namespaces: SessionTypes.Namespaces;
+}>): {
+    accounts: string[];
+    chainId: string;
+}[];
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAC/E,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAW9B,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAWzE,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,uBAEhD;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,YAAY,CAAC,MAAM,GAC3B,OAAO,CAAC,YAAY,CAAC,MAAM,GAAG,SAAS,CAAC,CAW1C;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAiC9B;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,GACjB,YAAY,CAAC,MAAM,GAAG,SAAS,CAMjC;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAkC9B;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,QAAQ,EAAE,UAAU,EACpB,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CA0B9B;AAoBD;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,iBAiB3E;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,UAAU,mBAwB1D;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,YAAY,CAAC,MAAM;;;IAgBlE;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,eAAe,CAAC,aAAa,CAAC;IACnC,UAAU,EAAE,YAAY,CAAC,UAAU,CAAC;CACrC,CAAC;;;IAeH"}

package/dist/signer.d.ts

@@ -0,0 +1,4 @@
+import { SignerFactory } from 'rango-types';
+import { WCInstance } from './types';
+export default function getSigners(instance: WCInstance): SignerFactory;
+//# sourceMappingURL=signer.d.ts.map

package/dist/signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../src/signer.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAEd,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAKrC,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,QAAQ,EAAE,UAAU,GAAG,aAAa,CAoBtE"}

package/dist/signers/cosmos.d.ts

@@ -0,0 +1,16 @@
+import { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import { SessionTypes } from '@walletconnect/types';
+import type { GenericSigner } from 'rango-types';
+import { CosmosTransaction } from 'rango-types';
+declare class COSMOSSigner implements GenericSigner<CosmosTransaction> {
+    private client;
+    private session;
+    constructor(client: SignClient, session: SessionTypes.Struct);
+    signMessage(): Promise<string>;
+    signAndSendTx(tx: CosmosTransaction, address: string, chainId: string | null): Promise<{
+        hash: string;
+    }>;
+    private isNetworkAndAccountExistInSession;
+}
+export default COSMOSSigner;
+//# sourceMappingURL=cosmos.d.ts.map

package/dist/signers/cosmos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmos.d.ts","sourceRoot":"","sources":["../../src/signers/cosmos.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAe,iBAAiB,EAAmB,MAAM,aAAa,CAAC;AA8B9E,cAAM,YAAa,YAAW,aAAa,CAAC,iBAAiB,CAAC;IAC5D,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,OAAO,CAAsB;gBAEzB,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,CAAC,MAAM;IAK/C,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IAIrC,aAAa,CACjB,EAAE,EAAE,iBAAiB,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAoJ5B,OAAO,CAAC,iCAAiC;CAyC1C;AAED,eAAe,YAAY,CAAC"}

package/dist/signers/evm.d.ts

@@ -0,0 +1,16 @@
+import { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import { SessionTypes } from '@walletconnect/types';
+import type { GenericSigner } from 'rango-types';
+import { EvmTransaction } from 'rango-types/lib/api/main';
+declare class EVMSigner implements GenericSigner<EvmTransaction> {
+    private client;
+    private session;
+    constructor(client: SignClient, session: SessionTypes.Struct);
+    signMessage(msg: string, address: string, chainId: string | null): Promise<string>;
+    signAndSendTx(tx: EvmTransaction, address: string, chainId: string | null): Promise<{
+        hash: string;
+    }>;
+    private isNetworkAndAccountExistInSession;
+}
+export default EVMSigner;
+//# sourceMappingURL=evm.d.ts.map

package/dist/signers/evm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evm.d.ts","sourceRoot":"","sources":["../../src/signers/evm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAM1D,cAAM,SAAU,YAAW,aAAa,CAAC,cAAc,CAAC;IACtD,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,OAAO,CAAsB;gBAEzB,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,CAAC,MAAM;IAK/C,WAAW,CACtB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,MAAM,CAAC;IA8BZ,aAAa,CACjB,EAAE,EAAE,cAAc,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAoB5B,OAAO,CAAC,iCAAiC;CAsD1C;AAED,eAAe,SAAS,CAAC"}

package/dist/signers/helper.d.ts

@@ -0,0 +1,3 @@
+import { BlockchainMeta } from 'rango-types';
+export declare function sendTx(chainId: string, tx: unknown, mode: 'async' | 'sync' | 'block', supportedChains: BlockchainMeta[]): Promise<Uint8Array>;
+//# sourceMappingURL=helper.d.ts.map

package/dist/signers/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../src/signers/helper.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAqB,MAAM,aAAa,CAAC;AAChE,wBAAsB,MAAM,CAC1B,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,OAAO,EACX,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,EAChC,eAAe,EAAE,cAAc,EAAE,GAChC,OAAO,CAAC,UAAU,CAAC,CAgErB"}

package/dist/signers/mock.d.ts

@@ -0,0 +1,3 @@
+import { BlockchainMeta } from 'rango-types';
+export declare const supportedChains: BlockchainMeta[];
+//# sourceMappingURL=mock.d.ts.map

package/dist/signers/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../src/signers/mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,eAAe,EAAE,cAAc,EAwlH3C,CAAC"}

package/dist/signers/solana.d.ts

@@ -0,0 +1,15 @@
+import { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import { SessionTypes } from '@walletconnect/types';
+import type { GenericSigner, SolanaTransaction } from 'rango-types';
+declare class SOLANASigner implements GenericSigner<SolanaTransaction> {
+    private client;
+    private session;
+    constructor(client: SignClient, session: SessionTypes.Struct);
+    signMessage(msg: string, address: string, chainId: string | null): Promise<string>;
+    signAndSendTx(tx: SolanaTransaction, address: string, chainId: string | null): Promise<{
+        hash: string;
+    }>;
+    private isNetworkAndAccountExistInSession;
+}
+export default SOLANASigner;
+//# sourceMappingURL=solana.d.ts.map

package/dist/signers/solana.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solana.d.ts","sourceRoot":"","sources":["../../src/signers/solana.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAWpE,cAAM,YAAa,YAAW,aAAa,CAAC,iBAAiB,CAAC;IAC5D,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,OAAO,CAAsB;gBAEzB,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,CAAC,MAAM;IAK/C,WAAW,CACtB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,MAAM,CAAC;IAkCZ,aAAa,CACjB,EAAE,EAAE,iBAAiB,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAgC5B,OAAO,CAAC,iCAAiC;CAuD1C;AAED,eAAe,YAAY,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+import type { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import type { ProposalTypes, SessionTypes } from '@walletconnect/types';
+import type { BlockchainMeta, CosmosBlockchainMeta } from 'rango-types/lib';
+export interface WCInstance {
+    client: SignClient;
+    session: SessionTypes.Struct | null;
+    request: (params: any) => Promise<string>;
+}
+export interface CreateSessionParams {
+    requiredNamespaces: ProposalTypes.RequiredNamespaces;
+    optionalNamespaces?: ProposalTypes.OptionalNamespaces;
+    pairingTopic?: string;
+}
+export interface ConnectParams {
+    network: string;
+    meta: BlockchainMeta[];
+}
+export interface CosmosMeta extends CosmosBlockchainMeta {
+    chainId: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5E,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,YAAY,CAAC,MAAM,GAAG,IAAI,CAAC;IACpC,OAAO,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,mBAAmB;IAClC,kBAAkB,EAAE,aAAa,CAAC,kBAAkB,CAAC;IACrD,kBAAkB,CAAC,EAAE,aAAa,CAAC,kBAAkB,CAAC;IACtD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,cAAc,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IAEtD,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@rango-dev/provider-walletconnect-2",
+  "version": "0.1.1-next.0",
+  "license": "MIT",
+  "type": "module",
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/build/command.mjs --path wallets/provider-walletconnect-2",
+    "clean": "rimraf dist",
+    "format": "prettier --write '{.,src}/**/*.{ts,tsx}'",
+    "lint": "eslint \"**/*.{ts,tsx}\" --ignore-path ../../.eslintignore"
+  },
+  "dependencies": {
+    "@keplr-wallet/simple-fetch": "^0.12.14",
+    "@rango-dev/signer-evm": "^0.8.1-next.2",
+    "@rango-dev/wallets-shared": "^0.8.1-next.2",
+    "@walletconnect/encoding": "^1.0.2",
+    "@walletconnect/sign-client": "^2.8.1",
+    "@walletconnect/utils": "^2.9.1",
+    "@web3modal/standalone": "^2.4.3",
+    "bs58": "^5.0.0",
+    "caip": "^1.1.0",
+    "cosmos-wallet": "^1.2.0",
+    "rango-types": "^0.1.47"
+  },
+  "devDependencies": {
+    "@walletconnect/types": "^2.8.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/readme.md

@@ -0,0 +1,10 @@
+# @rango-dev/provider-walletconnect2
+
+
+## Known issues
+
+- Trust wallet doesn't return optional namespaces other than evms on its response. So Solana and Cosmos will be ask for connect in wallet but we can not use them.
+- Using Private key to import wallets other than `Ethereum` will be problematic. Because it imports only a single blockchain and we are by default asking for `Ethereum`.  
+- Signing a transaction on Metamask goes through an internal error.
+- We couldn't update exist session during a bug in `@walletconnect/utils`, so we are creating new session for accessing to new chains.
+

package/src/constants.ts

@@ -0,0 +1,83 @@
+import { Networks } from '@rango-dev/wallets-shared';
+
+export const DEFAULT_NETWORK = Networks.ETHEREUM;
+export const PING_TIMEOUT = 10_000;
+
+export enum NAMESPACES {
+  ETHEREUM = 'eip155',
+  SOLANA = 'solana',
+  COSMOS = 'cosmos',
+  POLKADOT = 'polkadot',
+  CARDANO = 'cip34',
+  ERLOND = 'elrond',
+  MULTIVERSX = 'multiversx',
+}
+
+// Refrence: https://docs.walletconnect.com/2.0/advanced/rpc-reference/solana-rpc
+export enum SolanaRPCMethods {
+  GET_ACCOUNTS = 'solana_getAccounts',
+  REQUEST_ACCOUNTS = 'solana_requestAccounts',
+  SIGN_TRANSACTION = 'solana_signTransaction',
+  SIGN_MESSAGE = 'solana_signMessage',
+}
+
+// Refrence: https://docs.walletconnect.com/2.0/advanced/rpc-reference/cosmos-rpc
+export enum CosmosRPCMethods {
+  GET_ACCOUNTS = 'cosmos_getAccounts',
+  SIGN_DIRECT = 'cosmos_signDirect',
+  SIGN_AMINO = 'cosmos_signAmino',
+}
+
+// Refrence: https://docs.walletconnect.com/2.0/advanced/rpc-reference/ethereum-rpc
+export enum EthereumRPCMethods {
+  PERSONAL_SIGN = 'personal_sign',
+  SIGN = 'eth_sign',
+  SIGN_TYPED_DATA = 'eth_signTypedData',
+  SIGN_TRANSACTION = 'eth_signTransaction',
+  SEND_TRANSACTION = 'eth_sendTransaction',
+  SEND_RAW_TRANSACTION = 'eth_sendRawTransaction',
+}
+
+export enum StarknetRPCMethods {
+  REQUEST_ADD_INVOKE_TRANSACTION = 'starknet_requestAddInvokeTransaction',
+  SIGN_TYPED_DATA = 'starknet_signTypedData',
+}
+
+export enum EthereumEvents {
+  CHAIN_CHANGED = 'chainChanged',
+  ACCOUNTS_CHANGED = 'accountsChanged',
+}
+
+export const DEFAULT_ETHEREUM_EVENTS: EthereumEvents[] = [
+  EthereumEvents.CHAIN_CHANGED,
+  EthereumEvents.ACCOUNTS_CHANGED,
+];
+
+export const DEFAULT_ETHEREUM_METHODS = [
+  EthereumRPCMethods.PERSONAL_SIGN,
+  EthereumRPCMethods.SEND_TRANSACTION,
+  EthereumRPCMethods.SIGN_TRANSACTION,
+];
+export const DEFAULT_SOLANA_METHODS = [
+  SolanaRPCMethods.SIGN_TRANSACTION,
+  SolanaRPCMethods.SIGN_MESSAGE,
+];
+export const DEFAULT_COSMOS_METHODS = [
+  CosmosRPCMethods.GET_ACCOUNTS,
+  CosmosRPCMethods.SIGN_AMINO,
+  CosmosRPCMethods.SIGN_DIRECT,
+];
+
+// refrence: https://github.com/ChainAgnostic/namespaces/blob/main/solana/caip2.md
+export const DEFAULT_SOLANA_CHAIN_ID = '4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ';
+
+export const DEFAULT_APP_METADATA = {
+  name: 'Rango Exchange',
+  description:
+    'Easiest DEX UX with best price to exchange all coins on all blockchains.',
+  url: 'https://app.rango.exchange/',
+  icons: ['https://avatars.githubusercontent.com/u/37784886'],
+};
+
+export const PROJECT_ID = 'f5196d081862c6f2b81c04520ea9301c';
+export const RELAY_URL = 'wss://relay.walletconnect.com';

package/src/helpers.ts

@@ -0,0 +1,165 @@
+import { WalletState } from '@rango-dev/wallets-shared';
+import { Networks } from '@rango-dev/wallets-shared';
+import { ProposalTypes } from '@walletconnect/types';
+import { ChainId } from 'caip';
+import { BlockchainMeta, cosmosBlockchains, evmBlockchains } from 'rango-types';
+
+import {
+  DEFAULT_COSMOS_METHODS,
+  DEFAULT_ETHEREUM_EVENTS,
+  DEFAULT_ETHEREUM_METHODS,
+  DEFAULT_SOLANA_CHAIN_ID,
+  DEFAULT_SOLANA_METHODS,
+  NAMESPACES,
+} from './constants';
+import { getLastSession } from './session';
+import { CosmosMeta } from './types';
+
+type FinalNamespaces = {
+  [key in NAMESPACES]?: ProposalTypes.BaseRequiredNamespace;
+};
+
+export function generateRequiredNamespace(
+  meta: BlockchainMeta[],
+  network: string
+): FinalNamespaces | undefined {
+  const evm = evmBlockchains(meta);
+  const cosmos = cosmosBlockchains(meta);
+
+  const requiredEvmChain = evm.find((chain) => chain.name === network);
+  const requiredCosmosChain = cosmos.find((chain) => chain.name === network);
+  const requiredSolanaChain = network === Networks.SOLANA;
+
+  if (requiredEvmChain) {
+    return {
+      [NAMESPACES.ETHEREUM]: {
+        events: DEFAULT_ETHEREUM_EVENTS,
+        methods: DEFAULT_ETHEREUM_METHODS,
+        chains: [
+          new ChainId({
+            namespace: NAMESPACES.ETHEREUM,
+            reference: String(parseInt(requiredEvmChain.chainId)),
+          }).toString(),
+        ],
+      },
+    };
+  } else if (!!requiredCosmosChain) {
+    return {
+      [NAMESPACES.COSMOS]: {
+        events: [],
+        methods: DEFAULT_COSMOS_METHODS,
+        chains: [
+          new ChainId({
+            namespace: NAMESPACES.COSMOS,
+            reference: requiredCosmosChain.chainId!,
+          }).toString(),
+        ],
+      },
+    };
+  } else if (requiredSolanaChain) {
+    return {
+      [NAMESPACES.SOLANA]: {
+        events: [],
+        methods: DEFAULT_SOLANA_METHODS,
+        chains: [`solana:${DEFAULT_SOLANA_CHAIN_ID}`],
+      },
+    };
+  }
+
+  return undefined;
+}
+
+export function generateOptionalNamespace(
+  meta: BlockchainMeta[]
+): FinalNamespaces | undefined {
+  const evm = evmBlockchains(meta);
+  const cosmos = cosmosBlockchains(meta);
+
+  return {
+    [NAMESPACES.ETHEREUM]: {
+      methods: DEFAULT_ETHEREUM_METHODS,
+      events: DEFAULT_ETHEREUM_EVENTS,
+      chains: evm.map((chain) => {
+        return new ChainId({
+          namespace: NAMESPACES.ETHEREUM,
+          reference: String(parseInt(chain.chainId)),
+        }).toString();
+      }),
+    },
+    [NAMESPACES.COSMOS]: {
+      methods: DEFAULT_COSMOS_METHODS,
+      events: [],
+      chains: cosmos
+        .filter((chain): chain is CosmosMeta => !!chain.chainId)
+        .map((chain) => {
+          return new ChainId({
+            namespace: NAMESPACES.COSMOS,
+            reference: chain.chainId,
+          }).toString();
+        }),
+    },
+    [NAMESPACES.SOLANA]: {
+      methods: DEFAULT_SOLANA_METHODS,
+      events: [],
+      chains: [`solana:${DEFAULT_SOLANA_CHAIN_ID}`],
+    },
+  };
+}
+
+export function solanaChainIdToNetworkName(chainId: string): string {
+  return chainId === DEFAULT_SOLANA_CHAIN_ID ? Networks.SOLANA : chainId;
+}
+
+/**
+ *
+ * In `rango-preset` we are working with `window.ethereum.request()`,
+ * this is an interceptor for some RPC methods (e.g. eth_chainId).
+ *
+ */
+export async function simulateRequest(
+  params: any,
+  provider: any,
+  meta: BlockchainMeta[],
+  getState: () => WalletState
+) {
+  if (params.method === 'eth_chainId') {
+    const currentSession = getLastSession(provider);
+    const standaloneChains = Object.values(currentSession.namespaces)
+      .map((namespace) => namespace.chains)
+      .flat() as string[];
+
+    const network = getState().network;
+
+    if (standaloneChains.length > 0) {
+      const chainId = network
+        ? getChainIdByNetworkName(network, meta)
+        : undefined;
+
+      if (chainId) {
+        return chainId;
+      } else {
+        const firstChain = standaloneChains[0];
+        const chainId = new ChainId(firstChain);
+        return chainId.reference;
+      }
+    } else {
+      throw new Error(`Couldn't find any chain on namespace`);
+    }
+  }
+  throw new Error('Dissallowed method:', params);
+}
+
+export function getChainIdByNetworkName(
+  network: string,
+  meta: BlockchainMeta[]
+): string | undefined {
+  const targetBlockchain = meta.find(
+    (blockchain) => blockchain.name === network
+  );
+  const chainIdInHex = targetBlockchain?.chainId;
+  if (!chainIdInHex) return undefined;
+
+  const chainId = String(parseInt(chainIdInHex));
+
+  return chainId;
+}

package/src/index.ts

@@ -0,0 +1,177 @@
+import {
+  WalletTypes,
+  CanSwitchNetwork,
+  Connect,
+  Disconnect,
+  GetInstance,
+  Subscribe,
+  SwitchNetwork,
+  WalletConfig,
+  WalletInfo,
+} from '@rango-dev/wallets-shared';
+import { SignerFactory, BlockchainMeta } from 'rango-types';
+import type { ISignClient } from '@walletconnect/types';
+import Client from '@walletconnect/sign-client';
+
+import signer from './signer';
+import {
+  disconnectSessions,
+  cleanupSingleSession,
+  getAccountsFromEvent,
+  getAccountsFromSession,
+  tryConnect,
+  trySwitchByCreatingNewSession,
+} from './session';
+import {
+  DEFAULT_APP_METADATA,
+  DEFAULT_NETWORK,
+  EthereumEvents,
+  PROJECT_ID,
+  RELAY_URL,
+} from './constants';
+import { simulateRequest } from './helpers';
+import type { WCInstance } from './types';
+
+const WALLET = WalletTypes.WALLET_CONNECT_2;
+
+export const config: WalletConfig = {
+  type: WALLET,
+  checkInstallation: false,
+  isAsyncInstance: true,
+  defaultNetwork: DEFAULT_NETWORK,
+};
+
+export const getInstance: GetInstance = async (options) => {
+  const { currentProvider, getState, meta } = options;
+
+  /*
+    Create a new pair, if exists use the pair,
+    Or use the already created one.
+  */
+  let provider: ISignClient;
+  if (!currentProvider) {
+    provider = await Client.init({
+      relayUrl: RELAY_URL,
+      projectId: PROJECT_ID,
+      metadata: DEFAULT_APP_METADATA,
+    });
+  } else {
+    provider = currentProvider;
+  }
+
+  return {
+    client: provider,
+    session: null,
+    request: (params: any) => simulateRequest(params, provider, meta, getState),
+  };
+};
+
+export const connect: Connect = async ({ instance, network, meta }) => {
+  const { client } = instance as WCInstance;
+
+  const requestedNetwork = network || DEFAULT_NETWORK;
+
+  // Try to restore the session first, if couldn't, create a new session by showing a modal.
+  const session = await tryConnect(client, {
+    network: requestedNetwork,
+    meta,
+  });
+  // Override the value (session).
+  instance.session = session;
+
+  const accounts = getAccountsFromSession(session);
+  return accounts;
+};
+
+export const subscribe: Subscribe = ({
+  instance,
+  updateChainId,
+  updateAccounts,
+  disconnect,
+}) => {
+  const { client } = instance as WCInstance;
+
+  /**
+   * Session events refrence:
+   * https://docs.walletconnect.com/2.0/specs/clients/sign/session-events
+   */
+
+  // Listen to updating the session by adding a new chain, method, or event
+  client.on('session_update', (args) => {
+    const allAccounts = getAccountsFromEvent(args);
+    allAccounts.forEach((accountsWithChain) => {
+      updateAccounts(accountsWithChain.accounts, accountsWithChain.chainId);
+    });
+  });
+
+  // Listen to events triggred by wallet. (e.g. accountsChanged and chainChanged)
+  client.on('session_event', (args) => {
+    if (args.params.event.name === EthereumEvents.ACCOUNTS_CHANGED) {
+      const accounts = args.params.event.data;
+      const chainId = args.params.chainId;
+      updateAccounts(accounts);
+      updateChainId(chainId);
+    } else if (args.params.event.name === EthereumEvents.CHAIN_CHANGED) {
+      const chainId = args.params.chainId;
+      updateChainId(chainId);
+    } else {
+      console.log('[WC2] session_event not supported', args.params.event);
+    }
+  });
+
+  client.on('session_delete', async (event) => {
+    console.log('[WC2] your wallet has requested to delete session.', event);
+    cleanupSingleSession(client, event.topic);
+    disconnect();
+  });
+};
+
+export const switchNetwork: SwitchNetwork = async ({
+  network,
+  instance,
+  meta,
+}) => {
+  /**
+   * 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.
+   */
+  const session = await trySwitchByCreatingNewSession(instance, {
+    network,
+    meta,
+  });
+  instance.session = session;
+};
+
+/**
+ *
+ * Note:
+ * There is no straight-forward way to detect the wallet supports which blockchain,
+ * So we send request to wallet and expect to be rejected on the wallet if it's not supported.
+ *
+ */
+export const canSwitchNetworkTo: CanSwitchNetwork = () => true;
+
+export const disconnect: Disconnect = async ({ instance }) => {
+  const { client } = instance as WCInstance;
+
+  if (client) {
+    disconnectSessions(client);
+  }
+};
+
+export const getSigners: (provider: WCInstance) => SignerFactory = signer;
+
+export const getWalletInfo: (allBlockChains: BlockchainMeta[]) => WalletInfo = (
+  allBlockChains
+) => {
+  return {
+    name: 'WalletConnect',
+    img: 'https://raw.githubusercontent.com/rango-exchange/rango-types/main/assets/icons/wallets/walletconnect.svg',
+    installLink: '',
+    color: '#b2dbff',
+    supportedChains: allBlockChains,
+    showOnMobile: true,
+    mobileWallet: true,
+  };
+};