bitbadgesjs-sdk 0.30.0 → 0.30.1

package/README.md

@@ -1,70 +1,281 @@
-# Overview
+# BitBadges SDK
 
-The BitBadges SDK is a bundle of TypeScript libraries that provide all the tools and functions needed for you to build your own frontend or interact with the BitBadges API, blockchain, and indexer.
+The official TypeScript SDK for interacting with the BitBadges blockchain, API, and indexer.
 
-GitHub: [https://github.com/bitbadges/bitbadgesjs](https://github.com/bitbadges/bitbadgesjs)
+[![npm version](https://badge.fury.io/js/bitbadgesjs-sdk.svg)](https://www.npmjs.com/package/bitbadgesjs-sdk)
 
-Reference repositories that use the SDK:
+## Installation
 
-- [BitBadges Frontend](https://github.com/BitBadges/bitbadges-frontend)
-- [BitBadges Indexer / API](https://github.com/BitBadges/bitbadges-indexer)
+```bash
+npm install bitbadgesjs-sdk
+# or
+bun add bitbadgesjs-sdk
+```
 
-See [full documentation](full-documentation.md) for complete documentation on each library. Also, the BitBadges official indexer source code and BitBadges official frontend code both use the SDK, so please feel free to reference them.
+## Quick Start
 
-## Version Compatibility
+### 1. Initialize the API Client
+
+```typescript
+import { BitBadgesAPI, BigIntify } from 'bitbadgesjs-sdk';
 
-This SDK is designed to be compatible with specific BitBadges chain versions. Use the following mapping to ensure compatibility:
+const api = new BitBadgesAPI({
+  convertFunction: BigIntify,
+  apiKey: 'your-api-key', // Get from https://bitbadges.io/developer
+  apiUrl: 'https://api.bitbadges.io' // Optional, defaults to production
+});
+```
 
-| BitBadges Chain Version | SDK Version Range | Status     |
-| ----------------------- | ----------------- | ---------- |
-| v12                     | 0.18.x            | ✅ Current |
-| v13                     | 0.19.x            | ✅ Current |
-| v14                     | 0.20.x            | ✅ Current |
-| v15                     | 0.20.x            | ✅ Current |
-| v16                     | 0.21.x            | ✅ Current |
-| v18                     | 0.23.x            | ✅ Current |
-| v19                     | 0.24.x            | ✅ Current |
-| v20                     | 0.25.x            | ✅ Current |
-| v21                     | 0.26.x            | ✅ Current |
-| v22                     | 0.27.x            | ✅ Current |
-| v23                     | 0.28.x            | ✅ Current |
+### 2. Fetch a Collection
 
-**Recommendation:** Always use the latest patch version within your compatible major.minor version range. For example, if you're using BitBadges v12, use the latest `0.18.x` version.
+```typescript
+const response = await api.getCollections({
+  collectionsToFetch: [
+    {
+      collectionId: '1',
+      metadataToFetch: {
+        tokenIds: [{ start: 1n, end: 10n }]
+      }
+    }
+  ]
+});
 
-> 📖 **For detailed version information, see [VERSION_COMPATIBILITY.md](./VERSION_COMPATIBILITY.md)**
+const collection = response.collections[0]?.collection;
+console.log('Name:', collection?.collectionMetadataTimeline?.[0]?.collectionMetadata?.name);
+```
 
-### Installation
+### 3. Check a User's Balance
 
-```bash
-# For specific version
-npm install bitbadgesjs-sdk@^0.19.0
+```typescript
+const balance = await api.getBalanceByAddress(
+  '1',           // collectionId
+  'bb1abc...',   // address
+  {}
+);
 
-# For latest version
-npm install bitbadgesjs-sdk
+console.log('Token IDs:', balance.balances.map(b => b.badgeIds));
+console.log('Amounts:', balance.balances.map(b => b.amount));
 ```
 
-This library provides miscellaneous functionality to help you interact with BitBadges, such as types, API routes, managing metadata requests, logic with ID ranges and balances, etc.
+### 4. Get Token Activity
 
-It also exports functions for broadcasting transactions and interacting with the blockchain. See [Broadcasting Txs](../create-and-broadcast-txs/) for how to use.
+```typescript
+const activity = await api.getTokenActivity('1', '1', { bookmark: '' });
+
+for (const item of activity.activity) {
+  console.log(`${item.from} -> ${item.to}: ${item.balances}`);
+}
+```
+
+## Browser vs Node.js Usage
+
+The SDK works in both browser and Node.js environments. Environment detection is handled automatically.
+
+### Node.js
 
 ```typescript
-// Find a node URL from a network endpoint:
-// https://docs.evmos.org/develop/api/networks.
-const nodeUrl = ...
-
-const postOptions = {
-  method: 'POST',
-  headers: { 'Content-Type': 'application/json' },
-  body: generatePostBodyBroadcast(signedTx),
+// API key can be set via environment variable
+process.env.BITBADGES_API_KEY = 'your-api-key';
+
+const api = new BitBadgesAPI({
+  convertFunction: BigIntify
+  // apiKey will be read from BITBADGES_API_KEY env var
+});
+```
+
+### Browser
+
+```typescript
+// In browsers, you MUST pass the apiKey explicitly
+const api = new BitBadgesAPI({
+  convertFunction: BigIntify,
+  apiKey: 'your-api-key' // Required in browser - no env var access
+});
+```
+
+> **Note**: The SDK uses defensive checks (`typeof process !== 'undefined'`) to support both environments. No polyfills needed.
+
+## Core Concepts
+
+### Number Types
+
+The SDK uses a flexible `NumberType` system supporting `bigint`, `number`, and `string` to handle large blockchain values safely.
+
+```typescript
+import { BigIntify, Stringify, Numberify } from 'bitbadgesjs-sdk';
+
+// Always use BigIntify for large numbers (recommended)
+const collectionId = BigIntify('12345678901234567890');
+
+// Stringify for JSON serialization
+const idString = Stringify(12345678901234567890n);
+
+// Numberify only for small, safe integers
+const smallNum = Numberify('100');
+```
+
+### Type System
+
+The SDK has three type layers:
+
+| Type | Example | Use Case |
+|------|---------|----------|
+| **Interface** (`iType`) | `iBalance<bigint>` | Type annotations, function parameters |
+| **Class** | `Balance` | Most SDK operations - has utility methods |
+| **Proto** | `proto.Balance` | Blockchain serialization (strings only) |
+
+```typescript
+import { Balance, UintRange } from 'bitbadgesjs-sdk';
+
+// Create instances with classes
+const balance = new Balance({
+  amount: 100n,
+  badgeIds: [{ start: 1n, end: 10n }],
+  ownershipTimes: [{ start: 1n, end: 1000n }]
+});
+
+// Convert between number types
+const stringBalance = balance.convert(Stringify);
+
+// Convert to proto for blockchain
+const protoBalance = balance.toProto();
+```
+
+## Common Patterns
+
+### Pagination
+
+```typescript
+let bookmark = '';
+let hasMore = true;
+
+while (hasMore) {
+  const response = await api.getTokenActivity('1', '1', { bookmark });
+
+  // Process results
+  console.log(response.activity);
+
+  // Get next page
+  hasMore = response.pagination.hasMore;
+  bookmark = response.pagination.bookmark;
+}
+```
+
+### Error Handling
+
+```typescript
+try {
+  const response = await api.getCollections({ collectionsToFetch: [{ collectionId: '1' }] });
+} catch (error) {
+  if (error.errorMessage) {
+    console.error('API Error:', error.errorMessage);
+  }
+  if (error.unauthorized) {
+    console.error('Authentication required');
+  }
 }
+```
+
+### Address Utilities
+
+```typescript
+import { convertToBitBadgesAddress, isAddressValid } from 'bitbadgesjs-sdk';
+
+// Validate a BitBadges address
+const isValid = isAddressValid('bb1abc...');
+
+// Convert to BitBadges format (bb-prefixed only)
+const bbAddress = convertToBitBadgesAddress('bb1abc...');
+```
+
+## Module Structure
+
+```
+bitbadgesjs-sdk/
+├── core/           # Balance, UintRange, Approvals, Permissions
+├── api-indexer/    # BitBadgesAPI client and response types
+├── transactions/   # Message builders (MsgTransferTokens, etc.)
+├── address-converter/  # Address utilities
+├── interfaces/     # TypeScript type definitions
+├── proto/          # Protocol buffer types
+├── common/         # Number conversion utilities
+└── gamm/           # AMM pool utilities
+```
 
-const broadcastEndpoint = `${nodeUrl}${generateEndpointBroadcast()}`
-const broadcastPost = await fetch(
-  broadcastEndpoint,
-  postOptions,
-)
+### Key Exports
 
-const response = await broadcastPost.json()
+```typescript
+// API Client
+import { BitBadgesAPI } from 'bitbadgesjs-sdk';
+
+// Number Conversion
+import { BigIntify, Stringify, Numberify } from 'bitbadgesjs-sdk';
+
+// Core Classes
+import { Balance, UintRange, Transfer, CollectionApproval } from 'bitbadgesjs-sdk';
+
+// Address Utilities
+import { convertToBitBadgesAddress, isAddressValid } from 'bitbadgesjs-sdk';
+
+// Transaction Messages
+import { MsgTransferTokens, MsgCreateCollection } from 'bitbadgesjs-sdk';
+```
+
+## Version Compatibility
+
+| BitBadges Chain | SDK Version | Status |
+|-----------------|-------------|--------|
+| v25             | 0.30.x      | Current |
+| v24             | 0.29.x      | Supported |
+| v23             | 0.28.x      | Supported |
+| v22             | 0.27.x      | Supported |
+| v21             | 0.26.x      | Supported |
+| v20             | 0.25.x      | Supported |
+| v19             | 0.24.x      | Supported |
+| v18             | 0.23.x      | Supported |
+| v16             | 0.21.x      | Supported |
+| v14-15          | 0.20.x      | Supported |
+| v13             | 0.19.x      | Supported |
+| v12             | 0.18.x      | Supported |
+
+```bash
+# Install specific version for your chain
+npm install bitbadgesjs-sdk@^0.30.0
 ```
 
-For most use cases, you will not need to broadcast transactions. If you do, consider first exploring the helper broadcast tool at [https://bitbadges.io/dev/broadcast](https://bitbadges.io/dev/broadcast).
+## Troubleshooting
+
+### "BigInt is not defined"
+Ensure you're running Node.js 10.4+ or a modern browser. BigInt is required.
+
+### Precision loss with large numbers
+Always use `BigIntify` instead of `Numberify` for collection IDs and token IDs.
+
+### Browser: "process is not defined"
+This shouldn't occur - the SDK checks for `process` existence. If it does, ensure you're using the latest SDK version.
+
+### API authentication errors
+- Verify your API key at https://bitbadges.io/developer
+- In browsers, pass `apiKey` explicitly (env vars don't work)
+- For authenticated endpoints, use `api.setAccessToken(token)`
+
+### Transaction failures
+1. Always simulate first: `await api.simulateTx(payload)`
+2. Verify account has sufficient balance for fees
+3. Check sequence number is correct
+
+## Additional Resources
+
+- **Detailed Patterns & Examples**: See [AI_AGENT_GUIDE.md](./AI_AGENT_GUIDE.md) for comprehensive patterns
+- **API Documentation**: https://docs.bitbadges.io/for-developers/bitbadges-api/api
+- **GitHub**: https://github.com/bitbadges/bitbadgesjs
+- **Broadcast Helper**: https://bitbadges.io/dev/broadcast
+
+### Reference Implementations
+
+- [BitBadges Frontend](https://github.com/BitBadges/bitbadges-frontend) - Next.js web app
+- [BitBadges Indexer](https://github.com/BitBadges/bitbadges-indexer) - Express.js API
+
+## License
+
+See [LICENSE](./LICENSE) for details.

package/dist/cjs/index.d.ts

@@ -13,4 +13,5 @@ export * from './transactions/index.js';
 export * from './address-converter/index.js';
 export * from './node-rest-api/index.js';
 export * from './gamm/index.js';
+export * from './signing/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,IAAI,MAAM,CAAC;KAClB;CACF;AAaD,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AAEjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,IAAI,MAAM,CAAC;KAClB;CACF;AAaD,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AAEjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}

package/dist/cjs/index.js

@@ -55,4 +55,5 @@ __exportStar(require("./transactions/index.js"), exports);
 __exportStar(require("./address-converter/index.js"), exports);
 __exportStar(require("./node-rest-api/index.js"), exports);
 __exportStar(require("./gamm/index.js"), exports);
+__exportStar(require("./signing/index.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG;IACxB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;AACzB,CAAC,CAAC;AAGF,IAAI,OAAO,OAAO,KAAK,WAAW,EAAE,CAAC;AAErC,CAAC;KAAM,CAAC;IACN,OAAO,CAAC,GAAG,CAAC,mBAAmB,GAAG,MAAM,CAAC;AAC3C,CAAC;AAED,kDAAgC;AAChC,yDAAuC;AACvC,oDAAkC;AAClC,wDAAsC;AACtC,0DAA0C;AAC1C,mDAAiC;AAEjC,0DAAwC;AACxC,+DAA6C;AAC7C,2DAAyC;AACzC,kDAAgC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG;IACxB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;AACzB,CAAC,CAAC;AAGF,IAAI,OAAO,OAAO,KAAK,WAAW,EAAE,CAAC;AAErC,CAAC;KAAM,CAAC;IACN,OAAO,CAAC,GAAG,CAAC,mBAAmB,GAAG,MAAM,CAAC;AAC3C,CAAC;AAED,kDAAgC;AAChC,yDAAuC;AACvC,oDAAkC;AAClC,wDAAsC;AACtC,0DAA0C;AAC1C,mDAAiC;AAEjC,0DAAwC;AACxC,+DAA6C;AAC7C,2DAAyC;AACzC,kDAAgC;AAChC,qDAAmC"}

package/dist/cjs/signing/BitBadgesSigningClient.d.ts

@@ -0,0 +1,32 @@
+import type { AccountInfo, BroadcastResult, SignAndBroadcastOptions, SigningClientOptions, SimulateResult, TransactionMessage } from './types.js';
+export declare class BitBadgesSigningClient {
+    private readonly adapter;
+    private readonly apiUrl;
+    private readonly nodeUrl;
+    private readonly testnet;
+    private readonly chainIdOverride?;
+    private readonly sequenceRetryEnabled;
+    private readonly maxSequenceRetries;
+    private readonly gasMultiplier;
+    private readonly defaultGasLimit;
+    private readonly evmPrecompileGasLimit;
+    private readonly apiKey?;
+    private readonly axiosInstance;
+    private cachedAccountInfo;
+    constructor(options: SigningClientOptions);
+    get address(): string;
+    get chainType(): 'cosmos' | 'evm';
+    private get chainId();
+    getAccountInfo(forceRefresh?: boolean): Promise<AccountInfo>;
+    clearCache(): void;
+    private calculateFee;
+    simulate(messages: TransactionMessage[], options?: {
+        memo?: string;
+    }): Promise<SimulateResult>;
+    private normalizeMessages;
+    signAndBroadcast(messages: TransactionMessage[], options?: SignAndBroadcastOptions): Promise<BroadcastResult>;
+    private signAndBroadcastCosmos;
+    private isSequenceMismatchError;
+    private signAndBroadcastEvm;
+}
+//# sourceMappingURL=BitBadgesSigningClient.d.ts.map

package/dist/cjs/signing/BitBadgesSigningClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitBadgesSigningClient.d.ts","sourceRoot":"","sources":["../../../src/signing/BitBadgesSigningClient.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EAEpB,cAAc,EACd,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAmDpB,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAU;IAC/C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAG9C,OAAO,CAAC,iBAAiB,CAA4B;gBAOzC,OAAO,EAAE,oBAAoB;IA4BzC,IAAI,OAAO,IAAI,MAAM,CAOpB;IAKD,IAAI,SAAS,IAAI,QAAQ,GAAG,KAAK,CAEhC;IAKD,OAAO,KAAK,OAAO,GAKlB;IASK,cAAc,CAAC,YAAY,UAAQ,GAAG,OAAO,CAAC,WAAW,CAAC;IAoChE,UAAU,IAAI,IAAI;IAOlB,OAAO,CAAC,YAAY;IAgBd,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,EAAE,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IA4CpG,OAAO,CAAC,iBAAiB;IAgBnB,gBAAgB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,eAAe,CAAC;YAarG,sBAAsB;IAgHpC,OAAO,CAAC,uBAAuB;YAQjB,mBAAmB;CAkDlC"}

package/dist/cjs/signing/BitBadgesSigningClient.js

@@ -0,0 +1,270 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitBadgesSigningClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const converter_js_1 = require("../address-converter/converter.js");
+const constants_js_1 = require("../common/constants.js");
+const account_js_1 = require("../node-rest-api/account.js");
+const base_js_1 = require("../transactions/messages/base.js");
+const DEFAULT_API_URL = 'https://api.bitbadges.io';
+const TESTNET_API_URL = 'https://api.bitbadges.io/testnet';
+const DEFAULT_NODE_URL = 'https://lcd.bitbadges.io';
+const TESTNET_NODE_URL = 'https://lcd-testnet.bitbadges.io';
+const DEFAULT_GAS_LIMIT = 400000;
+const DEFAULT_EVM_PRECOMPILE_GAS_LIMIT = 2000000;
+const DEFAULT_GAS_MULTIPLIER = 1.3;
+const DEFAULT_MAX_SEQUENCE_RETRIES = 3;
+const DEFAULT_FEE_DENOM = 'ubadge';
+const DEFAULT_GAS_PRICE = 0.025;
+class BitBadgesSigningClient {
+    constructor(options) {
+        this.cachedAccountInfo = null;
+        this.adapter = options.adapter;
+        this.testnet = options.testnet || false;
+        this.apiUrl = options.apiUrl || (this.testnet ? TESTNET_API_URL : DEFAULT_API_URL);
+        this.nodeUrl = options.nodeUrl || (this.testnet ? TESTNET_NODE_URL : DEFAULT_NODE_URL);
+        this.chainIdOverride = options.chainIdOverride;
+        this.sequenceRetryEnabled = options.sequenceRetryEnabled !== false;
+        this.maxSequenceRetries = options.maxSequenceRetries || DEFAULT_MAX_SEQUENCE_RETRIES;
+        this.gasMultiplier = options.gasMultiplier || DEFAULT_GAS_MULTIPLIER;
+        this.defaultGasLimit = options.defaultGasLimit || DEFAULT_GAS_LIMIT;
+        this.evmPrecompileGasLimit = options.evmPrecompileGasLimit || DEFAULT_EVM_PRECOMPILE_GAS_LIMIT;
+        this.apiKey = options.apiKey;
+        this.axiosInstance = axios_1.default.create({
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.apiKey && { 'x-api-key': this.apiKey })
+            }
+        });
+    }
+    get address() {
+        const addr = this.adapter.address;
+        if (addr.startsWith('0x')) {
+            return (0, converter_js_1.convertToBitBadgesAddress)(addr);
+        }
+        return addr;
+    }
+    get chainType() {
+        return this.adapter.chainType;
+    }
+    get chainId() {
+        if (this.chainIdOverride) {
+            return this.chainIdOverride;
+        }
+        return this.testnet ? constants_js_1.TESTNET_CHAIN_DETAILS.cosmosChainId : constants_js_1.MAINNET_CHAIN_DETAILS.cosmosChainId;
+    }
+    async getAccountInfo(forceRefresh = false) {
+        if (this.cachedAccountInfo && !forceRefresh) {
+            return this.cachedAccountInfo;
+        }
+        const bbAddress = this.address;
+        const endpoint = (0, account_js_1.generateEndpointAccount)(bbAddress);
+        const response = await this.axiosInstance.get(`${this.nodeUrl}${endpoint}`);
+        const baseAccount = response.data.account.base_account;
+        let publicKey = baseAccount.pub_key?.key || '';
+        if (!publicKey) {
+            try {
+                publicKey = await this.adapter.getPublicKey();
+            }
+            catch {
+            }
+        }
+        this.cachedAccountInfo = {
+            address: bbAddress,
+            accountNumber: parseInt(baseAccount.account_number, 10),
+            sequence: parseInt(baseAccount.sequence, 10),
+            publicKey
+        };
+        return this.cachedAccountInfo;
+    }
+    clearCache() {
+        this.cachedAccountInfo = null;
+    }
+    calculateFee(gasLimit) {
+        const amount = Math.ceil(gasLimit * DEFAULT_GAS_PRICE);
+        return {
+            amount: amount.toString(),
+            denom: DEFAULT_FEE_DENOM,
+            gas: gasLimit.toString()
+        };
+    }
+    async simulate(messages, options) {
+        const accountInfo = await this.getAccountInfo();
+        if (!accountInfo.publicKey) {
+            throw new Error('Public key is required for simulation. Sign a transaction first to register the public key on chain.');
+        }
+        const protoMessages = this.normalizeMessages(messages);
+        const dummySignature = '0'.repeat(128);
+        const txContext = {
+            testnet: this.testnet,
+            chainIdOverride: this.chainIdOverride,
+            sender: {
+                address: this.address,
+                sequence: accountInfo.sequence,
+                accountNumber: accountInfo.accountNumber,
+                publicKey: accountInfo.publicKey
+            },
+            fee: this.calculateFee(this.defaultGasLimit),
+            memo: options?.memo || ''
+        };
+        const broadcastBody = (0, base_js_1.createTxBroadcastBody)(txContext, protoMessages, dummySignature);
+        const response = await this.axiosInstance.post(`${this.apiUrl}/api/v0/simulate`, JSON.parse(broadcastBody));
+        const gasUsed = parseInt(response.data.gas_info?.gas_used || '0', 10);
+        const gasLimit = Math.ceil(gasUsed * this.gasMultiplier);
+        return {
+            gasUsed,
+            gasLimit,
+            fee: this.calculateFee(gasLimit)
+        };
+    }
+    normalizeMessages(messages) {
+        return messages.map((msg) => {
+            if (msg && typeof msg.toProto === 'function') {
+                return msg.toProto();
+            }
+            return msg;
+        });
+    }
+    async signAndBroadcast(messages, options) {
+        if (this.adapter.chainType === 'evm') {
+            return this.signAndBroadcastEvm(messages, options);
+        }
+        return this.signAndBroadcastCosmos(messages, options);
+    }
+    async signAndBroadcastCosmos(messages, options, retryCount = 0) {
+        const accountInfo = await this.getAccountInfo();
+        if (!accountInfo.publicKey) {
+            const pubKey = await this.adapter.getPublicKey();
+            if (!pubKey) {
+                throw new Error('Public key is required for Cosmos transactions');
+            }
+            accountInfo.publicKey = pubKey;
+            this.cachedAccountInfo = accountInfo;
+        }
+        const protoMessages = this.normalizeMessages(messages);
+        let fee;
+        if (options?.fee) {
+            fee = options.fee;
+        }
+        else if (options?.simulate !== false) {
+            try {
+                const simResult = await this.simulate(messages, { memo: options?.memo });
+                const multiplier = options?.gasMultiplier || this.gasMultiplier;
+                const adjustedGas = Math.ceil(simResult.gasUsed * multiplier);
+                fee = this.calculateFee(adjustedGas);
+            }
+            catch {
+                fee = this.calculateFee(this.defaultGasLimit);
+            }
+        }
+        else {
+            fee = this.calculateFee(this.defaultGasLimit);
+        }
+        const txContext = {
+            testnet: this.testnet,
+            chainIdOverride: this.chainIdOverride,
+            sender: {
+                address: this.address,
+                sequence: accountInfo.sequence,
+                accountNumber: accountInfo.accountNumber,
+                publicKey: accountInfo.publicKey
+            },
+            fee,
+            memo: options?.memo || ''
+        };
+        const payload = (0, base_js_1.createTransactionPayload)(txContext, protoMessages);
+        if (!this.adapter.signDirect) {
+            throw new Error('Cosmos adapter must implement signDirect');
+        }
+        const signResult = await this.adapter.signDirect(payload, accountInfo.accountNumber);
+        const broadcastBody = (0, base_js_1.createTxBroadcastBody)(txContext, protoMessages, signResult.signature);
+        try {
+            const response = await this.axiosInstance.post(`${this.apiUrl}/api/v0/broadcast`, JSON.parse(broadcastBody));
+            const txResponse = response.data.tx_response;
+            const code = txResponse?.code || 0;
+            if (code !== 0 && this.isSequenceMismatchError(txResponse?.raw_log)) {
+                if (this.sequenceRetryEnabled && retryCount < this.maxSequenceRetries) {
+                    this.clearCache();
+                    return this.signAndBroadcastCosmos(messages, options, retryCount + 1);
+                }
+            }
+            if (code === 0 && this.cachedAccountInfo) {
+                this.cachedAccountInfo.sequence += 1;
+            }
+            return {
+                txHash: txResponse?.txhash || '',
+                rawResponse: response.data,
+                success: code === 0,
+                error: code !== 0 ? txResponse?.raw_log : undefined,
+                code
+            };
+        }
+        catch (error) {
+            const rawLog = error?.response?.data?.tx_response?.raw_log || error?.message || '';
+            if (this.isSequenceMismatchError(rawLog)) {
+                if (this.sequenceRetryEnabled && retryCount < this.maxSequenceRetries) {
+                    this.clearCache();
+                    return this.signAndBroadcastCosmos(messages, options, retryCount + 1);
+                }
+            }
+            return {
+                txHash: '',
+                rawResponse: error?.response?.data,
+                success: false,
+                error: error?.message || 'Unknown error',
+                code: error?.response?.data?.tx_response?.code || -1
+            };
+        }
+    }
+    isSequenceMismatchError(message) {
+        if (!message)
+            return false;
+        return message.includes('account sequence mismatch') || message.includes('incorrect account sequence');
+    }
+    async signAndBroadcastEvm(messages, options) {
+        if (!this.adapter.sendEvmTransaction) {
+            throw new Error('EVM adapter must implement sendEvmTransaction');
+        }
+        const protoMessages = this.normalizeMessages(messages);
+        const evmAddress = this.adapter.address;
+        const txContext = {
+            testnet: this.testnet,
+            chainIdOverride: this.chainIdOverride,
+            evmAddress,
+            fee: this.calculateFee(this.evmPrecompileGasLimit),
+            memo: options?.memo || ''
+        };
+        const payload = (0, base_js_1.createTransactionPayload)(txContext, protoMessages);
+        if (!payload.evmTx) {
+            throw new Error('Messages are not supported for EVM precompile conversion');
+        }
+        try {
+            const txHash = await this.adapter.sendEvmTransaction({
+                to: payload.evmTx.to,
+                data: payload.evmTx.data,
+                value: payload.evmTx.value,
+                gasLimit: this.evmPrecompileGasLimit
+            });
+            return {
+                txHash,
+                rawResponse: { evmTx: payload.evmTx },
+                success: true,
+                code: 0
+            };
+        }
+        catch (error) {
+            return {
+                txHash: '',
+                rawResponse: null,
+                success: false,
+                error: error?.message || 'EVM transaction failed',
+                code: -1
+            };
+        }
+    }
+}
+exports.BitBadgesSigningClient = BitBadgesSigningClient;
+//# sourceMappingURL=BitBadgesSigningClient.js.map