@rango-dev/provider-walletconnect-2 0.53.2-next.2 → 0.53.2-next.4

package/src/signers/cosmos.ts

@@ -1,248 +0,0 @@
-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/helper.ts

@@ -1,77 +0,0 @@
-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;
-  }
-}