@rango-dev/provider-walletconnect-2 0.0.0-experimental-936229e8-20251208

package/src/signers/cosmos.ts

@@ -0,0 +1,248 @@
+import type { AminoSignResponse } from '@cosmjs/launchpad';
+import type { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import type { SessionTypes } from '@walletconnect/types';
+import type { CosmosTransaction, GenericSigner } from 'rango-types';
+
+import { BroadcastMode, makeSignDoc } from '@cosmjs/launchpad';
+import { cosmos } from '@keplr-wallet/cosmos';
+import { getsignedTx } from '@rango-dev/signer-cosmos';
+import { uint8ArrayToHex } from '@rango-dev/wallets-shared';
+import { AccountId, ChainId } from 'caip';
+import { formatDirectSignDoc, stringifySignDocValues } from 'cosmos-wallet';
+import { SignerError, SignerErrorCode } from 'rango-types';
+
+import { CosmosRPCMethods, NAMESPACES } from '../constants.js';
+
+import { sendTx } from './helper.js';
+import { supportedChains } from './mock.js';
+
+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) => ({
+        ...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,
+          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) };
+      }
+      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,163 @@
+import type { SignClient } from '@walletconnect/sign-client/dist/types/client';
+import type { SessionTypes } from '@walletconnect/types';
+import type { EvmTransaction } from 'rango-types/mainApi';
+
+import { cleanEvmError, DefaultEvmSigner } from '@rango-dev/signer-evm';
+import * as encoding from '@walletconnect/encoding';
+import { AccountId, ChainId } from 'caip';
+import { type GenericSigner } from 'rango-types';
+
+import { EthereumRPCMethods, NAMESPACES } from '../constants.js';
+
+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];
+
+    let signature: string;
+    try {
+      // Send message to wallet (using relayer)
+      signature = await this.client.request({
+        topic: this.session.topic,
+        chainId: caipChainId.toString(),
+        request: {
+          method: EthereumRPCMethods.PERSONAL_SIGN,
+          params,
+        },
+      });
+    } catch (error) {
+      throw cleanEvmError(error);
+    }
+
+    /*
+     * 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 }> {
+    try {
+      const requestedFor = this.isNetworkAndAccountExistInSession({
+        address,
+        chainId,
+      });
+      const transaction = DefaultEvmSigner.buildTx(tx);
+      const hash: string = await this.client.request({
+        topic: this.session.topic,
+        chainId: requestedFor.caipChainId,
+        request: {
+          method: EthereumRPCMethods.SEND_TRANSACTION,
+          params: [transaction],
+        },
+      });
+      // Some wallets e.g. Rainbow wallet are returning invalid hash (e.g. 'null') in case of the rejection
+      if (!hash?.startsWith('0x')) {
+        throw new Error(
+          `Received an invalid hash on signing the transaction. (hash=${hash})`
+        );
+      }
+      return {
+        hash,
+      };
+    } catch (error: any) {
+      const modifiedError = cleanEvmError(error);
+      const session = this.session;
+      const context = {
+        namspaces: session?.namespaces,
+        peering: session?.peer?.metadata,
+        code: error?.code,
+      };
+      modifiedError.context = context;
+      throw modifiedError;
+    }
+  }
+
+  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;

package/src/signers/helper.ts

@@ -0,0 +1,77 @@
+import type { BlockchainMeta } from 'rango-types';
+
+import { TendermintTxTracer } from '@keplr-wallet/cosmos';
+import { simpleFetch } from '@keplr-wallet/simple-fetch';
+import { cosmosBlockchains } from 'rango-types';
+
+export async function sendTx(
+  chainId: string,
+  tx: unknown,
+  mode: 'async' | 'sync' | 'block',
+  supportedChains: BlockchainMeta[]
+): Promise<Uint8Array> {
+  console.log({ chainId, tx, mode });
+
+  const cosmos = cosmosBlockchains(supportedChains);
+  const chainInfo = cosmos.find((item) => item.chainId === chainId)?.info;
+  const isProtoTx = Buffer.isBuffer(tx) || tx instanceof Uint8Array;
+
+  console.log({ chainInfo, isProtoTx });
+
+  if (!chainInfo) {
+    throw new Error('Chain info is undefined from server');
+  }
+  const params = isProtoTx
+    ? {
+        tx_bytes: Buffer.from(tx as any).toString('base64'),
+        mode: (() => {
+          switch (mode) {
+            case 'async':
+              return 'BROADCAST_MODE_ASYNC';
+            case 'block':
+              return 'BROADCAST_MODE_BLOCK';
+            case 'sync':
+              return 'BROADCAST_MODE_SYNC';
+            default:
+              return 'BROADCAST_MODE_UNSPECIFIED';
+          }
+        })(),
+      }
+    : {
+        tx,
+        mode: mode,
+      };
+
+  try {
+    const result = await simpleFetch<any>(
+      chainInfo.rest,
+      isProtoTx ? '/cosmos/tx/v1beta1/txs' : '/txs',
+      {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify(params),
+      }
+    );
+
+    const txResponse = isProtoTx ? result.data['tx_response'] : result.data;
+
+    if (txResponse.code != null && txResponse.code !== 0) {
+      throw new Error(txResponse['raw_log']);
+    }
+
+    const txHash = Buffer.from(txResponse.txhash, 'hex');
+
+    const txTracer = new TendermintTxTracer(chainInfo.rpc, '/websocket');
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    txTracer.traceTx(txHash).then(() => {
+      txTracer.close();
+    });
+
+    return txHash;
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}