@getpara/graz-connector 2.0.0-alpha.50 → 2.0.0-alpha.65

package/dist/cjs/connector.js

@@ -0,0 +1,348 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var connector_exports = {};
+__export(connector_exports, {
+  ParaGrazConnector: () => ParaGrazConnector,
+  toArray: () => toArray
+});
+module.exports = __toCommonJS(connector_exports);
+var import_encoding = require("@cosmjs/encoding");
+var import_cosmjs_v0_integration = require("@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 import_cosmjs_v0_integration.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;
+  }
+  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;
+        }
+        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 import_cosmjs_v0_integration.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: (0, import_encoding.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 import_cosmjs_v0_integration.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 import_cosmjs_v0_integration.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 import_cosmjs_v0_integration.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"}`);
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParaGrazConnector,
+  toArray
+});

package/dist/cjs/index.js

@@ -0,0 +1,30 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  ParaGrazConnector: () => import_connector.ParaGrazConnector,
+  toArray: () => import_connector.toArray
+});
+module.exports = __toCommonJS(src_exports);
+var import_connector = require("./connector.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParaGrazConnector,
+  toArray
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/{connector.js → esm/connector.js}

@@ -72,7 +72,6 @@ class ParaGrazConnector {
     }
     this.events = config.events;
     this.paraWebClient = config.paraWeb;
-    this.noModal = config.noModal;
   }
   ensureChainEnabled(chainId) {
     return __async(this, null, function* () {
@@ -137,9 +136,6 @@ class ParaGrazConnector {
           (_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);

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

@@ -9,7 +9,6 @@ export type ParaGrazConnectorEvents = {
 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'> {
@@ -18,7 +17,6 @@ export declare class ParaGrazConnector implements Omit<Wallet, 'experimentalSugg
     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>;

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "@getpara/graz-connector",
-  "version": "2.0.0-alpha.50",
+  "version": "2.0.0-alpha.65",
   "sideEffects": false,
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": "./dist/esm/index.js"
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "typegen": "tsc --emitDeclarationOnly",
-    "build": "rm -rf dist && yarn typegen && node ./scripts/build.mjs"
+    "build": "rm -rf dist && node ./scripts/build.mjs && yarn build:types",
+    "build:types": "rm -rf dist/types && tsc --module esnext --declarationDir dist/types --emitDeclarationOnly --declaration"
   },
   "dependencies": {
-    "@getpara/cosmjs-v0-integration": "2.0.0-alpha.50",
-    "@getpara/web-sdk": "2.0.0-alpha.50"
+    "@getpara/cosmjs-v0-integration": "2.0.0-alpha.65",
+    "@getpara/web-sdk": "2.0.0-alpha.65"
   },
   "devDependencies": {
     "@cosmjs/amino": "^0.32.4",
@@ -21,7 +26,7 @@
     "@cosmjs/tendermint-rpc": "^0.32.4",
     "@keplr-wallet/types": "^0.12.156",
     "cosmjs-types": "^0.9.0",
-    "graz": "^0.3.3",
+    "graz": "^0.4.1",
     "typescript": "5.1.6"
   },
   "peerDependencies": {
@@ -32,6 +37,6 @@
     "@cosmjs/tendermint-rpc": ">=0.32.4",
     "@keplr-wallet/types": ">=0.12.156",
     "cosmjs-types": ">=0.8.0",
-    "graz": ">=0.3.3"
+    "graz": ">=0.4.1"
   }
 }

package/scripts/build.mjs

@@ -1,36 +0,0 @@
-import * as esbuild from 'esbuild';
-import * as fs from 'fs/promises';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-import { glob } from 'glob';
-
-const entryPoints = await glob('src/**/*.{ts,tsx,js,jsx}');
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const distDir = resolve(__dirname, '../dist');
-
-await fs.mkdir(distDir, { recursive: true });
-await fs.writeFile(`${distDir}/package.json`, JSON.stringify({ type: 'module', sideEffects: false }, null, 2));
-
-/** @type {import('esbuild').BuildOptions} */
-await esbuild.build({
-  banner: {
-    js: '"use client";', // Required for Next 13 App Router
-  },
-  bundle: false,
-  write: true,
-  format: 'esm',
-  loader: {
-    '.png': 'dataurl',
-    '.svg': 'dataurl',
-    '.json': 'text',
-  },
-  platform: 'browser',
-  entryPoints,
-  outdir: distDir,
-  allowOverwrite: true,
-  splitting: true, // Required for tree shaking
-  minify: false,
-  target: ['es2015'],
-  packages: 'external',
-});

package/src/connector.ts

@@ -1,355 +0,0 @@
-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,2 +0,0 @@
-export { toArray, ParaGrazConnector } from './connector.js';
-export type { ParaGrazConfig } from './connector.js';

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "jsx": "react-jsx",
-    "module": "ESNext",
-    "declaration": true,
-    "declarationDir": "./dist"
-  },
-  "include": ["src/**/*.ts", "src/**/*.tsx"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.test.tsx", "__tests__"]
-}