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

package/dist/connector.d.ts

@@ -1,44 +1,49 @@
-import ParaWeb from '@getpara/react-sdk';
-import type { Environment, ParaModalProps } from '@getpara/react-sdk';
-import type { Wallet, Key as GrazKey } from 'graz';
-import type { OfflineAminoSigner, OfflineDirectSigner, AminoSignResponse, StdSignDoc, StdSignature, DirectSignResponse, AccountData, SignDoc as KeplrSignDoc } from '@keplr-wallet/types';
-import Long from 'long';
+import { Wallet, SignDoc as GrazSignDoc } from 'graz';
+import { ParaWeb, Wallet as ParaWallet } from '@getpara/web-sdk';
+import { DirectSignResponse, OfflineDirectSigner } from '@cosmjs/proto-signing';
+import { AminoSignResponse, OfflineAminoSigner, StdSignature, StdSignDoc } from '@cosmjs/amino';
+import { ChainInfo, KeplrSignOptions } from '@keplr-wallet/types';
+export type ParaGrazConnectorEvents = {
+    onEnabled?: (chainIds: string[], connector: ParaGrazConnector) => void;
+};
 export interface ParaGrazConfig {
-    apiKey: string;
-    env: Environment;
-    modalProps?: ParaModalProps;
-}
-export declare class ParaOfflineSigner implements OfflineDirectSigner {
-    private chainId;
-    private paraWebClient;
-    constructor(chainId: string, paraWebClient: ParaWeb);
-    getAccounts(): Promise<readonly AccountData[]>;
-    signDirect(signerAddress: string, signDoc: KeplrSignDoc): Promise<DirectSignResponse>;
+    paraWeb: ParaWeb;
+    events?: ParaGrazConnectorEvents;
+    noModal?: boolean;
 }
+export declare function toArray<T>(v: T | T[]): T[];
 export declare class ParaGrazConnector implements Omit<Wallet, 'experimentalSuggestChain'> {
-    private paraWebClient;
-    private config;
-    private isModalClosed;
-    constructor(config: ParaGrazConfig);
-    closeModal: () => void;
-    private waitForLogin;
-    private waitForAccounts;
-    enable(chainIds: string | string[]): Promise<void>;
+    protected readonly config: ParaGrazConfig;
+    protected readonly chains: ChainInfo[] | null;
+    protected paraWebClient: ParaWeb;
+    protected enabledChainIds: Set<string>;
+    protected readonly events?: ParaGrazConnectorEvents;
+    protected noModal?: boolean;
+    constructor(config: ParaGrazConfig, chains?: ChainInfo[] | null);
+    protected ensureChainEnabled(chainId: string): Promise<void>;
+    protected waitForLogin(timeoutMs?: number): Promise<void>;
+    protected waitForAccounts(timeoutMs?: number): Promise<ParaWallet[]>;
+    protected hasCosmosWallet(): Promise<boolean>;
+    enable(chainIdsInput: string | string[]): Promise<void>;
+    disconnect(): Promise<void>;
+    getFirstWallet(): Promise<ParaWallet>;
+    getBech32Prefix(chainId: string): string;
     getParaWebClient(): ParaWeb;
     getConfig(): ParaGrazConfig;
-    getKey(chainId: string): Promise<GrazKey>;
-    getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner;
+    protected buildHybridSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner;
+    getKey(chainId: string): Promise<{
+        name: string;
+        algo: import("@cosmjs/amino").Algo;
+        pubKey: Uint8Array;
+        address: Uint8Array;
+        bech32Address: string;
+        isKeystone: boolean;
+        isNanoLedger: boolean;
+    }>;
     getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner;
+    getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner;
     getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner>;
-    signAmino(chainId: string, signer: string, signDoc: StdSignDoc): Promise<AminoSignResponse>;
-    signDirect(chainId: string, signer: string, signDoc: {
-        bodyBytes?: Uint8Array;
-        authInfoBytes?: Uint8Array;
-        chainId?: string;
-        accountNumber?: Long;
-    }): Promise<DirectSignResponse>;
+    signAmino(chainId: string, signer: string, signDoc: StdSignDoc, _signOptions?: KeplrSignOptions): Promise<AminoSignResponse>;
+    signDirect(chainId: string, signer: string, signDoc: GrazSignDoc, _signOptions?: KeplrSignOptions): Promise<DirectSignResponse>;
     signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature>;
-    disconnect(): Promise<void>;
-    private ensureConnected;
-    private getBech32Prefix;
 }

