@getpara/graz-connector 0.1.0-alpha.6 → 2.0.0-dev.11

package/package.json

@@ -1,25 +1,36 @@
 {
   "name": "@getpara/graz-connector",
-  "version": "0.1.0-alpha.6",
+  "version": "2.0.0-dev.11",
+  "sideEffects": false,
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "sideEffects": false,
-  "dependencies": {
-    "@getpara/react-sdk": "1.11.0",
-    "@getpara/cosmjs-v0-integration": "1.11.0"
-  },
   "scripts": {
     "build": "rm -rf dist && yarn typegen && node ./scripts/build.mjs",
+    "test": "vitest run --coverage",
     "typegen": "tsc --emitDeclarationOnly"
   },
+  "dependencies": {
+    "@getpara/cosmjs-v0-integration": "~2.0.0-alpha.44",
+    "@getpara/web-sdk": "~2.0.0-alpha.44"
+  },
   "devDependencies": {
-    "@cosmjs/amino": "^0.32.3",
-    "@cosmjs/encoding": "^0.32.3",
-    "@cosmjs/proto-signing": "^0.32.3",
-    "cosmjs-types": "0.9.0",
-    "typescript": "5.1.6",
-    "graz": "0.2.1",
-    "@keplr-wallet/types": "0.12.221"
+    "@cosmjs/amino": "^0.32.4",
+    "@cosmjs/encoding": "^0.32.4",
+    "@cosmjs/proto-signing": "^0.32.4",
+    "@keplr-wallet/types": "^0.12.156",
+    "cosmjs-types": "^0.9.0",
+    "graz": "^0.3.3",
+    "typescript": "5.1.6"
+  },
+  "peerDependencies": {
+    "@cosmjs/amino": ">=0.32.4",
+    "@cosmjs/encoding": ">=0.32.4",
+    "@cosmjs/proto-signing": ">=0.32.4",
+    "@cosmjs/stargate": ">=0.32.4",
+    "@cosmjs/tendermint-rpc": ">=0.32.4",
+    "@keplr-wallet/types": ">=0.12.156",
+    "cosmjs-types": ">=0.8.0",
+    "graz": ">=0.3.3"
   }
 }

package/src/connector.ts

@@ -1,153 +1,211 @@
-import ParaWeb from '@getpara/react-sdk';
-import type { Environment, ParaModalProps } from '@getpara/react-sdk';
-import type { Wallet, Key as GrazKey } from 'graz';
-import { getChainInfo } from 'graz';
-import type {
-  OfflineAminoSigner,
-  OfflineDirectSigner,
-  AminoSignResponse,
-  StdSignDoc,
-  StdSignature,
-  DirectSignResponse,
-  AccountData,
-  Algo,
-  SignDoc as KeplrSignDoc,
-  SignDoc,
-} from '@keplr-wallet/types';
-import { ParaAminoSigner, ParaProtoSigner } from '@getpara/cosmjs-v0-integration';
 import { fromBech32 } from '@cosmjs/encoding';
-import { renderModal } from './connectorModal.js';
-import Long from 'long';
+import { SignDoc } from 'cosmjs-types/cosmos/tx/v1beta1/tx.js';
+import { Wallet, SignDoc as GrazSignDoc } from 'graz';
+import { ParaAminoSigner, ParaProtoSigner } from '@getpara/cosmjs-v0-integration';
+import { ParaWeb, Wallet as ParaWallet } from '@getpara/web-sdk';
+import { Algo, DirectSignResponse, OfflineDirectSigner } from '@cosmjs/proto-signing';
+import { AccountData, AminoSignResponse, OfflineAminoSigner, StdSignature, StdSignDoc } from '@cosmjs/amino';
+import { ChainInfo, KeplrSignOptions } from '@keplr-wallet/types';
 
