@getpara/graz-connector 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/{ParaGrazProvider.d.ts → connector.d.ts}

@@ -1,14 +1,21 @@
 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 } from '@keplr-wallet/types';
-export type ParaGrazModalProps = Omit<ParaModalProps, 'para'>;
+import type { OfflineAminoSigner, OfflineDirectSigner, AminoSignResponse, StdSignDoc, StdSignature, DirectSignResponse, AccountData, SignDoc as KeplrSignDoc } from '@keplr-wallet/types';
+import Long from 'long';
 export interface ParaGrazConfig {
     apiKey: string;
     env: Environment;
-    modalProps?: ParaGrazModalProps;
+    modalProps?: ParaModalProps;
 }
-export declare class ParaGrazInternalProvider implements Omit<Wallet, 'experimentalSuggestChain'> {
+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>;
+}
+export declare class ParaGrazConnector implements Omit<Wallet, 'experimentalSuggestChain'> {
     private paraWebClient;
     private config;
     private isModalClosed;
@@ -23,11 +30,15 @@ export declare class ParaGrazInternalProvider implements Omit<Wallet, 'experimen
     getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner;
     getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner;
     getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner>;
-    signAmino(chainId: string, signer: string, signDoc: StdSignDoc, signOptions?: any): Promise<AminoSignResponse>;
-    signDirect(chainId: string, signer: string, signDoc: any, signOptions?: any): Promise<{
-        signed: any;
-        signature: StdSignature;
-    }>;
+    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>;
     signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature>;
     disconnect(): Promise<void>;
+    private ensureConnected;
+    private getBech32Prefix;
 }

package/dist/connector.js

@@ -0,0 +1,304 @@
+"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";
+import { fromBech32 } from "@cosmjs/encoding";
+import { renderModal } from "./connectorModal.js";
+import Long from "long";
+const TEN_MINUTES_MS = 6e5;
+class ParaOfflineSigner {
+  constructor(chainId, paraWebClient) {
+    this.chainId = chainId;
+    this.paraWebClient = paraWebClient;
+  }
+  getAccounts() {
+    return __async(this, null, function* () {
+      const key = yield getKey(this.paraWebClient, this.chainId);
+      return [
+        {
+          address: key.address,
+          algo: key.algo,
+          pubkey: key.pubkey
+        }
+      ];
+    });
+  }
+  signDirect(signerAddress, signDoc) {
+    return __async(this, null, function* () {
+      if (this.chainId !== signDoc.chainId) {
+        throw new Error("Chain ID does not match signer chain ID");
+      }
+      const accounts = yield this.getAccounts();
+      if (accounts.find((account) => account.address !== signerAddress)) {
+        throw new Error("Signer address does not match wallet address");
+      }
+      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.");
+    }
+    this.config = config;
+    this.paraWebClient = new ParaWeb(config.env, config.apiKey);
+    this.isModalClosed = true;
+  }
+  waitForLogin() {
+    return __async(this, arguments, function* (timeoutMs = TEN_MINUTES_MS) {
+      const startTime = Date.now();
+      while (Date.now() - startTime < timeoutMs) {
+        if (yield this.paraWebClient.isFullyLoggedIn()) {
+          return true;
+        }
+        if (this.isModalClosed) {
+          throw new Error("user closed modal");
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 2e3));
+      }
+      throw new Error("timed out waiting for user to log in");
+    });
+  }
+  waitForAccounts(chainIds, 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;
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+      }
+      throw new Error("timed out waiting for accounts to load");
+    });
+  }
+  enable(chainIds) {
+    return __async(this, null, function* () {
+      if (yield this.paraWebClient.isFullyLoggedIn()) {
+        const wallets = Object.values(this.paraWebClient.getWalletsByType("COSMOS"));
+        if (wallets && wallets.length > 0) {
+          return;
+        }
+      }
+      this.isModalClosed = false;
+      renderModal(this.paraWebClient, this.config.modalProps, () => {
+        this.isModalClosed = true;
+      });
+      yield this.waitForLogin();
+      try {
+        yield this.waitForAccounts(chainIds);
+      } catch (error) {
+        throw new Error("accounts not available after login");
+      }
+    });
+  }
+  getParaWebClient() {
+    return this.paraWebClient;
+  }
+  getConfig() {
+    return this.config;
+  }
+  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}`);
+      }
+      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}`);
+    }
+    const bech32Prefix = this.getBech32Prefix(chainId);
+    return new ParaAminoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
+  }
+  getOfflineSignerAuto(chainId) {
+    return Promise.resolve(this.getOfflineSignerOnlyAmino(chainId));
+  }
+  signAmino(chainId, signer, signDoc) {
+    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}`);
+      }
+      const bech32Prefix = this.getBech32Prefix(chainId);
+      const walletSigner = new ParaAminoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
+      return walletSigner.signAmino(signer, signDoc);
+    });
+  }
+  signDirect(chainId, signer, signDoc) {
+    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}`);
+      }
+      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");
+      }
+      const signDoc = {
+        chain_id: "",
+        account_number: "0",
+        sequence: "0",
+        fee: {
+          gas: "0",
+          amount: []
+        },
+        msgs: [
+          {
+            type: "sign/MsgSignData",
+            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");
+      }
+    });
+  }
+  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
+};

