@getpara/graz-connector 0.1.0-alpha.5 → 2.0.0-alpha.50

package/dist/chunk-M66XENHI.js

@@ -0,0 +1,25 @@
+"use client";
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+export {
+  __async
+};

package/dist/connector.d.ts

@@ -0,0 +1,41 @@
+import { Wallet, SignDoc as GrazSignDoc, Key } 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 {
+    paraWeb: ParaWeb;
+    events?: ParaGrazConnectorEvents;
+    noModal?: boolean;
+}
+export declare function toArray<T>(v: T | T[]): T[];
+export declare class ParaGrazConnector implements Omit<Wallet, 'experimentalSuggestChain'> {
+    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;
+    protected buildHybridSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner;
+    getKey(chainId: string): Promise<Key>;
+    getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner;
+    getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner;
+    getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner>;
+    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>;
+}

package/dist/connector.js

@@ -0,0 +1,311 @@
+"use client";
+import {
+  __async
+} from "./chunk-M66XENHI.js";
+import { fromBech32 } from "@cosmjs/encoding";
+import { ParaAminoSigner, ParaProtoSigner } from "@getpara/cosmjs-v0-integration";
+function toArray(v) {
+  return Array.isArray(v) ? v : [v];
+}
+class ParaOfflineSigner {
+  constructor(chainId, connector) {
+    this.chainId = chainId;
+    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 this.connector.getKey(this.chainId);
+      return [
+        {
+          address: key.bech32Address,
+          algo: key.algo,
+          pubkey: key.pubKey
+        }
+      ];
+    });
+  }
+  signDirect(signerAddress, signDoc) {
+    return __async(this, null, function* () {
+      if (this.chainId !== signDoc.chainId) {
+        throw new Error(`Chain ID mismatch: expected ${this.chainId}, got ${signDoc.chainId}`);
+      }
+      const accounts = yield this.getAccounts();
+      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"}`);
+      }
+    });
+  }
+}
+class ParaGrazConnector {
+  constructor(config, chains = null) {
+    this.config = config;
+    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(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;
+        }
+        if (Date.now() >= deadline) {
+          throw new Error(`Login timeout after ${timeoutMs / 1e3}s`);
+        }
+        yield new Promise((r) => setTimeout(r, delay));
+        delay = Math.min(delay * 1.5, MAX_DELAY);
+      }
+    });
+  }
+  waitForAccounts(timeoutMs = 5e3) {
+    return __async(this, null, function* () {
+      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((r) => setTimeout(r, delay));
+        delay = Math.min(delay * 1.5, MAX_DELAY);
+      }
+    });
+  }
+  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* () {
+      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();
+      }
+    });
+  }
+  getFirstWallet() {
+    return __async(this, null, function* () {
+      try {
+        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* () {
+      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}`);
+      }
+    });
+  }
+  getOfflineSignerOnlyAmino(chainId) {
+    void this.ensureChainEnabled(chainId);
+    const wallet = this.paraWebClient.getWalletsByType("COSMOS")[0];
+    if (!wallet) {
+      throw new Error("No Cosmos wallet for Amino signing");
+    }
+    return new ParaAminoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+  }
+  getOfflineSigner(chainId) {
+    void this.ensureChainEnabled(chainId);
+    return this.buildHybridSigner(chainId);
+  }
+  getOfflineSignerAuto(chainId) {
+    return __async(this, null, function* () {
+      void this.ensureChainEnabled(chainId);
+      return this.buildHybridSigner(chainId);
+    });
+  }
+  signAmino(chainId, signer, signDoc, _signOptions) {
+    return __async(this, null, function* () {
+      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"}`);
+      }
+    });
+  }
+  signDirect(chainId, signer, signDoc, _signOptions) {
+    return __async(this, null, function* () {
+      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"}`);
+      }
+    });
+  }
+  signArbitrary(chainId, signer, data) {
+    return __async(this, null, function* () {
+      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: [] },
+        msgs: [
+          {
+            type: "sign/MsgSignData",
+            value: { signer, data: encodedData }
+          }
+        ],
+        memo: ""
+      };
+      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"}`);
+      }
+    });
+  }
+}
+export {
+  ParaGrazConnector,
+  toArray
+};

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-export { WalletType, AuthLayout, AuthMethod, OAuthMethod, Environment } from '@getpara/react-sdk';
-export { ParaGrazInternalProvider } from './ParaGrazProvider.js';
-export type { ParaGrazConfig, ParaGrazModalProps } from './ParaGrazProvider.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 { ParaGrazInternalProvider } from "./ParaGrazProvider.js";
+import "./chunk-M66XENHI.js";
+import { toArray, ParaGrazConnector } from "./connector.js";
 export {
-  AuthLayout,
-  AuthMethod,
-  Environment,
-  OAuthMethod,
-  ParaGrazInternalProvider,
-  WalletType
+  ParaGrazConnector,
+  toArray
 };

