@bronlabs/bron-ethers-signer 1.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bron Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,163 @@
+# @bronlabs/bron-ethers-signer
+
+Ethers.js compatible signer for [Bron](https://bron.dev) custody platform.
+
+## Installation
+
+```bash
+npm install @bronlabs/bron-ethers-signer ethers
+```
+
+## Usage
+
+```typescript
+import { BronSigner } from '@bronlabs/bron-ethers-signer';
+import { ethers } from 'ethers';
+
+// Create provider
+const provider = new ethers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_KEY');
+
+// Create BronSigner
+const signer = new BronSigner({
+  provider,
+  apiKey: process.env.BRON_API_KEY!,
+  workspaceId: process.env.BRON_WORKSPACE_ID!,
+  accountId: process.env.BRON_ACCOUNT_ID!,
+});
+
+// Get signer address
+const address = await signer.getAddress();
+console.log('Address:', address);
+
+// Sign a message (EIP-191)
+const signature = await signer.signMessage('Hello World');
+console.log('Signature:', signature);
+
+// Verify signature
+const recovered = ethers.verifyMessage('Hello World', signature);
+console.log('Recovered:', recovered);
+
+// Sign typed data (EIP-712)
+const domain = {
+  name: 'MyApp',
+  version: '1',
+  chainId: 1,
+  verifyingContract: '0x...',
+};
+
+const types = {
+  Message: [
+    { name: 'content', type: 'string' },
+    { name: 'value', type: 'uint256' },
+  ],
+};
+
+const value = {
+  content: 'Hello',
+  value: 42,
+};
+
+const typedSignature = await signer.signTypedData(domain, types, value);
+console.log('Typed Signature:', typedSignature);
+
+// Send a transaction
+const tx = await signer.sendTransaction({
+  to: '0x...',
+  value: ethers.parseEther('0.1'),
+  data: '0x',
+});
+console.log('Transaction hash:', tx.hash);
+await tx.wait();
+```
+
+## Supported Networks
+
+| Network   | Chain ID   |
+|-----------|------------|
+| Ethereum  | 1          |
+| Arbitrum  | 42161      |
+| Base      | 8453       |
+| Optimism  | 10         |
+| BNB Chain | 56         |
+| Sepolia   | 11155111   |
+
+## API Reference
+
+### `BronSigner`
+
+#### Constructor
+
+```typescript
+new BronSigner(options: BronSignerOptions)
+```
+
+Options:
+- `provider` - Ethers.js provider instance
+- `apiKey` - Bron API key
+- `workspaceId` - Bron workspace ID
+- `accountId` - Bron account ID
+
+#### Methods
+
+- `getAddress(): Promise<string>` - Get the signer's address
+- `signMessage(message: string | Uint8Array): Promise<string>` - Sign a message (EIP-191)
+- `signTypedData(domain, types, value): Promise<string>` - Sign typed data (EIP-712)
+- `sendTransaction(tx): Promise<TransactionResponse>` - Send a transaction
+- `connect(provider): BronSigner` - Connect to a different provider
+
+### Utility Functions
+
+```typescript
+import {
+  getNetworkId,
+  getGasTokenId,
+  isChainSupported,
+  getSupportedChainIds
+} from '@bronlabs/bron-ethers-signer';
+
+// Get Bron network ID from chain ID
+const networkId = getNetworkId(1); // 'ETH'
+
+// Check if chain is supported
+const supported = isChainSupported(42161); // true
+
+// Get all supported chain IDs
+const chainIds = getSupportedChainIds(); // [1, 42161, 8453, ...]
+```
+
+## Hardhat Integration
+
+Simple one-liner to override `ethers.getSigners()` and `ethers.getSigner()`:
+
+```javascript
+// hardhat.config.js
+require("dotenv").config();
+const { extendHardhatWithBronSigner } = require("@bronlabs/bron-ethers-signer/hardhat");
+
+extendHardhatWithBronSigner({
+  apiKey: process.env.BRON_API_KEY,
+  workspaceId: process.env.BRON_WORKSPACE_ID,
+  accountId: process.env.BRON_ACCOUNT_ID,
+});
+
+module.exports = {
+  // ... your config
+};
+```
+
+Now all hardhat scripts using `ethers.getSigners()` will automatically use BronSigner for non-local networks.
+
+### Options
+
+```javascript
+extendHardhatWithBronSigner({
+  apiKey: process.env.BRON_API_KEY,
+  workspaceId: process.env.BRON_WORKSPACE_ID,
+  accountId: process.env.BRON_ACCOUNT_ID,
+  excludeNetworks: ['hardhat', 'localhost'], // optional, these are defaults
+});
+```
+
+## License
+
+MIT

package/dist/BronSigner-CMusvgJo.d.cts

@@ -0,0 +1,117 @@
+import { Provider, TypedDataField, TypedDataDomain, AbstractSigner, TransactionRequest, TransactionResponse } from 'ethers';
+
+/**
+ * Configuration options for BronSigner
+ */
+interface BronSignerOptions {
+    /** Ethers.js provider instance */
+    provider: Provider;
+    /** Bron API key */
+    apiKey: string;
+    /** Bron workspace ID */
+    workspaceId: string;
+    /** Bron account ID */
+    accountId: string;
+}
+/**
+ * Network mapping configuration
+ */
+interface NetworkMapping {
+    /** Bron network ID */
+    networkId: string;
+    /** Bron gas token asset ID */
+    gasTokenId: number;
+}
+/**
+ * EIP-712 typed data structure
+ */
+interface EIP712TypedData {
+    types: Record<string, TypedDataField[]>;
+    primaryType: string;
+    domain: TypedDataDomain;
+    message: Record<string, unknown>;
+}
+/**
+ * Bron transaction status
+ */
+type TransactionStatus = 'pending' | 'awaiting-approval' | 'approved' | 'signing' | 'broadcasting' | 'completed' | 'failed' | 'rejected' | 'canceled';
+
+/**
+ * Ethers.js compatible signer that uses Bron custody platform for signing operations.
+ *
+ * @example
+ * ```typescript
+ * import { BronSigner } from '@bronlabs/bron-ethers-signer';
+ * import { ethers } from 'ethers';
+ *
+ * const provider = new ethers.JsonRpcProvider('https://mainnet.infura.io/v3/...');
+ *
+ * const signer = new BronSigner({
+ *   provider,
+ *   apiKey: process.env.BRON_API_KEY!,
+ *   workspaceId: process.env.BRON_WORKSPACE_ID!,
+ *   accountId: process.env.BRON_ACCOUNT_ID!,
+ * });
+ *
+ * // Sign a message
+ * const signature = await signer.signMessage('Hello World');
+ *
+ * // Sign typed data (EIP-712)
+ * const typedSignature = await signer.signTypedData(domain, types, value);
+ *
+ * // Send a transaction
+ * const tx = await signer.sendTransaction({ to: '0x...', value: ethers.parseEther('1') });
+ * ```
+ */
+declare class BronSigner extends AbstractSigner {
+    private readonly bronApi;
+    private readonly apiKey;
+    private readonly workspaceId;
+    private readonly accountId;
+    constructor(options: BronSignerOptions);
+    /**
+     * Creates a new BronSigner connected to a different provider
+     */
+    connect(provider: Provider): BronSigner;
+    /**
+     * Returns the address associated with this signer's Bron account
+     */
+    getAddress(): Promise<string>;
+    /**
+     * Sends a transaction through Bron custody platform.
+     * The transaction will be signed and broadcast by Bron.
+     */
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
+    /**
+     * Transaction signing is not supported by BronSigner.
+     * Use sendTransaction() instead which handles signing and broadcasting internally.
+     * @throws Always throws - use sendTransaction instead
+     */
+    signTransaction(_tx: TransactionRequest): Promise<string>;
+    /**
+     * Signs a message using the Bron custody platform.
+     * Uses EIP-191 personal_sign format.
+     *
+     * @param message - The message to sign (string, Buffer, or Uint8Array)
+     * @returns The signature as a hex string
+     */
+    signMessage(message: string | Uint8Array): Promise<string>;
+    /**
+     * Signs typed data using EIP-712 standard through Bron custody platform.
+     *
+     * @param domain - The EIP-712 domain
+     * @param types - The type definitions
+     * @param value - The data to sign
+     * @returns The signature as a hex string
+     */
+    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    private assertProvider;
+    private getBronNetworkId;
+    private getBronGasTokenId;
+    private messageToHex;
+    private buildTypedData;
+    private sanitizeForJson;
+    private pollTransaction;
+}
+
+export { BronSigner as B, type EIP712TypedData as E, type NetworkMapping as N, type TransactionStatus as T, type BronSignerOptions as a };

package/dist/BronSigner-CMusvgJo.d.ts

@@ -0,0 +1,117 @@
+import { Provider, TypedDataField, TypedDataDomain, AbstractSigner, TransactionRequest, TransactionResponse } from 'ethers';
+
+/**
+ * Configuration options for BronSigner
+ */
+interface BronSignerOptions {
+    /** Ethers.js provider instance */
+    provider: Provider;
+    /** Bron API key */
+    apiKey: string;
+    /** Bron workspace ID */
+    workspaceId: string;
+    /** Bron account ID */
+    accountId: string;
+}
+/**
+ * Network mapping configuration
+ */
+interface NetworkMapping {
+    /** Bron network ID */
+    networkId: string;
+    /** Bron gas token asset ID */
+    gasTokenId: number;
+}
+/**
+ * EIP-712 typed data structure
+ */
+interface EIP712TypedData {
+    types: Record<string, TypedDataField[]>;
+    primaryType: string;
+    domain: TypedDataDomain;
+    message: Record<string, unknown>;
+}
+/**
+ * Bron transaction status
+ */
+type TransactionStatus = 'pending' | 'awaiting-approval' | 'approved' | 'signing' | 'broadcasting' | 'completed' | 'failed' | 'rejected' | 'canceled';
+
+/**
+ * Ethers.js compatible signer that uses Bron custody platform for signing operations.
+ *
+ * @example
+ * ```typescript
+ * import { BronSigner } from '@bronlabs/bron-ethers-signer';
+ * import { ethers } from 'ethers';
+ *
+ * const provider = new ethers.JsonRpcProvider('https://mainnet.infura.io/v3/...');
+ *
+ * const signer = new BronSigner({
+ *   provider,
+ *   apiKey: process.env.BRON_API_KEY!,
+ *   workspaceId: process.env.BRON_WORKSPACE_ID!,
+ *   accountId: process.env.BRON_ACCOUNT_ID!,
+ * });
+ *
+ * // Sign a message
+ * const signature = await signer.signMessage('Hello World');
+ *
+ * // Sign typed data (EIP-712)
+ * const typedSignature = await signer.signTypedData(domain, types, value);
+ *
+ * // Send a transaction
+ * const tx = await signer.sendTransaction({ to: '0x...', value: ethers.parseEther('1') });
+ * ```
+ */
+declare class BronSigner extends AbstractSigner {
+    private readonly bronApi;
+    private readonly apiKey;
+    private readonly workspaceId;
+    private readonly accountId;
+    constructor(options: BronSignerOptions);
+    /**
+     * Creates a new BronSigner connected to a different provider
+     */
+    connect(provider: Provider): BronSigner;
+    /**
+     * Returns the address associated with this signer's Bron account
+     */
+    getAddress(): Promise<string>;
+    /**
+     * Sends a transaction through Bron custody platform.
+     * The transaction will be signed and broadcast by Bron.
+     */
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
+    /**
+     * Transaction signing is not supported by BronSigner.
+     * Use sendTransaction() instead which handles signing and broadcasting internally.
+     * @throws Always throws - use sendTransaction instead
+     */
+    signTransaction(_tx: TransactionRequest): Promise<string>;
+    /**
+     * Signs a message using the Bron custody platform.
+     * Uses EIP-191 personal_sign format.
+     *
+     * @param message - The message to sign (string, Buffer, or Uint8Array)
+     * @returns The signature as a hex string
+     */
+    signMessage(message: string | Uint8Array): Promise<string>;
+    /**
+     * Signs typed data using EIP-712 standard through Bron custody platform.
+     *
+     * @param domain - The EIP-712 domain
+     * @param types - The type definitions
+     * @param value - The data to sign
+     * @returns The signature as a hex string
+     */
+    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    private assertProvider;
+    private getBronNetworkId;
+    private getBronGasTokenId;
+    private messageToHex;
+    private buildTypedData;
+    private sanitizeForJson;
+    private pollTransaction;
+}
+
+export { BronSigner as B, type EIP712TypedData as E, type NetworkMapping as N, type TransactionStatus as T, type BronSignerOptions as a };