package/dist/index.d.ts

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

package/dist/index.js

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

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@getpara/graz-connector",
-  "version": "0.1.0-alpha.4",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/types/index.d.ts",
-  "typings": "dist/types/index.d.ts",
+  "version": "0.1.0-alpha.6",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "sideEffects": false,
   "dependencies": {
     "@getpara/react-sdk": "1.11.0",

package/src/connector.ts

@@ -0,0 +1,370 @@
+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';
+
+const TEN_MINUTES_MS = 600000;
+
+export interface ParaGrazConfig {
+  apiKey: string;
+  env: Environment;
+  modalProps?: ParaModalProps;
+}
+
+export class ParaOfflineSigner implements OfflineDirectSigner {
+  private chainId: string;
+  private paraWebClient: ParaWeb;
+
+  constructor(chainId: string, paraWebClient: ParaWeb) {
+    this.chainId = chainId;
+    this.paraWebClient = paraWebClient;
+  }
+
+  async getAccounts(): Promise<readonly AccountData[]> {
+    const key = await getKey(this.paraWebClient, this.chainId);
+    return [
+      {
+        address: key.address,
+        algo: key.algo as Algo,
+        pubkey: key.pubkey,
+      },
+    ];
+  }
+
+  async signDirect(signerAddress: string, signDoc: KeplrSignDoc): Promise<DirectSignResponse> {
+    if (this.chainId !== signDoc.chainId) {
+      throw new Error('Chain ID does not match signer chain ID');
+    }
+
+    const accounts = await this.getAccounts();
+    if (accounts.find(account => account.address !== signerAddress)) {
+      throw new Error('Signer address does not match wallet address');
+    }
+
+    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);
+
+    return {
+      signed: {
+        bodyBytes: result.signed.bodyBytes,
+        authInfoBytes: result.signed.authInfoBytes,
+        chainId: result.signed.chainId,
+        accountNumber: Long.fromString(result.signed.accountNumber.toString()),
+      },
+      signature: result.signature,
+    };
+  }
+}
+
+export class ParaGrazConnector implements Omit<Wallet, 'experimentalSuggestChain'> {
+  private paraWebClient: ParaWeb;
+  private config: ParaGrazConfig;
+  private isModalClosed: boolean;
+
+  constructor(config: ParaGrazConfig) {
+    if (!config || !config.apiKey || !config.env) {
+      throw new Error('Para Connector: Missing API Key or Environment in config.');
+    }
+    this.config = config;
+    this.paraWebClient = new ParaWeb(config.env, config.apiKey);
+    this.isModalClosed = true;
+  }
+
+  closeModal = () => {
+    this.isModalClosed = true;
+  };
+
+  private async waitForLogin(timeoutMs = TEN_MINUTES_MS): Promise<boolean> {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      if (await this.paraWebClient.isFullyLoggedIn()) {
+        return true;
+      }
+
+      if (this.isModalClosed) {
+        throw new Error('user closed modal');
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+
+    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;
+      }
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+
+    throw new Error('timed out waiting for accounts to load');
+  }
+
+  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) {
+        return;
+      }
+    }
+
+    this.isModalClosed = false;
+    renderModal(this.paraWebClient, this.config.modalProps, () => {
+      this.isModalClosed = true;
+    });
+
+    await this.waitForLogin();
+
+    try {
+      await this.waitForAccounts(chainIds);
+    } catch (error) {
+      throw new Error('accounts not available after login');
+    }
+  }
+
+  getParaWebClient(): ParaWeb {
+    return this.paraWebClient;
+  }
+
+  getConfig(): ParaGrazConfig {
+    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];
+    return {
+      address: fromBech32(account.address).data,
+      bech32Address: account.address,
+      algo: account.algo,
+      name: account.address,
+      pubKey: account.pubkey,
+      isKeystone: false,
+      isNanoLedger: false,
+    };
+  }
+
+  getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
+    const aminoSigner = this.getOfflineSignerOnlyAmino(chainId);
+    const directSigner = new ParaOfflineSigner(chainId, this.paraWebClient);
+
+    const combinedSigner = {
+      getAccounts: () => directSigner.getAccounts(),
+      signAmino: (signerAddress: string, signDoc: StdSignDoc) => aminoSigner.signAmino(signerAddress, signDoc),
+      signDirect: (signerAddress: string, signDoc: SignDoc) => directSigner.signDirect(signerAddress, signDoc),
+    };
+
+    return combinedSigner as unknown as OfflineAminoSigner & OfflineDirectSigner;
+  }
+
+  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}`);
+    }
+
+    const bech32Prefix = this.getBech32Prefix(chainId);
+
+    return new ParaAminoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
+  }
+
+  getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner> {
+    return Promise.resolve(this.getOfflineSignerOnlyAmino(chainId));
+  }
+
+  async signAmino(chainId: string, signer: string, signDoc: StdSignDoc): Promise<AminoSignResponse> {
+    await 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}`);
+    }
+
+    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;
+    },
+  ): Promise<DirectSignResponse> {
+    await 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}`);
+    }
+
+    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();
+
+    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 signDoc = {
+      chain_id: '',
+      account_number: '0',
+      sequence: '0',
+      fee: {
+        gas: '0',
+        amount: [],
+      },
+      msgs: [
+        {
+          type: 'sign/MsgSignData',
+          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;
+    }
+
+    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,3 @@
 export { WalletType, AuthLayout, AuthMethod, OAuthMethod, Environment } from '@getpara/react-sdk';
-export { ParaGrazInternalProvider } from './ParaGrazProvider.js';
-export type { ParaGrazConfig, ParaGrazModalProps } from './ParaGrazProvider.js';
+export { ParaGrazConnector } from './connector.js';
+export type { ParaGrazConfig } from './connector.js';

package/dist/ParaGrazProvider.js

@@ -1,136 +0,0 @@
-"use client";
-import {
-  __async
-} from "./chunk-IV3L3JVM.js";
-import ParaWeb from "@getpara/react-sdk";
-import { ParaProtoSigner } from "@getpara/cosmjs-v0-integration";
-import { fromBech32 } from "@cosmjs/encoding";
-import { renderModal } from "./connectorModal.js";
-const TEN_MINUTES_MS = 6e5;
-class ParaGrazInternalProvider {
-  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.");
-    }
-    this.config = config;
-    this.paraWebClient = new ParaWeb(config.env, config.apiKey);
-    this.isModalClosed = true;
-  }
-  waitForLogin() {
-    return __async(this, arguments, function* (timeoutMs = TEN_MINUTES_MS) {
-      const startTime = Date.now();
-      while (Date.now() - startTime < timeoutMs) {
-        if (yield this.paraWebClient.isFullyLoggedIn()) {
-          return true;
-        }
-        if (this.isModalClosed) {
-          throw new Error("user closed modal");
-        }
-        yield new Promise((resolve) => setTimeout(resolve, 2e3));
-      }
-      throw new Error("timed out waiting for user to log in");
-    });
-  }
-  waitForAccounts(chainIds, 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;
-        }
-        yield new Promise((resolve) => setTimeout(resolve, 500));
-      }
-      throw new Error("timed out waiting for accounts to load");
-    });
-  }
-  enable(chainIds) {
-    return __async(this, null, function* () {
-      if (yield this.paraWebClient.isFullyLoggedIn()) {
-        const wallets = Object.values(this.paraWebClient.getWalletsByType("COSMOS"));
-        if (wallets && wallets.length > 0) {
-          return;
-        }
-      }
-      this.isModalClosed = false;
-      renderModal(this.paraWebClient, this.config.modalProps, () => {
-        this.isModalClosed = true;
-      });
-      yield this.waitForLogin();
-      try {
-        yield this.waitForAccounts(chainIds);
-      } catch (error) {
-        throw new Error("accounts not available after login");
-      }
-    });
-  }
-  getParaWebClient() {
-    return this.paraWebClient;
-  }
-  getConfig() {
-    return this.config;
-  }
-  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 walletSigner = new ParaProtoSigner(this.paraWebClient, 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}`);
-      }
-      return {
-        address: fromBech32(accountData[0].address).data,
-        bech32Address: accountData[0].address,
-        algo: accountData[0].algo,
-        name: accountData[0].address,
-        pubKey: accountData[0].pubkey,
-        isKeystone: false,
-        isNanoLedger: false
-      };
-    });
-  }
-  getOfflineSigner(chainId) {
-    console.warn(`Para Connector: getOfflineSigner called for ${chainId} - Needs Implementation`);
-    throw new Error("getOfflineSigner not implemented");
-  }
-  getOfflineSignerOnlyAmino(chainId) {
-    console.warn(`Para Connector: getOfflineSignerOnlyAmino called for ${chainId} - Needs Implementation`);
-    throw new Error("getOfflineSignerOnlyAmino not implemented");
-  }
-  getOfflineSignerAuto(chainId) {
-    console.warn(`Para Connector: getOfflineSignerAuto called for ${chainId} - Needs Implementation`);
-    throw new Error("getOfflineSignerAuto not implemented");
-  }
-  signAmino(chainId, signer, signDoc, signOptions) {
-    return __async(this, null, function* () {
-      console.warn(`Para Connector: signAmino called for ${chainId} - Needs Implementation`);
-      throw new Error("signAmino not implemented");
-    });
-  }
-  signDirect(chainId, signer, signDoc, signOptions) {
-    return __async(this, null, function* () {
-      console.warn(`Para Connector: signDirect called for ${chainId} - Needs Implementation`);
-      throw new Error("signDirect not implemented");
-    });
-  }
-  signArbitrary(chainId, signer, data) {
-    return __async(this, null, function* () {
-      console.warn(`Para Connector: signArbitrary called for ${chainId} - Needs Implementation`);
-      throw new Error("signArbitrary not implemented");
-    });
-  }
-  disconnect() {
-    return __async(this, null, function* () {
-      yield this.paraWebClient.logout();
-    });
-  }
-}
-export {
-  ParaGrazInternalProvider
-};