package/package.json

@@ -1,25 +1,37 @@
 {
   "name": "@getpara/graz-connector",
-  "version": "0.1.0-alpha.5",
+  "version": "2.0.0-alpha.50",
+  "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",
-    "typegen": "tsc --emitDeclarationOnly"
+    "typegen": "tsc --emitDeclarationOnly",
+    "build": "rm -rf dist && yarn typegen && node ./scripts/build.mjs"
+  },
+  "dependencies": {
+    "@getpara/cosmjs-v0-integration": "2.0.0-alpha.50",
+    "@getpara/web-sdk": "2.0.0-alpha.50"
   },
   "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",
+    "@cosmjs/stargate": "^0.32.4",
+    "@cosmjs/tendermint-rpc": "^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

@@ -0,0 +1,355 @@
+import { fromBech32 } from '@cosmjs/encoding';
+import { SignDoc } from 'cosmjs-types/cosmos/tx/v1beta1/tx.js';
+import { Wallet, SignDoc as GrazSignDoc, Key } 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';
+
+export type ParaGrazConnectorEvents = {
+  onEnabled?: (chainIds: string[], connector: ParaGrazConnector) => void;
+};
+
+export interface ParaGrazConfig {
+  paraWeb: ParaWeb;
+  events?: ParaGrazConnectorEvents;
+  noModal?: boolean;
+}
+
+export function toArray<T>(v: T | T[]): T[] {
+  return Array.isArray(v) ? v : [v];
+}
+
+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);
+  }
+
+  protected async wallet() {
+    return this.connector.getFirstWallet();
+  }
+
+  async getAccounts(): Promise<readonly AccountData[]> {
+    const key = await this.connector.getKey(this.chainId);
+    return [
+      {
+        address: key.bech32Address,
+        algo: key.algo as Algo,
+        pubkey: key.pubKey,
+      },
+    ];
+  }
+
+  async signDirect(signerAddress: string, signDoc: SignDoc): Promise<DirectSignResponse> {
+    if (this.chainId !== signDoc.chainId) {
+      throw new Error(`Chain ID mismatch: expected ${this.chainId}, got ${signDoc.chainId}`);
+    }
+
+    const accounts = await this.getAccounts();
+    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, (await this.wallet()).id);
+
+    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'> {
+  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;
+  }
+
+  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');
+    }
+  }
+
+  protected async waitForLogin(timeoutMs = 60_000): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    let delay = 500;
+    const MAX_DELAY = 5_000;
+
+    while (true) {
+      if (await this.paraWebClient.isFullyLoggedIn()) {
+        return;
+      }
+
+      if (Date.now() >= deadline) {
+        throw new Error(`Login timeout after ${timeoutMs / 1000}s`);
+      }
+
+      await new Promise(r => setTimeout(r, delay));
+      delay = Math.min(delay * 1.5, MAX_DELAY);
+    }
+  }
+
+  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(r => setTimeout(r, delay));
+      delay = Math.min(delay * 1.5, MAX_DELAY);
+    }
+  }
+
+  protected async hasCosmosWallet(): Promise<boolean> {
+    const isLoggedIn = await this.paraWebClient.isFullyLoggedIn();
+    const wallets = this.paraWebClient.getWalletsByType('COSMOS');
+    return isLoggedIn && 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;
+      }
+
+      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');
+    }
+  }
+
+  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 {
+      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;
+  }
+
+  getConfig(): ParaGrazConfig {
+    return this.config;
+  }
+
+  protected buildHybridSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
+    const aminoSigner = this.getOfflineSignerOnlyAmino(chainId);
+    const directSigner = new ParaOfflineSigner(chainId, this);
+    return {
+      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;
+  }
+
+  async getKey(chainId: string): Promise<Key> {
+    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();
+
+      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}`);
+    }
+  }
+
+  getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner {
+    void this.ensureChainEnabled(chainId);
+    const wallet = this.paraWebClient.getWalletsByType('COSMOS')[0];
+
+    if (!wallet) {
+      throw new Error('No Cosmos wallet for Amino signing');
+    }
+
+    return new ParaAminoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+  }
+
+  getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
+    void this.ensureChainEnabled(chainId);
+    return this.buildHybridSigner(chainId);
+  }
+
+  async getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner> {
+    void this.ensureChainEnabled(chainId);
+    return this.buildHybridSigner(chainId);
+  }
+
+  async signAmino(
+    chainId: string,
+    signer: string,
+    signDoc: StdSignDoc,
+    _signOptions?: KeplrSignOptions,
+  ): Promise<AminoSignResponse> {
+    await this.ensureChainEnabled(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'}`);
+    }
+  }
+
+  async signDirect(
+    chainId: string,
+    signer: string,
+    signDoc: GrazSignDoc,
+    _signOptions?: KeplrSignOptions,
+  ): Promise<DirectSignResponse> {
+    await this.ensureChainEnabled(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'}`);
+    }
+  }
+
+  async signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature> {
+    await 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: [] },
+      msgs: [
+        {
+          type: 'sign/MsgSignData',
+          value: { signer, data: encodedData },
+        },
+      ],
+      memo: '',
+    };
+
+    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'}`);
+    }
+  }
+}

