Signer Service

import { Effect, Schedule, Layer } from 'effect'
import {
  SignerService, Signer, Provider, LocalAccount,
  HttpTransport, Secp256k1Live, KeccakLive,
  withTimeout, withRetrySchedule
} from 'voltaire-effect'
import { Hex } from '@tevm/voltaire'

const privateKey = Hex.fromHex('0xac0974bec...')

// Compose layers first
const DepsLayer = Layer.mergeAll(
  Secp256k1Live,
  KeccakLive,
  HttpTransport({
    url: 'https://eth.llamarpc.com',
    timeout: '30 seconds',
    retrySchedule: Schedule.exponential('1 second').pipe(
      Schedule.jittered,
      Schedule.compose(Schedule.recurs(3))
    )
  })
)
const SignerLayer = Signer.fromPrivateKey(privateKey, Provider).pipe(Layer.provide(DepsLayer))

const program = Effect.gen(function* () {
  const signer = yield* SignerService

  // Per-request timeout for transaction broadcast
  return yield* signer.sendTransaction({
    to: recipientAddress,
    value: 1000000000000000000n
  }).pipe(withTimeout('30 seconds'))
}).pipe(Effect.provide(SignerLayer))

const signer = Signer.fromPrivateKey(privateKey, Provider)

// Equivalent to:
const signer = Signer.fromProvider(Provider, LocalAccount(privateKey))

import { Signer, Provider, LocalAccount, JsonRpcAccount } from 'voltaire-effect'

// With local account (private key signing)
const localSigner = Signer.fromProvider(Provider, LocalAccount(privateKey))

// With JSON-RPC account (browser wallet)
const browserSigner = Signer.fromProvider(Provider, JsonRpcAccount(userAddress))

const DepsLayer = Layer.mergeAll(Provider, LocalAccount(privateKey))
const signer = Signer.Live.pipe(Layer.provide(DepsLayer))

// Type: Layer.Layer<SignerService, never, TransportService>

import * as Layer from 'effect/Layer'

// Signer.Live depends on Provider + Account + Transport
const Signer = {
  Live: Layer.effect(SignerService, Effect.gen(function* () {
    const provider = yield* ProviderService
    const account = yield* AccountService
    const transport = yield* TransportService
    // ... implementation
  })) as Layer.Layer<SignerService, never, ProviderService | AccountService | TransportService>,

  // Compose Provider + Account into ready-to-use Signer
  fromProvider: (
    providerLayer: Layer.Layer<ProviderService, any, TransportService>,
    accountLayer: Layer.Layer<AccountService>
  ): Layer.Layer<SignerService, any, TransportService> =>
    Signer.Live.pipe(
      Layer.provide(Layer.mergeAll(providerLayer, accountLayer))
    ),

  // Convenience: local private key signer
  fromPrivateKey: (
    privateKey: Hex,
    providerLayer: Layer.Layer<ProviderService, any, TransportService>
  ): Layer.Layer<SignerService, any, TransportService> =>
    Signer.fromProvider(providerLayer, LocalAccount(privateKey)),
}

import { JsonRpcAccount, BrowserTransport } from 'voltaire-effect'
import { Layer } from 'effect'

// Compose layers first
const BrowserSignerLayer = Signer.fromProvider(Provider, JsonRpcAccount(userAddress)).pipe(
  Layer.provide(BrowserTransport)
)

const program = Effect.gen(function* () {
  const signer = yield* SignerService
  const accounts = yield* signer.requestAddresses() // triggers popup
  const txHash = yield* signer.sendTransaction({ to, value })
  return txHash
}).pipe(Effect.provide(BrowserSignerLayer))

const signature = yield* signer.signMessage(Hex.fromString('Hello!'))

const signedTx = yield* signer.signTransaction({ to, value })

const sig = yield* signer.signTypedData({
  domain: { name: 'App', version: '1', chainId: 1n },
  primaryType: 'Order',
  types: { Order: [{ name: 'amount', type: 'uint256' }] },
  message: { amount: 1000n }
})

const txHash = yield* signer.sendTransaction({ to, value: 1000000000000000000n })

const txHash = yield* signer.sendRawTransaction(signedTxHex)

const accounts = yield* signer.requestAddresses()

yield* signer.switchChain(137) // Polygon

// AddressInput accepts both branded AddressType and hex strings (matches Provider API)
type AddressInput = AddressType | `0x${string}`

type TransactionRequest = {
  readonly to?: AddressInput | null    // null = contract deploy
  readonly value?: bigint
  readonly data?: HexType
  readonly nonce?: bigint              // auto-filled from getTransactionCount('pending')
  readonly gasLimit?: bigint           // auto-estimated via estimateGas
  readonly gasPrice?: bigint           // legacy (type 0/1)
  readonly maxFeePerGas?: bigint       // EIP-1559+ (type 2/3/4)
  readonly maxPriorityFeePerGas?: bigint
  readonly chainId?: bigint            // auto-detected from eth_chainId
  readonly accessList?: Array<{        // EIP-2930+ access list
    address: AddressInput
    storageKeys: Array<`0x${string}`>
  }>
  
  // Explicit transaction type (auto-detected if not provided)
  readonly type?: 0 | 1 | 2 | 3 | 4
  
  // EIP-4844 blob transaction fields
  readonly blobVersionedHashes?: readonly `0x${string}`[]
  readonly maxFeePerBlobGas?: bigint
  
  // EIP-7702 set code authorization
  readonly authorizationList?: readonly {
    chainId: bigint
    address: `0x${string}`
    nonce: bigint
    yParity: number
    r: `0x${string}`
    s: `0x${string}`
  }[]
}

maxFeePerGas = baseFeePerGas * 1.2 + maxPriorityFeePerGas

import { SignerError } from 'voltaire-effect'

program.pipe(
  Effect.catchTag('SignerError', (e) => {
    if (e.message.includes('insufficient funds')) return Effect.fail(e)
    if (e.message.includes('rejected')) return Effect.fail(e)
    return Effect.fail(e)
  })
)

type SignerShape = {
  readonly signMessage: (message: HexType) => Effect.Effect<SignatureType, SignerError>
  readonly signTransaction: (tx: TransactionRequest) => Effect.Effect<HexType, SignerError>
  readonly signTypedData: (typedData: TypedDataType) => Effect.Effect<SignatureType, SignerError>
  readonly sendTransaction: (tx: TransactionRequest) => Effect.Effect<HashType, SignerError>
  readonly sendRawTransaction: (signedTx: HexType) => Effect.Effect<HashType, SignerError>
  readonly requestAddresses: () => Effect.Effect<AddressType[], SignerError>
  readonly switchChain: (chainId: number) => Effect.Effect<void, SignerError>
}

// HexType is a branded `0x${string}` for signed transaction bytes
// HashType is a branded Uint8Array for 32-byte hashes (tx hash)
// SignatureType is a branded Uint8Array with signature metadata