package/src/ParaGrazProvider.ts

@@ -1,165 +0,0 @@
-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,
-} from '@keplr-wallet/types';
-import { ParaAminoSigner, ParaProtoSigner } from '@getpara/cosmjs-v0-integration';
-import { fromBech32 } from '@cosmjs/encoding';
-import { renderModal } from './connectorModal.js';
-
-const TEN_MINUTES_MS = 600000;
-
-export type ParaGrazModalProps = Omit<ParaModalProps, 'para'>;
-
-export interface ParaGrazConfig {
-  apiKey: string;
-  env: Environment;
-  modalProps?: ParaGrazModalProps;
-}
-
-export class ParaGrazInternalProvider implements Omit<Wallet, 'experimentalSuggestChain'> {
-  private paraWebClient: ParaWeb;
-  private config: ParaGrazConfig;
-  private isModalClosed: boolean;
-
-  constructor(config: ParaGrazConfig) {
-    if (!config || !config.apiKey || !config.env) {
-      throw new Error('Para Connector: Missing API Key or Environment in config.');
-    }
-    this.config = config;
-    this.paraWebClient = new ParaWeb(config.env, config.apiKey);
-    this.isModalClosed = true;
-  }
-
-  closeModal = () => {
-    this.isModalClosed = true;
-  };
-
-  private async waitForLogin(timeoutMs = TEN_MINUTES_MS): Promise<boolean> {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      if (await this.paraWebClient.isFullyLoggedIn()) {
-        return true;
-      }
-
-      if (this.isModalClosed) {
-        throw new Error('user closed modal');
-      }
-
-      await new Promise(resolve => setTimeout(resolve, 2000));
-    }
-
-    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;
-      }
-      await new Promise(resolve => setTimeout(resolve, 500));
-    }
-
-    throw new Error('timed out waiting for accounts to load');
-  }
-
-  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) {
-        return;
-      }
-    }
-
-    this.isModalClosed = false;
-    renderModal(this.paraWebClient, this.config.modalProps, () => {
-      this.isModalClosed = true;
-    });
-
-    await this.waitForLogin();
-
-    try {
-      await this.waitForAccounts(chainIds);
-    } catch (error) {
-      throw new Error('accounts not available after login');
-    }
-  }
-
-  getParaWebClient(): ParaWeb {
-    return this.paraWebClient;
-  }
-
-  getConfig(): ParaGrazConfig {
-    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}`);
-    }
-
-    const walletSigner = new ParaProtoSigner(this.paraWebClient, 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}`);
-    }
-
-    return {
-      address: fromBech32(accountData[0].address).data,
-      bech32Address: accountData[0].address,
-      algo: accountData[0].algo,
-      name: accountData[0].address,
-      pubKey: accountData[0].pubkey,
-      isKeystone: false,
-      isNanoLedger: false,
-    };
-  }
-
-  getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
-    console.warn(`Para Connector: getOfflineSigner called for ${chainId} - Needs Implementation`);
-    throw new Error('getOfflineSigner not implemented');
-  }
-
-  getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner {
-    console.warn(`Para Connector: getOfflineSignerOnlyAmino called for ${chainId} - Needs Implementation`);
-    throw new Error('getOfflineSignerOnlyAmino not implemented');
-  }
-
-  getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner> {
-    console.warn(`Para Connector: getOfflineSignerAuto called for ${chainId} - Needs Implementation`);
-    throw new Error('getOfflineSignerAuto not implemented');
-  }
-
-  async signAmino(chainId: string, signer: string, signDoc: StdSignDoc, signOptions?: any): Promise<AminoSignResponse> {
-    console.warn(`Para Connector: signAmino called for ${chainId} - Needs Implementation`);
-    throw new Error('signAmino not implemented');
-  }
-
-  async signDirect(
-    chainId: string,
-    signer: string,
-    signDoc: any,
-    signOptions?: any,
-  ): Promise<{ signed: any; signature: StdSignature }> {
-    console.warn(`Para Connector: signDirect called for ${chainId} - Needs Implementation`);
-    throw new Error('signDirect not implemented');
-  }
-
-  async signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature> {
-    console.warn(`Para Connector: signArbitrary called for ${chainId} - Needs Implementation`);
-    throw new Error('signArbitrary not implemented');
-  }
-
-  async disconnect(): Promise<void> {
-    await this.paraWebClient.logout();
-  }
-}