package/src/index.ts

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

package/tsconfig.json

@@ -6,8 +6,8 @@
     "jsx": "react-jsx",
     "module": "ESNext",
     "declaration": true,
-    "declarationDir": "dist"
+    "declarationDir": "./dist"
   },
-  "include": ["**/*.ts", "**/*.tsx"],
-  "exclude": ["node_modules", "dist"]
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.test.tsx", "__tests__"]
 }

package/dist/ParaGrazProvider.d.ts

@@ -1,33 +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';
-export type ParaGrazModalProps = Omit<ParaModalProps, 'para'>;
-export interface ParaGrazConfig {
-    apiKey: string;
-    env: Environment;
-    modalProps?: ParaGrazModalProps;
-}
-export declare class ParaGrazInternalProvider 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>;
-    getParaWebClient(): ParaWeb;
-    getConfig(): ParaGrazConfig;
-    getKey(chainId: string): Promise<GrazKey>;
-    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;
-    }>;
-    signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature>;
-    disconnect(): Promise<void>;
-}

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/dist/chunk-IV3L3JVM.js

@@ -1,46 +0,0 @@
-"use client";
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-export {
-  __spreadValues,
-  __spreadProps,
-  __async
-};

package/dist/connectorModal.d.ts

@@ -1,2 +0,0 @@
-import ParaWeb, { ParaModalProps } from '@getpara/react-sdk';
-export declare function renderModal(para: ParaWeb, modalProps: Partial<ParaModalProps>, onCloseArg: () => void): void;

package/dist/connectorModal.js

@@ -1,36 +0,0 @@
-"use client";
-import {
-  __async,
-  __spreadProps,
-  __spreadValues
-} from "./chunk-IV3L3JVM.js";
-import { jsx } from "react/jsx-runtime";
-import { ParaModal } from "@getpara/react-sdk";
-function renderModal(para, modalProps, onCloseArg) {
-  const existingContainer = document.getElementById("para-modal");
-  const container = existingContainer != null ? existingContainer : document.createElement("div");
-  container.id = "para-modal";
-  if (!existingContainer) {
-    document.body.appendChild(container);
-  }
-  const onClose = () => {
-    onCloseArg();
-    modalProps.onClose && modalProps.onClose();
-    render(false);
-  };
-  const render = (isOpen) => __async(this, null, function* () {
-    const Modal = /* @__PURE__ */ jsx(ParaModal, __spreadProps(__spreadValues({}, modalProps), { onClose, para, isOpen }));
-    try {
-      const client = yield import("react-dom/client");
-      const root = client.createRoot(container);
-      root.render(Modal);
-    } catch (e) {
-      const ReactDOM = yield import("react-dom");
-      ReactDOM.render(Modal, container);
-    }
-  });
-  render(true);
-}
-export {
-  renderModal
-};

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();
-  }
-}

package/src/connectorModal.tsx

@@ -1,32 +0,0 @@
-import ParaWeb, { ParaModal, ParaModalProps } from '@getpara/react-sdk';
-
-export function renderModal(para: ParaWeb, modalProps: Partial<ParaModalProps>, onCloseArg: () => void): void {
-  const existingContainer = document.getElementById('para-modal');
-  const container = existingContainer ?? document.createElement('div');
-  container.id = 'para-modal';
-
-  if (!existingContainer) {
-    document.body.appendChild(container);
-  }
-
-  const onClose = () => {
-    onCloseArg();
-    modalProps.onClose && modalProps.onClose();
-    render(false);
-  };
-
-  const render = async (isOpen: boolean) => {
-    const Modal = <ParaModal {...modalProps} onClose={onClose} para={para} isOpen={isOpen} />;
-
-    try {
-      const client = await import('react-dom/client');
-      const root = client.createRoot(container);
-      root.render(Modal);
-    } catch (e) {
-      const ReactDOM = await import('react-dom');
-      ReactDOM.render(Modal, container);
-    }
-  };
-
-  render(true);
-}