-const TEN_MINUTES_MS = 600000;
+export type ParaGrazConnectorEvents = {
+  onEnabled?: (chainIds: string[], connector: ParaGrazConnector) => void;
+};
 
 export interface ParaGrazConfig {
-  apiKey: string;
-  env: Environment;
-  modalProps?: ParaModalProps;
+  paraWeb: ParaWeb;
+  events?: ParaGrazConnectorEvents;
+  noModal?: boolean;
+}
+
+export function toArray<T>(v: T | T[]): T[] {
+  return Array.isArray(v) ? v : [v];
 }
 
-export class ParaOfflineSigner implements OfflineDirectSigner {
-  private chainId: string;
-  private paraWebClient: ParaWeb;
+class ParaOfflineSigner implements OfflineDirectSigner {
+  constructor(
+    protected readonly chainId: string,
+    protected readonly connector: ParaGrazConnector,
+  ) {}
+
+  protected get para() {
+    return this.connector.getParaWebClient();
+  }
+
+  protected get prefix() {
+    return this.connector.getBech32Prefix(this.chainId);
+  }
 
-  constructor(chainId: string, paraWebClient: ParaWeb) {
-    this.chainId = chainId;
-    this.paraWebClient = paraWebClient;
+  protected async wallet() {
+    return this.connector.getFirstWallet();
   }
 
   async getAccounts(): Promise<readonly AccountData[]> {
-    const key = await getKey(this.paraWebClient, this.chainId);
+    const key = await this.connector.getKey(this.chainId);
     return [
       {
-        address: key.address,
+        address: key.bech32Address,
         algo: key.algo as Algo,
-        pubkey: key.pubkey,
+        pubkey: key.pubKey,
       },
     ];
   }
 
-  async signDirect(signerAddress: string, signDoc: KeplrSignDoc): Promise<DirectSignResponse> {
+  async signDirect(signerAddress: string, signDoc: SignDoc): Promise<DirectSignResponse> {
     if (this.chainId !== signDoc.chainId) {
-      throw new Error('Chain ID does not match signer chain ID');
+      throw new Error(`Chain ID mismatch: expected ${this.chainId}, got ${signDoc.chainId}`);
     }
 
     const accounts = await this.getAccounts();
-    if (accounts.find(account => account.address !== signerAddress)) {
-      throw new Error('Signer address does not match wallet address');
+    if (accounts.every(a => a.address !== signerAddress)) {
+      throw new Error(`Signer address ${signerAddress} not found in wallet`);
     }
 
-    const convertedSignDoc = {
-      bodyBytes: signDoc.bodyBytes,
-      authInfoBytes: signDoc.authInfoBytes,
-      chainId: signDoc.chainId,
-      accountNumber: typeof signDoc.accountNumber === 'string' ? signDoc.accountNumber : signDoc.accountNumber.toString(),
-    };
-
-    const result = await requestSignature(this.paraWebClient, this.chainId, signerAddress, convertedSignDoc);
+    const signer = new ParaProtoSigner(this.para, this.prefix, (await this.wallet()).id);
 
-    return {
-      signed: {
-        bodyBytes: result.signed.bodyBytes,
-        authInfoBytes: result.signed.authInfoBytes,
-        chainId: result.signed.chainId,
-        accountNumber: Long.fromString(result.signed.accountNumber.toString()),
-      },
-      signature: result.signature,
-    };
+    try {
+      const result = await signer.signDirect(signerAddress, signDoc);
+      return {
+        signed: {
+          bodyBytes: result.signed.bodyBytes,
+          authInfoBytes: result.signed.authInfoBytes,
+          chainId: result.signed.chainId,
+          accountNumber: result.signed.accountNumber,
+        },
+        signature: result.signature,
+      };
+    } catch (err) {
+      throw new Error(`Direct signing failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
   }
 }
 
 export class ParaGrazConnector implements Omit<Wallet, 'experimentalSuggestChain'> {
-  private paraWebClient: ParaWeb;
-  private config: ParaGrazConfig;
-  private isModalClosed: boolean;
+  protected paraWebClient: ParaWeb;
+  protected enabledChainIds = new Set<string>();
+  protected readonly events?: ParaGrazConnectorEvents;
+  protected noModal?: boolean;
+
+  constructor(
+    protected readonly config: ParaGrazConfig,
+    protected readonly chains: ChainInfo[] | null = null,
+  ) {
+    if (!config?.paraWeb) {
+      throw new Error('ParaWeb instance required in config');
+    }
+    this.events = config.events;
+    this.paraWebClient = config.paraWeb;
+    this.noModal = config.noModal;
+  }
 
-  constructor(config: ParaGrazConfig) {
-    if (!config || !config.apiKey || !config.env) {
-      throw new Error('Para Connector: Missing API Key or Environment in config.');
+  protected async ensureChainEnabled(chainId: string): Promise<void> {
+    if (!this.enabledChainIds.has(chainId)) {
+      throw new Error(`Chain ${chainId} not enabled. Call enable() first`);
+    }
+
+    if (!(await this.paraWebClient.isFullyLoggedIn())) {
+      throw new Error('Para wallet not authenticated');
     }
-    this.config = config;
-    this.paraWebClient = new ParaWeb(config.env, config.apiKey);
-    this.isModalClosed = true;
   }
 
-  closeModal = () => {
-    this.isModalClosed = true;
-  };
+  protected async waitForLogin(timeoutMs = 60_000): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    let delay = 500;
+    const MAX_DELAY = 5_000;
 
-  private async waitForLogin(timeoutMs = TEN_MINUTES_MS): Promise<boolean> {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
+    while (true) {
       if (await this.paraWebClient.isFullyLoggedIn()) {
-        return true;
+        return;
       }
 
-      if (this.isModalClosed) {
-        throw new Error('user closed modal');
+      if (Date.now() >= deadline) {
+        throw new Error(`Login timeout after ${timeoutMs / 1000}s`);
       }
 
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      await new Promise(r => setTimeout(r, delay));
+      delay = Math.min(delay * 1.5, MAX_DELAY);
     }
-
-    throw new Error('timed out waiting for user to log in');
   }
 
-  private async waitForAccounts(chainIds: string | string[], timeoutMs = 5000): Promise<boolean> {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-      if (wallets && wallets.length > 0) {
-        return true;
+  protected async waitForAccounts(timeoutMs = 5_000): Promise<ParaWallet[]> {
+    const deadline = Date.now() + timeoutMs;
+    let delay = 250;
+    const MAX_DELAY = 1_000;
+
+    while (true) {
+      const wallets = this.paraWebClient.getWalletsByType('COSMOS');
+      if (wallets.length) {
+        return wallets;
+      }
+
+      if (Date.now() >= deadline) {
+        throw new Error('No Cosmos wallets found');
       }
-      await new Promise(resolve => setTimeout(resolve, 500));
+
+      await new Promise(r => setTimeout(r, delay));
+      delay = Math.min(delay * 1.5, MAX_DELAY);
     }
+  }
 
-    throw new Error('timed out waiting for accounts to load');
+  protected async hasCosmosWallet(): Promise<boolean> {
+    const isLoggedIn = await this.paraWebClient.isFullyLoggedIn();
+    const wallets = this.paraWebClient.getWalletsByType('COSMOS');
+    return isLoggedIn && wallets.length > 0;
   }
 
-  async enable(chainIds: string | string[]): Promise<void> {
-    if (await this.paraWebClient.isFullyLoggedIn()) {
-      const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-      if (wallets && wallets.length > 0) {
+  async enable(chainIdsInput: string | string[]): Promise<void> {
+    const chainIds = toArray(chainIdsInput);
+    const previousEnabled = new Set(this.enabledChainIds);
+
+    try {
+      chainIds.forEach(id => this.enabledChainIds.add(id));
+
+      if (await this.hasCosmosWallet()) {
+        this.events?.onEnabled?.(chainIds, this);
         return;
       }
-    }
 
-    this.isModalClosed = false;
-    renderModal(this.paraWebClient, this.config.modalProps, () => {
-      this.isModalClosed = true;
-    });
+      if (!this.noModal) {
+        throw new Error('Modal not supported. Use @getpara/graz-integration or set noModal: true');
+      }
+
+      await this.waitForLogin();
+      await this.waitForAccounts();
+      this.events?.onEnabled?.(chainIds, this);
+    } catch (err) {
+      this.enabledChainIds = previousEnabled;
+
+      if (err instanceof Error) {
+        throw err;
+      }
+
+      throw new Error('Failed to enable Para wallet');
+    }
+  }
 
-    await this.waitForLogin();
+  async disconnect(): Promise<void> {
+    try {
+      await this.paraWebClient.logout();
+    } catch (err) {
+      throw new Error('Disconnect failed');
+    } finally {
+      this.enabledChainIds.clear();
+    }
+  }
 
+  async getFirstWallet(): Promise<ParaWallet> {
     try {
-      await this.waitForAccounts(chainIds);
-    } catch (error) {
-      throw new Error('accounts not available after login');
+      const [wallet] = await this.waitForAccounts();
+      return wallet;
+    } catch (err) {
+      throw new Error('No Para wallet available');
     }
   }
 
+  getBech32Prefix(chainId: string): string {
+    const prefix = this.chains?.find(c => c.chainId === chainId)?.bech32Config?.bech32PrefixAccAddr || 'cosmos';
+    return prefix;
+  }
+
   getParaWebClient(): ParaWeb {
     return this.paraWebClient;
   }
@@ -156,215 +214,142 @@ export class ParaGrazConnector implements Omit<Wallet, 'experimentalSuggestChain
     return this.config;
   }
 
-  async getKey(chainId: string): Promise<GrazKey> {
-    const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-
-    if (wallets.length === 0) {
-      throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
-    }
-
-    // Get the bech32 prefix from chain info
-    const bech32Prefix = this.getBech32Prefix(chainId);
-
-    const walletSigner = new ParaProtoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
-    const accountData = await walletSigner.getAccounts();
-    if (accountData.length === 0) {
-      throw new Error(`Para Connector: No accounts found for wallet ${wallets[0].id}`);
-    }
-
-    const account = accountData[0];
+  protected buildHybridSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
+    const aminoSigner = this.getOfflineSignerOnlyAmino(chainId);
+    const directSigner = new ParaOfflineSigner(chainId, this);
     return {
-      address: fromBech32(account.address).data,
-      bech32Address: account.address,
-      algo: account.algo,
-      name: account.address,
-      pubKey: account.pubkey,
-      isKeystone: false,
-      isNanoLedger: false,
-    };
+      getAccounts: () => directSigner.getAccounts(),
+      signAmino: (signer: string, signDoc: StdSignDoc) => aminoSigner.signAmino(signer, signDoc),
+      signDirect: (signer: string, signDoc: SignDoc) => directSigner.signDirect(signer, signDoc),
+    } as unknown as OfflineAminoSigner & OfflineDirectSigner;
   }
 
-  getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
-    const aminoSigner = this.getOfflineSignerOnlyAmino(chainId);
-    const directSigner = new ParaOfflineSigner(chainId, this.paraWebClient);
+  async getKey(chainId: string) {
+    try {
+      await this.ensureChainEnabled(chainId);
+      const wallet = await this.getFirstWallet();
+      const signer = new ParaProtoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+      const [account] = await signer.getAccounts();
 
-    const combinedSigner = {
-      getAccounts: () => directSigner.getAccounts(),
-      signAmino: (signerAddress: string, signDoc: StdSignDoc) => aminoSigner.signAmino(signerAddress, signDoc),
-      signDirect: (signerAddress: string, signDoc: SignDoc) => directSigner.signDirect(signerAddress, signDoc),
-    };
+      if (!account) {
+        throw new Error(`No Cosmos accounts for chain ${chainId}`);
+      }
+
+      return {
+        name: 'Para Wallet',
+        algo: account.algo,
+        pubKey: account.pubkey,
+        address: fromBech32(account.address).data,
+        bech32Address: account.address,
+        isKeystone: false,
+        isNanoLedger: false,
+      };
+    } catch (err) {
+      if (err instanceof Error) {
+        throw err;
+      }
 
-    return combinedSigner as unknown as OfflineAminoSigner & OfflineDirectSigner;
+      throw new Error(`Failed to get key for chain ${chainId}`);
+    }
   }
 
   getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner {
-    const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-    if (wallets.length === 0) {
-      throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
+    void this.ensureChainEnabled(chainId);
+    const wallet = this.paraWebClient.getWalletsByType('COSMOS')[0];
+
+    if (!wallet) {
+      throw new Error('No Cosmos wallet for Amino signing');
     }
 
-    const bech32Prefix = this.getBech32Prefix(chainId);
+    return new ParaAminoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+  }
 
-    return new ParaAminoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
+  getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
+    void this.ensureChainEnabled(chainId);
+    return this.buildHybridSigner(chainId);
   }
 
-  getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner> {
-    return Promise.resolve(this.getOfflineSignerOnlyAmino(chainId));
+  async getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner> {
+    void this.ensureChainEnabled(chainId);
+    return this.buildHybridSigner(chainId);
   }
 
-  async signAmino(chainId: string, signer: string, signDoc: StdSignDoc): Promise<AminoSignResponse> {
-    await this.ensureConnected();
+  async signAmino(
+    chainId: string,
+    signer: string,
+    signDoc: StdSignDoc,
+    _signOptions?: KeplrSignOptions,
+  ): Promise<AminoSignResponse> {
+    await this.ensureChainEnabled(chainId);
 
-    const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-    if (wallets.length === 0) {
-      throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
+    try {
+      const wallet = await this.getFirstWallet();
+      const signerImpl = new ParaAminoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+      const response = await signerImpl.signAmino(signer, signDoc);
+      return response;
+    } catch (err) {
+      throw new Error(`Amino signing failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
     }
-
-    const bech32Prefix = this.getBech32Prefix(chainId);
-
-    const walletSigner = new ParaAminoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
-
-    return walletSigner.signAmino(signer, signDoc);
   }
 
   async signDirect(
     chainId: string,
     signer: string,
-    signDoc: {
-      bodyBytes?: Uint8Array;
-      authInfoBytes?: Uint8Array;
-      chainId?: string;
-      accountNumber?: Long;
-    },
+    signDoc: GrazSignDoc,
+    _signOptions?: KeplrSignOptions,
   ): Promise<DirectSignResponse> {
-    await this.ensureConnected();
+    await this.ensureChainEnabled(chainId);
 
-    const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-    if (wallets.length === 0) {
-      throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
+    try {
+      const wallet = await this.getFirstWallet();
+      const signerImpl = new ParaProtoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+      const convertedSignDoc: SignDoc = {
+        bodyBytes: signDoc.bodyBytes ?? new Uint8Array(),
+        authInfoBytes: signDoc.authInfoBytes ?? new Uint8Array(),
+        chainId: signDoc.chainId,
+        accountNumber: typeof signDoc.accountNumber === 'bigint' ? signDoc.accountNumber : BigInt(signDoc.accountNumber),
+      };
+
+      const result = await signerImpl.signDirect(signer, convertedSignDoc);
+      return {
+        signed: {
+          bodyBytes: result.signed.bodyBytes,
+          authInfoBytes: result.signed.authInfoBytes,
+          chainId: result.signed.chainId,
+          accountNumber: result.signed.accountNumber,
+        },
+        signature: result.signature,
+      };
+    } catch (err) {
+      throw new Error(`Direct signing failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
     }
-
-    const convertedSignDoc = {
-      bodyBytes: signDoc.bodyBytes || new Uint8Array(),
-      authInfoBytes: signDoc.authInfoBytes || new Uint8Array(),
-      chainId: signDoc.chainId || chainId,
-      accountNumber: signDoc.accountNumber ? signDoc.accountNumber.toString() : '0',
-    };
-
-    const bech32Prefix = this.getBech32Prefix(chainId);
-
-    const walletSigner = new ParaProtoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
-
-    const result = await walletSigner.signDirect(signer, {
-      ...convertedSignDoc,
-      accountNumber: BigInt(convertedSignDoc.accountNumber),
-    });
-
-    return {
-      signed: {
-        bodyBytes: result.signed.bodyBytes,
-        authInfoBytes: result.signed.authInfoBytes,
-        chainId: result.signed.chainId,
-        accountNumber: Long.fromString(result.signed.accountNumber.toString()),
-      },
-      signature: result.signature,
-    };
   }
 
   async signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature> {
-    await this.ensureConnected();
+    await this.ensureChainEnabled(chainId);
 
-    let encodedData: string;
-    let isADR36WithString = false;
-
-    if (typeof data === 'string') {
-      encodedData = Buffer.from(data).toString('base64');
-      isADR36WithString = true;
-    } else {
-      encodedData = Buffer.from(data).toString('base64');
-    }
+    const encodedData =
+      typeof data === 'string' ? Buffer.from(data, 'utf-8').toString('base64') : Buffer.from(data).toString('base64');
 
     const signDoc = {
       chain_id: '',
       account_number: '0',
       sequence: '0',
-      fee: {
-        gas: '0',
-        amount: [],
-      },
+      fee: { gas: '0', amount: [] },
       msgs: [
         {
           type: 'sign/MsgSignData',
-          value: {
-            signer,
-            data: encodedData,
-          },
+          value: { signer, data: encodedData },
         },
       ],
       memo: '',
     };
 
-    const response = await this.signAmino(chainId, signer, signDoc);
-
-    return response.signature;
-  }
-
-  async disconnect(): Promise<void> {
-    await this.paraWebClient.logout();
-  }
-
-  private async ensureConnected(): Promise<void> {
-    const isConnected = await this.paraWebClient.isFullyLoggedIn();
-    if (!isConnected) {
-      throw new Error('Wallet is not connected, please connect first');
-    }
-  }
-
-  private getBech32Prefix(chainId: string): string {
-    const chainInfo = getChainInfo({ chainId });
-    if (chainInfo?.bech32Config?.bech32PrefixAccAddr) {
-      return chainInfo.bech32Config.bech32PrefixAccAddr;
+    try {
+      const response = await this.signAmino(chainId, signer, signDoc);
+      return response.signature;
+    } catch (err) {
+      throw new Error(`Arbitrary signing failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
     }
-
-    return 'cosmos';
-  }
-}
-
-async function getKey(paraWebClient: ParaWeb, chainId: string) {
-  const wallets = Object.values(paraWebClient.getWalletsByType('COSMOS'));
-
-  if (wallets.length < 1) {
-    throw Error('No wallets available');
-  }
-
-  const chainInfo = getChainInfo({ chainId });
-  const bech32Prefix = chainInfo?.bech32Config?.bech32PrefixAccAddr || 'cosmos';
-
-  const walletSigner = new ParaProtoSigner(paraWebClient, bech32Prefix, wallets[0].id);
-
-  const accountData = (await walletSigner.getAccounts())[0];
-  if (!accountData) {
-    throw new Error('No account data found');
-  }
-
-  return accountData;
-}
-
-async function requestSignature(paraWebClient: ParaWeb, chainId: string, signerAddress: string, signDoc: any) {
-  const isConnected = await paraWebClient.isFullyLoggedIn();
-  if (!isConnected) {
-    throw new Error('Wallet is not connected, please connect first');
-  }
-
-  const wallets = Object.values(paraWebClient.getWalletsByType('COSMOS'));
-  if (wallets.length === 0) {
-    throw new Error('No wallets available');
   }
-
-  const chainInfo = getChainInfo({ chainId });
-  const bech32Prefix = chainInfo?.bech32Config?.bech32PrefixAccAddr || 'cosmos';
-
-  const walletSigner = new ParaProtoSigner(paraWebClient, bech32Prefix, wallets[0].id);
-
-  return walletSigner.signDirect(signerAddress, signDoc);
 }

package/src/index.ts

@@ -1,3 +1,2 @@
-export { WalletType, AuthLayout, AuthMethod, OAuthMethod, Environment } from '@getpara/react-sdk';
-export { ParaGrazConnector } from './connector.js';
+export { toArray, ParaGrazConnector } from './connector.js';
 export type { ParaGrazConfig } from './connector.js';