package/dist/connector.js

@@ -1,29 +1,36 @@
 "use client";
 import {
-  __async,
-  __spreadProps,
-  __spreadValues
-} from "./chunk-IV3L3JVM.js";
-import ParaWeb from "@getpara/react-sdk";
-import { getChainInfo } from "graz";
-import { ParaAminoSigner, ParaProtoSigner } from "@getpara/cosmjs-v0-integration";
+  __async
+} from "./chunk-M66XENHI.js";
 import { fromBech32 } from "@cosmjs/encoding";
-import { renderModal } from "./connectorModal.js";
-import Long from "long";
-const TEN_MINUTES_MS = 6e5;
+import { ParaAminoSigner, ParaProtoSigner } from "@getpara/cosmjs-v0-integration";
+function toArray(v) {
+  return Array.isArray(v) ? v : [v];
+}
 class ParaOfflineSigner {
-  constructor(chainId, paraWebClient) {
+  constructor(chainId, connector) {
     this.chainId = chainId;
-    this.paraWebClient = paraWebClient;
+    this.connector = connector;
+  }
+  get para() {
+    return this.connector.getParaWebClient();
+  }
+  get prefix() {
+    return this.connector.getBech32Prefix(this.chainId);
+  }
+  wallet() {
+    return __async(this, null, function* () {
+      return this.connector.getFirstWallet();
+    });
   }
   getAccounts() {
     return __async(this, null, function* () {
-      const key = yield getKey(this.paraWebClient, this.chainId);
+      const key = yield this.connector.getKey(this.chainId);
       return [
         {
-          address: key.address,
+          address: key.bech32Address,
           algo: key.algo,
-          pubkey: key.pubkey
+          pubkey: key.pubKey
         }
       ];
     });
@@ -31,274 +38,274 @@ class ParaOfflineSigner {
   signDirect(signerAddress, signDoc) {
     return __async(this, null, function* () {
       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 = yield 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 signer = new ParaProtoSigner(this.para, this.prefix, (yield this.wallet()).id);
+      try {
+        const result = yield 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"}`);
       }
-      const convertedSignDoc = {
-        bodyBytes: signDoc.bodyBytes,
-        authInfoBytes: signDoc.authInfoBytes,
-        chainId: signDoc.chainId,
-        accountNumber: typeof signDoc.accountNumber === "string" ? signDoc.accountNumber : signDoc.accountNumber.toString()
-      };
-      const result = yield requestSignature(this.paraWebClient, this.chainId, signerAddress, convertedSignDoc);
-      return {
-        signed: {
-          bodyBytes: result.signed.bodyBytes,
-          authInfoBytes: result.signed.authInfoBytes,
-          chainId: result.signed.chainId,
-          accountNumber: Long.fromString(result.signed.accountNumber.toString())
-        },
-        signature: result.signature
-      };
     });
   }
 }
 class ParaGrazConnector {
-  constructor(config) {
-    this.closeModal = () => {
-      this.isModalClosed = true;
-    };
-    if (!config || !config.apiKey || !config.env) {
-      throw new Error("Para Connector: Missing API Key or Environment in config.");
-    }
+  constructor(config, chains = null) {
     this.config = config;
-    this.paraWebClient = new ParaWeb(config.env, config.apiKey);
-    this.isModalClosed = true;
+    this.chains = chains;
+    this.enabledChainIds = /* @__PURE__ */ new Set();
+    if (!(config == null ? void 0 : config.paraWeb)) {
+      throw new Error("ParaWeb instance required in config");
+    }
+    this.events = config.events;
+    this.paraWebClient = config.paraWeb;
+    this.noModal = config.noModal;
+  }
+  ensureChainEnabled(chainId) {
+    return __async(this, null, function* () {
+      if (!this.enabledChainIds.has(chainId)) {
+        throw new Error(`Chain ${chainId} not enabled. Call enable() first`);
+      }
+      if (!(yield this.paraWebClient.isFullyLoggedIn())) {
+        throw new Error("Para wallet not authenticated");
+      }
+    });
   }
-  waitForLogin() {
-    return __async(this, arguments, function* (timeoutMs = TEN_MINUTES_MS) {
-      const startTime = Date.now();
-      while (Date.now() - startTime < timeoutMs) {
+  waitForLogin(timeoutMs = 6e4) {
+    return __async(this, null, function* () {
+      const deadline = Date.now() + timeoutMs;
+      let delay = 500;
+      const MAX_DELAY = 5e3;
+      while (true) {
         if (yield 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 / 1e3}s`);
         }
-        yield new Promise((resolve) => setTimeout(resolve, 2e3));
+        yield 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");
     });
   }
-  waitForAccounts(chainIds, timeoutMs = 5e3) {
+  waitForAccounts(timeoutMs = 5e3) {
     return __async(this, null, function* () {
-      const startTime = Date.now();
-      while (Date.now() - startTime < timeoutMs) {
-        const wallets = Object.values(this.paraWebClient.getWalletsByType("COSMOS"));
-        if (wallets && wallets.length > 0) {
-          return true;
+      const deadline = Date.now() + timeoutMs;
+      let delay = 250;
+      const MAX_DELAY = 1e3;
+      while (true) {
+        const wallets = this.paraWebClient.getWalletsByType("COSMOS");
+        if (wallets.length) {
+          return wallets;
+        }
+        if (Date.now() >= deadline) {
+          throw new Error("No Cosmos wallets found");
         }
-        yield new Promise((resolve) => setTimeout(resolve, 500));
+        yield new Promise((r) => setTimeout(r, delay));
+        delay = Math.min(delay * 1.5, MAX_DELAY);
       }
-      throw new Error("timed out waiting for accounts to load");
     });
   }
-  enable(chainIds) {
+  hasCosmosWallet() {
+    return __async(this, null, function* () {
+      const isLoggedIn = yield this.paraWebClient.isFullyLoggedIn();
+      const wallets = this.paraWebClient.getWalletsByType("COSMOS");
+      return isLoggedIn && wallets.length > 0;
+    });
+  }
+  enable(chainIdsInput) {
     return __async(this, null, function* () {
-      if (yield this.paraWebClient.isFullyLoggedIn()) {
-        const wallets = Object.values(this.paraWebClient.getWalletsByType("COSMOS"));
-        if (wallets && wallets.length > 0) {
+      var _a, _b, _c, _d;
+      const chainIds = toArray(chainIdsInput);
+      const previousEnabled = new Set(this.enabledChainIds);
+      try {
+        chainIds.forEach((id) => this.enabledChainIds.add(id));
+        if (yield this.hasCosmosWallet()) {
+          (_b = (_a = this.events) == null ? void 0 : _a.onEnabled) == null ? void 0 : _b.call(_a, chainIds, this);
           return;
         }
+        if (!this.noModal) {
+          throw new Error("Modal not supported. Use @getpara/graz-integration or set noModal: true");
+        }
+        yield this.waitForLogin();
+        yield this.waitForAccounts();
+        (_d = (_c = this.events) == null ? void 0 : _c.onEnabled) == null ? void 0 : _d.call(_c, chainIds, this);
+      } catch (err) {
+        this.enabledChainIds = previousEnabled;
+        if (err instanceof Error) {
+          throw err;
+        }
+        throw new Error("Failed to enable Para wallet");
+      }
+    });
+  }
+  disconnect() {
+    return __async(this, null, function* () {
+      try {
+        yield this.paraWebClient.logout();
+      } catch (err) {
+        throw new Error("Disconnect failed");
+      } finally {
+        this.enabledChainIds.clear();
       }
-      this.isModalClosed = false;
-      renderModal(this.paraWebClient, this.config.modalProps, () => {
-        this.isModalClosed = true;
-      });
-      yield this.waitForLogin();
+    });
+  }
+  getFirstWallet() {
+    return __async(this, null, function* () {
       try {
-        yield this.waitForAccounts(chainIds);
-      } catch (error) {
-        throw new Error("accounts not available after login");
+        const [wallet] = yield this.waitForAccounts();
+        return wallet;
+      } catch (err) {
+        throw new Error("No Para wallet available");
       }
     });
   }
+  getBech32Prefix(chainId) {
+    var _a, _b, _c;
+    const prefix = ((_c = (_b = (_a = this.chains) == null ? void 0 : _a.find((c) => c.chainId === chainId)) == null ? void 0 : _b.bech32Config) == null ? void 0 : _c.bech32PrefixAccAddr) || "cosmos";
+    return prefix;
+  }
   getParaWebClient() {
     return this.paraWebClient;
   }
   getConfig() {
     return this.config;
   }
+  buildHybridSigner(chainId) {
+    const aminoSigner = this.getOfflineSignerOnlyAmino(chainId);
+    const directSigner = new ParaOfflineSigner(chainId, this);
+    return {
+      getAccounts: () => directSigner.getAccounts(),
+      signAmino: (signer, signDoc) => aminoSigner.signAmino(signer, signDoc),
+      signDirect: (signer, signDoc) => directSigner.signDirect(signer, signDoc)
+    };
+  }
   getKey(chainId) {
     return __async(this, null, function* () {
-      const wallets = Object.values(this.paraWebClient.getWalletsByType("COSMOS"));
-      if (wallets.length === 0) {
-        throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
-      }
-      const bech32Prefix = this.getBech32Prefix(chainId);
-      const walletSigner = new ParaProtoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
-      const accountData = yield walletSigner.getAccounts();
-      if (accountData.length === 0) {
-        throw new Error(`Para Connector: No accounts found for wallet ${wallets[0].id}`);
+      try {
+        yield this.ensureChainEnabled(chainId);
+        const wallet = yield this.getFirstWallet();
+        const signer = new ParaProtoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+        const [account] = yield signer.getAccounts();
+        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;
+        }
+        throw new Error(`Failed to get key for chain ${chainId}`);
       }
-      const account = accountData[0];
-      return {
-        address: fromBech32(account.address).data,
-        bech32Address: account.address,
-        algo: account.algo,
-        name: account.address,
-        pubKey: account.pubkey,
-        isKeystone: false,
-        isNanoLedger: false
-      };
     });
   }
-  getOfflineSigner(chainId) {
-    const aminoSigner = this.getOfflineSignerOnlyAmino(chainId);
-    const directSigner = new ParaOfflineSigner(chainId, this.paraWebClient);
-    const combinedSigner = {
-      getAccounts: () => directSigner.getAccounts(),
-      signAmino: (signerAddress, signDoc) => aminoSigner.signAmino(signerAddress, signDoc),
-      signDirect: (signerAddress, signDoc) => directSigner.signDirect(signerAddress, signDoc)
-    };
-    return combinedSigner;
-  }
   getOfflineSignerOnlyAmino(chainId) {
-    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, bech32Prefix, wallets[0].id);
+    return new ParaAminoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+  }
+  getOfflineSigner(chainId) {
+    void this.ensureChainEnabled(chainId);
+    return this.buildHybridSigner(chainId);
   }
   getOfflineSignerAuto(chainId) {
-    return Promise.resolve(this.getOfflineSignerOnlyAmino(chainId));
+    return __async(this, null, function* () {
+      void this.ensureChainEnabled(chainId);
+      return this.buildHybridSigner(chainId);
+    });
   }
-  signAmino(chainId, signer, signDoc) {
+  signAmino(chainId, signer, signDoc, _signOptions) {
     return __async(this, null, function* () {
-      yield this.ensureConnected();
-      const wallets = Object.values(this.paraWebClient.getWalletsByType("COSMOS"));
-      if (wallets.length === 0) {
-        throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
+      yield this.ensureChainEnabled(chainId);
+      try {
+        const wallet = yield this.getFirstWallet();
+        const signerImpl = new ParaAminoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+        const response = yield 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);
     });
   }
-  signDirect(chainId, signer, signDoc) {
+  signDirect(chainId, signer, signDoc, _signOptions) {
     return __async(this, null, function* () {
-      yield this.ensureConnected();
-      const wallets = Object.values(this.paraWebClient.getWalletsByType("COSMOS"));
-      if (wallets.length === 0) {
-        throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
+      var _a, _b;
+      yield this.ensureChainEnabled(chainId);
+      try {
+        const wallet = yield this.getFirstWallet();
+        const signerImpl = new ParaProtoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+        const convertedSignDoc = {
+          bodyBytes: (_a = signDoc.bodyBytes) != null ? _a : new Uint8Array(),
+          authInfoBytes: (_b = signDoc.authInfoBytes) != null ? _b : new Uint8Array(),
+          chainId: signDoc.chainId,
+          accountNumber: typeof signDoc.accountNumber === "bigint" ? signDoc.accountNumber : BigInt(signDoc.accountNumber)
+        };
+        const result = yield 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 = yield walletSigner.signDirect(signer, __spreadProps(__spreadValues({}, 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
-      };
     });
   }
   signArbitrary(chainId, signer, data) {
     return __async(this, null, function* () {
-      yield this.ensureConnected();
-      let encodedData;
-      let isADR36WithString = false;
-      if (typeof data === "string") {
-        encodedData = Buffer.from(data).toString("base64");
-        isADR36WithString = true;
-      } else {
-        encodedData = Buffer.from(data).toString("base64");
-      }
+      yield this.ensureChainEnabled(chainId);
+      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 = yield this.signAmino(chainId, signer, signDoc);
-      return response.signature;
-    });
-  }
-  disconnect() {
-    return __async(this, null, function* () {
-      yield this.paraWebClient.logout();
-    });
-  }
-  ensureConnected() {
-    return __async(this, null, function* () {
-      const isConnected = yield this.paraWebClient.isFullyLoggedIn();
-      if (!isConnected) {
-        throw new Error("Wallet is not connected, please connect first");
+      try {
+        const response = yield this.signAmino(chainId, signer, signDoc);
+        return response.signature;
+      } catch (err) {
+        throw new Error(`Arbitrary signing failed: ${err instanceof Error ? err.message : "Unknown error"}`);
       }
     });
   }
-  getBech32Prefix(chainId) {
-    var _a;
-    const chainInfo = getChainInfo({ chainId });
-    if ((_a = chainInfo == null ? void 0 : chainInfo.bech32Config) == null ? void 0 : _a.bech32PrefixAccAddr) {
-      return chainInfo.bech32Config.bech32PrefixAccAddr;
-    }
-    return "cosmos";
-  }
-}
-function getKey(paraWebClient, chainId) {
-  return __async(this, null, function* () {
-    var _a;
-    const wallets = Object.values(paraWebClient.getWalletsByType("COSMOS"));
-    if (wallets.length < 1) {
-      throw Error("No wallets available");
-    }
-    const chainInfo = getChainInfo({ chainId });
-    const bech32Prefix = ((_a = chainInfo == null ? void 0 : chainInfo.bech32Config) == null ? void 0 : _a.bech32PrefixAccAddr) || "cosmos";
-    const walletSigner = new ParaProtoSigner(paraWebClient, bech32Prefix, wallets[0].id);
-    const accountData = (yield walletSigner.getAccounts())[0];
-    if (!accountData) {
-      throw new Error("No account data found");
-    }
-    return accountData;
-  });
-}
-function requestSignature(paraWebClient, chainId, signerAddress, signDoc) {
-  return __async(this, null, function* () {
-    var _a;
-    const isConnected = yield 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 = ((_a = chainInfo == null ? void 0 : chainInfo.bech32Config) == null ? void 0 : _a.bech32PrefixAccAddr) || "cosmos";
-    const walletSigner = new ParaProtoSigner(paraWebClient, bech32Prefix, wallets[0].id);
-    return walletSigner.signDirect(signerAddress, signDoc);
-  });
 }
 export {
   ParaGrazConnector,
-  ParaOfflineSigner
+  toArray
 };

package/dist/index.d.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';

package/dist/index.js

@@ -1,12 +1,7 @@
 "use client";
-import "./chunk-IV3L3JVM.js";
-import { WalletType, AuthLayout, AuthMethod, OAuthMethod, Environment } from "@getpara/react-sdk";
-import { ParaGrazConnector } from "./connector.js";
+import "./chunk-M66XENHI.js";
+import { toArray, ParaGrazConnector } from "./connector.js";
 export {
-  AuthLayout,
-  AuthMethod,
-  Environment,
-  OAuthMethod,
   ParaGrazConnector,
-  WalletType
+  toArray
 };