> ## Documentation Index
> Fetch the complete documentation index at: https://voltaire.tevm.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Address.fromPrivateKey

> Derive address from secp256k1 private key

<Card title="Try it Live" icon="play" href="https://playground.tevm.sh?example=primitives/address.ts">
  Run Address examples in the interactive playground
</Card>

<Warning>
  **This page is a placeholder.** All examples on this page are currently AI-generated and are not correct. This documentation will be completed in the future with accurate, tested examples.
</Warning>

<Tip>
  View the complete executable example at [`playground/src/examples/primitives/address/from-private-key.ts`](https://github.com/evmts/voltaire/blob/main/playground/src/examples/primitives/address/from-private-key.ts).
</Tip>

## Factory API

For tree-shakeable, crypto-agnostic implementation, use the factory function:

```typescript theme={null}
import { FromPrivateKey } from '@tevm/voltaire/Address/AddressType'
import { hash as keccak256 } from '@tevm/voltaire/Keccak256'
import { derivePublicKey } from '@tevm/voltaire/Secp256k1'
import * as PrivateKey from '@tevm/voltaire/primitives/PrivateKey'

// Create factory instance with both crypto dependencies
const fromPrivateKey = FromPrivateKey({ keccak256, derivePublicKey })

// Use the factory
const privateKey = PrivateKey('0x...')
const address = fromPrivateKey(privateKey)
```

**Note:** This method requires TWO crypto dependencies:

* `keccak256` - For hashing the public key
* `derivePublicKey` - For deriving public key from private key

This allows complete control over which crypto implementations to use (native, WASM, or custom).

## Standard API

The standard API automatically injects crypto dependencies:

```typescript theme={null}
import { Address } from '@tevm/voltaire'

const privateKey = Bytes32()
// ... set private key bytes ...

const address = Address(privateKey)
```

## C FFI

The C API does not currently expose `fromPrivateKey` directly. To derive addresses from private keys in C, use the crypto library's secp256k1 functions to derive the public key first, then use `primitives_address_from_public_key`.

**Example workflow:**

```c theme={null}
#include "tevm.h"

// 1. Derive public key from private key (using secp256k1)
uint8_t private_key[32] = { /* your private key */ };
uint8_t public_key[64];  // x, y coordinates

// Use secp256k1_pubkey_create or similar (not shown - requires crypto lib)
// secp256k1_derive_public_key(private_key, public_key);

// 2. Convert public key coordinates to address
// Note: This function may not exist yet in C API
// If not available, compute manually:
// - Hash public key with keccak256
// - Take last 20 bytes for address

// Future API (when available):
// PrimitivesAddress addr;
// int result = primitives_address_from_public_key(public_key, 64, &addr);
```

**Note:** For production use with C, consider:

* Using the crypto library directly for secp256k1 operations
* Computing keccak256 hash of the derived public key
* Extracting the last 20 bytes for the address

**Alternative:** Use Zig or TypeScript APIs for key derivation, then pass addresses to C code as hex strings or byte arrays.

**Defined in:** [src/primitives.h](https://github.com/evmts/voltaire/blob/main/src/primitives.h)

## Algorithm

The address derivation follows this process:

1. **Derive public key** - Multiply generator point G by private key scalar
2. **Extract coordinates** - Get x and y coordinates from resulting point
3. **Hash public key** - Compute keccak256(x || y)
4. **Extract address** - Take last 20 bytes of hash

**Pseudocode:**

```
publicKey = secp256k1.multiply(G, privateKey)  // 64 bytes (x, y)
hash = keccak256(publicKey)                    // 32 bytes
address = hash[12:32]                          // Last 20 bytes
```

## Private Key Requirements

**Size:** Exactly 32 bytes (256 bits)

**Valid range:** `1` to `n-1` where `n` is the secp256k1 curve order:

```
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
```

**Invalid values:**

* All zeros (0x0000...0000)
* Greater than or equal to curve order

## Security Considerations

<Warning title="Private Key Security">
  Never hardcode or log private keys. Store securely and transmit only over encrypted channels. Compromised private keys allow complete control of associated addresses.
</Warning>

**Best practices:**

* Generate from cryptographically secure random source
* Never reuse across different accounts/networks
* Store encrypted at rest
* Use hardware wallets for high-value keys
* Implement key rotation policies

## Complete Example

```typescript theme={null}
import { Address } from '@tevm/voltaire'
import { randomBytes } from 'crypto' // Node.js

// Generate secure random private key
const privateKey = randomBytes(32)

// Derive address
const addr = Address(privateKey)

console.log('Address:', addr.toChecksummed())
console.log('Private key:', Buffer(privateKey).toString('hex'))

// Store private key securely (encrypted)
// Store address publicly (for receiving funds)
```

## Use Cases

### Wallet Generation

Generate new Ethereum accounts:

```typescript theme={null}
import { Address } from '@tevm/voltaire'

function generateAccount() {
  const privateKey = Bytes32()
  crypto.getRandomValues(privateKey)

  const address = Address(privateKey)

  return {
    address: address.toChecksummed(),
    privateKey: Buffer(privateKey).toString('hex')
  }
}

const account = generateAccount()
```

### Key Import

Import existing private keys:

```typescript theme={null}
import { Address } from '@tevm/voltaire'
import * as Hex from '@tevm/voltaire/Hex'

function importPrivateKey(keyHex: string) {
  // Remove 0x prefix if present
  const cleanHex = keyHex.startsWith('0x') ? keyHex.slice(2) : keyHex

  if (cleanHex.length !== 64) {
    throw new Error('Private key must be 32 bytes (64 hex chars)')
  }

  const privateKey = Hex.toBytes(`0x${cleanHex}`)
  const address = Address(privateKey)

  return address
}
```

### HD Wallets

Derive addresses from HD wallet private keys:

```typescript theme={null}
import { Address } from '@tevm/voltaire'

// Assume deriveChildKey generates child keys from master seed
function deriveAddresses(masterSeed: Uint8Array, count: number) {
  const addresses = []

  for (let i = 0; i < count; i++) {
    const childKey = deriveChildKey(masterSeed, i) // BIP32/BIP44
    const address = Address(childKey)
    addresses.push(address.toChecksummed())
  }

  return addresses
}
```

## Performance

**Cryptographic operations:**

* secp256k1 scalar multiplication (public key derivation)
* keccak256 hash function

**Bundle size impact:** When using tree-shakeable imports, including this method adds:

* secp256k1 implementation (\~15-20 KB)
* keccak256 implementation (\~5-10 KB)

**Execution time:** \~0.5-2ms depending on implementation and hardware.

## Error Handling

```typescript theme={null}
import { Address } from '@tevm/voltaire'

// Wrong length
try {
  const shortKey = Bytes16()
  Address(shortKey)
} catch (e) {
  console.error(e) // InvalidAddressLengthError: must be 32 bytes
}

// Invalid value (all zeros)
try {
  const zeroKey = Bytes32()
  Address(zeroKey)
} catch (e) {
  console.error(e) // InvalidValueError: Invalid private key
}

// Out of range
try {
  const invalidKey = Bytes32().fill(0xFF)
  Address(invalidKey)
} catch (e) {
  console.error(e) // InvalidValueError: Invalid private key
}
```

## See Also

* [fromPublicKey](/primitives/address/from-public-key) - Derive from public key coordinates
* [from](/primitives/address/from) - Universal constructor
* [Secp256k1](/crypto/secp256k1) - secp256k1 cryptography
* [Keccak256](/crypto/keccak256) - Keccak256 hash function
* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 4.2 (Address derivation)