Address Generation and Validation

npm install ethers @scure/base

import { Wallet, HDNodeWallet, getAddress, isAddress, getBytes, hexlify } from "ethers";
import { bech32 } from "@scure/base";

function hexToC8(hexAddress) {
  const checksummed = getAddress(hexAddress);
  return bech32.encode("c8", bech32.toWords(getBytes(checksummed)));
}

function c8ToHex(c8Address) {
  const decoded = bech32.decode(c8Address);
  if (decoded.prefix !== "c8") throw new Error("invalid c8ntinuum prefix");
  const bytes = new Uint8Array(bech32.fromWords(decoded.words));
  if (bytes.length !== 20) throw new Error("invalid account byte length");
  return getAddress(hexlify(bytes));
}

function validateC8ntinuumAddress(address) {
  if (address.startsWith("0x")) return isAddress(address);
  if (address.startsWith("c8")) {
    try {
      c8ToHex(address);
      return true;
    } catch {
      return false;
    }
  }
  return false;
}

const randomWallet = Wallet.createRandom();
console.log({
  privateKey: randomWallet.privateKey,
  publicKey: randomWallet.signingKey.publicKey,
  evmAddress: randomWallet.address,
  bech32Address: hexToC8(randomWallet.address),
});

const mnemonic = Wallet.createRandom().mnemonic.phrase;
const hdWallet = HDNodeWallet.fromPhrase(mnemonic, undefined, "m/44'/60'/0'/0/0");
console.log(validateC8ntinuumAddress(hdWallet.address));

import java.math.BigInteger;
import org.web3j.crypto.ECKeyPair;
import org.web3j.crypto.Keys;
import org.web3j.crypto.WalletUtils;
import org.web3j.utils.Numeric;

public final class C8ntinuumAddressDemo {
  static String hexToC8(String hexAddress) {
    String checksum = Keys.toChecksumAddress(hexAddress);
    byte[] addressBytes = Numeric.hexStringToByteArray(checksum);
    return Bech32.encode("c8", addressBytes);
  }

  static String c8ToHex(String c8Address) {
    byte[] addressBytes = Bech32.decodeToBytes(c8Address, "c8");
    if (addressBytes.length != 20) {
      throw new IllegalArgumentException("invalid account byte length");
    }
    return Keys.toChecksumAddress(Numeric.toHexString(addressBytes));
  }

  static boolean isValidC8ntinuumAddress(String address) {
    try {
      if (address.startsWith("0x")) return WalletUtils.isValidAddress(address);
      if (address.startsWith("c8")) {
        c8ToHex(address);
        return true;
      }
      return false;
    } catch (Exception error) {
      return false;
    }
  }

  public static void main(String[] args) throws Exception {
    ECKeyPair keyPair = Keys.createEcKeyPair();
    BigInteger privateKey = keyPair.getPrivateKey();
    BigInteger publicKey = keyPair.getPublicKey();

    String evmAddress = Keys.toChecksumAddress("0x" + Keys.getAddress(publicKey));
    String c8Address = hexToC8(evmAddress);

    System.out.println("privateKey=0x" + privateKey.toString(16));
    System.out.println("publicKey=0x" + publicKey.toString(16));
    System.out.println("evmAddress=" + evmAddress);
    System.out.println("c8Address=" + c8Address);
    System.out.println("valid=" + isValidC8ntinuumAddress(c8Address));
  }
}

package main

import (
	"crypto/ecdsa"
	"fmt"

	"github.com/cosmos/cosmos-sdk/types/bech32"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/crypto"
)

func HexToC8(hexAddress string) (string, error) {
	if !common.IsHexAddress(hexAddress) {
		return "", fmt.Errorf("invalid EVM address")
	}
	addr := common.HexToAddress(hexAddress)
	return bech32.ConvertAndEncode("c8", addr.Bytes())
}

func C8ToHex(c8Address string) (common.Address, error) {
	prefix, bytes, err := bech32.DecodeAndConvert(c8Address)
	if err != nil {
		return common.Address{}, err
	}
	if prefix != "c8" || len(bytes) != common.AddressLength {
		return common.Address{}, fmt.Errorf("invalid c8ntinuum account address")
	}
	return common.BytesToAddress(bytes), nil
}

func main() {
	privateKey, err := crypto.GenerateKey()
	if err != nil {
		panic(err)
	}

	publicKey := privateKey.Public().(*ecdsa.PublicKey)
	evmAddress := crypto.PubkeyToAddress(*publicKey)
	c8Address, err := HexToC8(evmAddress.Hex())
	if err != nil {
		panic(err)
	}

	fmt.Printf("privateKey=0x%x\n", crypto.FromECDSA(privateKey))
	fmt.Printf("publicKey=0x%x\n", crypto.FromECDSAPub(publicKey))
	fmt.Println("evmAddress=", evmAddress.Hex())
	fmt.Println("c8Address=", c8Address)
	fmt.Println("isEvmValid=", common.IsHexAddress(evmAddress.Hex()))
}

use alloy::primitives::{Address, hex};
use alloy::signers::local::PrivateKeySigner;
use bech32::{self, FromBase32, ToBase32, Variant};

fn hex_to_c8(address: Address) -> eyre::Result<String> {
    Ok(bech32::encode("c8", address.as_slice().to_base32(), Variant::Bech32)?)
}

fn c8_to_hex(c8_address: &str) -> eyre::Result<Address> {
    let (prefix, words, variant) = bech32::decode(c8_address)?;
    if prefix != "c8" || variant != Variant::Bech32 {
        eyre::bail!("invalid c8ntinuum prefix or encoding");
    }
    let bytes = Vec::<u8>::from_base32(&words)?;
    if bytes.len() != 20 {
        eyre::bail!("invalid account byte length");
    }
    Ok(Address::from_slice(&bytes))
}

fn main() -> eyre::Result<()> {
    let signer = PrivateKeySigner::random();
    let address = signer.address();
    let c8_address = hex_to_c8(address)?;

    let strict = Address::parse_checksummed(&address.to_checksum(None), None)?;
    let round_trip = c8_to_hex(&c8_address)?;

    println!("privateKey=0x{}", hex::encode(signer.to_bytes()));
    println!("evmAddress={}", strict.to_checksum(None));
    println!("c8Address={}", c8_address);
    println!("roundTrip={}", round_trip.to_checksum(None));

    Ok(())
}