hdwallet

func ABIEncode ¶ added in v0.2.2

func ABIEncode(name string, args []ABIValue) ([]byte, error)

ABIEncode encodes a function call: selector(name,types...) || head/tail(args). The signature is formed from name and the argument types, so name must be the bare function name (e.g. "transfer"), not the full signature.

func ABIEncodeParams ¶ added in v0.2.2

func ABIEncodeParams(values []ABIValue) ([]byte, error)

ABIEncodeParams encodes a tuple of values (no selector) using the head/tail layout. This is the encoding used for the arguments of a call and for nested tuples/arrays.

func ABIFunctionSelector ¶ added in v0.2.2

func ABIFunctionSelector(name string, types []string) []byte

ABIFunctionSelector returns the 4-byte selector for a function signature built from name and the given argument types (the canonical forms are used).

func ActivationCost ¶ added in v0.14.0

func ActivationCost(chain Chain) (*big.Int, bool)

ActivationCost returns the one-off cost charged when first funding a previously unseen account (e.g. TRX's account-creation fee). This is distinct from an ongoing reserve requirement: XLM/XRP's reserve is not a one-off fee consumed on activation but a floor the balance must stay above indefinitely, so it is modeled under MinimumBalance instead — not here.

func AddressFromPayload ¶ added in v0.10.0

func AddressFromPayload(chain Chain, payload []byte) (string, error)

AddressFromPayload derives an address for chain from a raw address payload. For EVM/secp256k1 chains: payload is the 20-byte keccak address. For Bitcoin P2PKH: payload is the 20-byte hash160 (always encodes as P2PKH). For ed25519 chains: payload is the 32-byte public key. Returns ErrUnsupportedCoin if the chain is not in the validator registry (or payload re-encoding is not implemented), or ErrInvalidAddress if the payload length does not match the expected format.

func AddressFromPublicKey ¶ added in v0.2.2

func AddressFromPublicKey(chain Chain, pub []byte) (string, error)

AddressFromPublicKey derives the address for chain directly from an external public key, reusing the registry's encoder (read-only). pub must be the curve's expected public-key form: a 33-byte compressed key for secp256k1/nist256p1, or a 32-byte key for ed25519. An unknown chain returns ErrUnsupportedCoin; a malformed key is reported by the underlying encoder.

func BroadcastPayload ¶ added in v0.11.0

func BroadcastPayload(chain Chain, out proto.Message) (string, error)

BroadcastPayload returns the RPC-ready string for submitting a signed transaction produced by (*HDWallet).SignTransaction, hiding the per-family differences in encoding and field naming behind a single accessor.

chain selects the expected output type; if the concrete type of out does not correspond to chain's transaction family, ErrTxInput is returned.

The returned value, by family:

• EVM (ETH/BNB/MATIC/… and all evmTxChains) "0x"-prefixed lowercase hex of the signed RLP (eth_sendRawTransaction).

• Bitcoin/UTXO (BTC/LTC/DOGE/DASH/BCH/ZEC/… and all utxoTxChains) Lowercase hex of the signed wire-format tx (sendrawtransaction / sendrawtx).

• Solana (SOL) Standard (padded) base64 of the signed transaction bytes, suitable for sendTransaction with encoding="base64".

• Cosmos (ATOM/OSMO/… and all cosmosTxChains; also ethermint EVMOS/INJ) Standard base64 of the TxRaw broadcast bytes (the tx_bytes field of a cosmos.tx.v1beta1.BroadcastTxRequest).

• Tron (TRX) JSON object accepted by TronGrid POST /wallet/broadcasttransaction: {"txID":"<hex>","raw_data_hex":"<hex>","signature":["<hex>"]}.

• XRP/Ripple (XRP) Uppercase hex of the signed transaction (the tx_blob parameter of the rippled submit command).

• Polkadot (DOT) "0x"-prefixed lowercase hex of the signed extrinsic, the exact form accepted by the author_submitExtrinsic RPC method.

Pure formatting over existing output fields — no re-signing, no network I/O. A nil or unrecognised out type returns ErrTxInput.

func BuildBRC20TransferBody ¶ added in v0.12.3

func BuildBRC20TransferBody(ticker, amount string) []byte

BuildBRC20TransferBody returns the canonical BRC-20 transfer JSON body. Field order is fund-critical (indexers are order-sensitive); we use fmt.Sprintf rather than json.Marshal to guarantee the exact field sequence.

func BuildBabylonOpReturn ¶ added in v0.12.3

func BuildBabylonOpReturn(stakerXonly []byte, finalityProviderXonly []byte, stakingTime uint16) []byte

BuildBabylonOpReturn builds the OP_RETURN identifier output used by the Babylon protocol to tag a staking transaction on-chain.

Format (after OP_RETURN):

"bbn\x01" (4 bytes magic + version byte 0x01)
+ version byte 0x00
+ stakerXonly (32 bytes)
+ finalityProviderXonly (32 bytes, or 32 zero bytes if nil)
+ stakingTime as 2-byte little-endian uint16

stakerXonly must be a 32-byte x-only public key. finalityProviderXonly must be a 32-byte x-only key, or nil (32 zero bytes used). Returns the full script: 0x6a (OP_RETURN) + minimal data push of the tag.

func BuildBabylonStakingOutput ¶ added in v0.12.3

func BuildBabylonStakingOutput(stakerKey []byte, covenantKeys [][]byte, covenantQuorum int, stakingTime uint16) (scriptPubKey []byte, err error)

BuildBabylonStakingOutput computes the P2TR scriptPubKey for a Babylon staking output. It assembles a tap-tree with a timelock leaf, an unbonding leaf, and a slashing leaf, rooted under the BIP-341 NUMS unspendable internal key.

• stakerKey: 33-byte compressed or 32-byte x-only public key of the staker.
• covenantKeys: one or more 33-byte compressed or 32-byte x-only covenant keys.
• covenantQuorum: the m in the m-of-n covenant multisig (1 ≤ quorum ≤ len(covenantKeys)).
• stakingTime: the CSV lockup period in blocks (uint16).

Returns the 34-byte P2TR scriptPubKey: OP_1 <32-byte output xonly>.

func BuildBabylonTimelockLeaf ¶ added in v0.12.3

func BuildBabylonTimelockLeaf(stakerXonly []byte, stakingTime uint16) []byte

BuildBabylonTimelockLeaf builds the tapscript leaf for the Babylon timelock spending path:

<staker_xonly> OP_CHECKSIGVERIFY <staking_time_LE2> OP_CSV OP_DROP OP_TRUE

stakingTime is encoded as a 2-byte little-endian uint16 (Bitcoin script number for OP_CSV). stakerXonly must be a 32-byte x-only public key.

func BuildInscriptionScript ¶ added in v0.12.3

func BuildInscriptionScript(xonlyPubkey []byte, contentType string, body []byte) ([]byte, error)

BuildInscriptionScript builds the tapscript leaf for an Ordinals inscription.

Layout:

<32-byte xonly pubkey> OP_CHECKSIG   // key-spend guard
OP_FALSE OP_IF                        // envelope open  (OP_0 = 0x00, OP_IF = 0x63)
  push("ord")                         // protocol tag
  OP_1 push(<contentType bytes>)      // content-type field
  OP_0 push(<body chunk>)             // body chunks, ≤520 bytes each
  [OP_0 push(<next chunk>) …]
OP_ENDIF                              // envelope close

xonlyPubkey must be exactly 32 bytes; returns ErrTxInput otherwise.

func BuildMultisigPSBT ¶ added in v0.11.0

func BuildMultisigPSBT(chain Chain, in *txbtc.SigningInput, redeemScript []byte) ([]byte, error)

BuildMultisigPSBT constructs an unsigned BIP-174 PSBT for spending a multisig UTXO. redeemScript is the m-of-n script produced by BuildMultisigRedeemScript (for P2SH it is also the redeemScript; for P2WSH it becomes the witnessScript). The type (P2SH or P2WSH) is inferred from each UTXO's scriptPubKey in in.

Coin selection uses the same planBitcoinTx logic as the single-key path. Fee estimation is approximate — it assumes P2SH/P2WSH per-type overhead and does not model the extra witness bytes of multisig scripts; callers should add headroom if byte-exact fees matter.

Only chains in btcAddrParams (BTC, LTC, and the native-SegWit altcoins) are accepted. Legacy P2PKH inputs in in.Utxo are rejected (same reason as the single-key PSBT path: no full prev-tx in the proto).

func BuildMultisigRedeemScript ¶ added in v0.11.0

func BuildMultisigRedeemScript(m int, pubkeys [][]byte) ([]byte, error)

BuildMultisigRedeemScript returns an OP_m <pubkeys> OP_n OP_CHECKMULTISIG script with the pubkeys sorted lexicographically (BIP-67). It is used both as the redeemScript for P2SH and as the witnessScript for P2WSH.

Constraints: 1 ≤ m ≤ n ≤ 16; every pubkey must be a 33-byte compressed point.

func BuildPSBT ¶ added in v0.6.0

func BuildPSBT(chain Chain, in *txbtc.SigningInput) ([]byte, error)

BuildPSBT builds an unsigned PSBT (BIP-174) for chain from in, returning the serialized packet. Coin selection (planBitcoinTx) chooses which UTXOs become inputs and computes the recipient/change outputs exactly as the direct signer would, so a subsequent SignPSBT/FinalizePSBT/ExtractPSBTTx produces the same transaction. Supported input types: P2WPKH, P2SH-P2WPKH, P2TR, and legacy P2PKH (via a synthetic NonWitnessUtxo using multisigFakePrevTx).

func BuildPSBTV2 ¶ added in v0.10.0

func BuildPSBTV2(chain Chain, in *txbtc.SigningInput) ([]byte, error)

BuildPSBTV2 constructs an unsigned BIP-370 PSBT for chain from in. Coin selection runs the same planBitcoinTx as the direct signer. Only segwit input types (P2WPKH, P2SH-P2WPKH, P2TR) are accepted; P2PKH returns ErrTxInput because the proto does not carry the full previous transaction.

func CPFPFee ¶ added in v0.10.0

func CPFPFee(parentFeeAlreadyPaid, parentVsize, childVsize int64, targetSatPerVbyte float64) int64

CPFPFee returns the fee a child tx must pay so that the parent+child package confirms at targetSatPerVbyte sat/vbyte. parentFeeAlreadyPaid is the fee the parent tx already included (satoshis); parentVsize and childVsize are virtual sizes in vbytes (use EstimateTxVsize). Returns 0 if the parent alone already meets or exceeds the target rate.

func CREATE2Address ¶ added in v0.10.0

func CREATE2Address(deployer []byte, salt [32]byte, initCode []byte) []byte

CREATE2Address computes the address a CREATE2 deployment will land at.

deployer — address calling CREATE2 (20 bytes)
salt     — 32-byte salt
initCode — contract init bytecode

Formula: keccak256(0xff ‖ deployer ‖ salt ‖ keccak256(initCode))[12:]

func ChecksumEthAddress ¶ added in v0.10.0

func ChecksumEthAddress(addr string) (string, error)

ChecksumEthAddress returns the EIP-55 mixed-case checksum of an Ethereum address. Input may be with or without "0x"/"0X" prefix, any case. Returns ErrInvalidAddress if the input is not a valid 20-byte hex address.

func CoinDecimals ¶ added in v0.10.0

func CoinDecimals(chain Chain) int

CoinDecimals returns the number of decimal places for the base unit of chain. Returns 0 if chain is not registered.

func CoinFamily ¶ added in v0.10.0

func CoinFamily(chain Chain) string

CoinFamily returns a string identifying the chain family for routing purposes. Values: "evm", "cosmos", "bitcoin-utxo", "solana", "tron", "ripple", "stellar", "polkadot", or "unknown".

func CombineCosmosMultisig ¶ added in v0.14.0

func CombineCosmosMultisig(threshold int, pubkeys [][]byte, in *txcosmos.SigningInput, sigs map[int][]byte) (*txcosmos.SigningOutput, error)

CombineCosmosMultisig assembles the broadcastable TxRaw from at least `threshold` partial signatures, keyed by index into pubkeys (the same ordered list used for CosmosMultisigAddress). Every partial is VERIFIED against its public key before combining (fund-critical guard). Pure function: no wallet, no secrets.

func CosmosGasLimit ¶ added in v0.10.0

func CosmosGasLimit(in *cosmos.SigningInput) uint64

CosmosGasLimit returns a conservative gas limit for the given Cosmos signing input. It sums per-message estimates; returns 80000 if no messages are present.

func CosmosMinFee ¶ added in v0.10.0

func CosmosMinFee(gasLimit uint64, minGasPrice float64, denom string) string

CosmosMinFee returns the minimum fee string (e.g. "5000uatom") for the given gas limit and minimum gas price in the chain's smallest denom unit.

func CosmosMultisigAddress ¶ added in v0.14.0

func CosmosMultisigAddress(hrp string, threshold int, pubkeys [][]byte) (string, error)

CosmosMultisigAddress returns the bech32 address of an m-of-n LegacyAminoMultisig account under hrp (e.g. "cosmos"). Key ORDER matters: the same ordered key list must be used for partial-signature indices and CombineCosmosMultisig. Pure function, no secrets.

func DecryptWIF ¶ added in v0.10.0

func DecryptWIF(encrypted string, passphrase []byte, fn func(wif []byte)) error

DecryptWIF decrypts a BIP-38 '6P…' encrypted key with passphrase. fn receives the WIF-encoded private key bytes; the slice is wiped before DecryptWIF returns. Returns ErrInvalidWIF if the passphrase is wrong.

func DustThreshold ¶ added in v0.14.0

func DustThreshold(chain Chain) (*big.Int, bool)

DustThreshold returns the standard-relay dust limit for UTXO chains (sats), reusing tx_bitcoin.go's btcDustThreshold — the same constant the signer itself uses to decide whether a change output is worth creating.

func EIP712Hash ¶ added in v0.2.2

func EIP712Hash(typedDataJSON []byte) ([]byte, error)

EIP712Hash parses MetaMask-shape typed-data JSON and returns the 32-byte keccak256 digest to sign (the 0x1901-prefixed hash).

func ERC20ApproveCalldata ¶ added in v0.10.0

func ERC20ApproveCalldata(spender []byte, amount *big.Int) []byte

ERC20ApproveCalldata builds approve(spender, amount) calldata.

func ERC20PermitCalldata ¶ added in v0.10.0

func ERC20PermitCalldata(owner, spender []byte, value, deadline *big.Int, v uint8, r, s [32]byte) []byte

ERC20PermitCalldata builds permit(owner, spender, value, deadline, v, r, s) calldata for EIP-2612.

func ERC20TransferLog ¶ added in v0.10.0

func ERC20TransferLog(log *EthLog) (from, to string, amount *big.Int, err error)

ERC20TransferLog decodes a standard ERC-20 Transfer(address,address,uint256) event log. Topics[1]=from (indexed), Topics[2]=to (indexed), Data=amount. Returns ErrTxDecode if the log does not match the Transfer event signature.

func ERC721ApproveCalldata ¶ added in v0.10.0

func ERC721ApproveCalldata(to []byte, tokenID *big.Int) []byte

ERC721ApproveCalldata builds approve(to, tokenId) calldata.

func ERC721SafeTransferCalldata ¶ added in v0.10.0

func ERC721SafeTransferCalldata(from, to []byte, tokenID *big.Int) []byte

ERC721SafeTransferCalldata builds safeTransferFrom(from, to, tokenId) calldata.

func ERC721SafeTransferWithDataCalldata ¶ added in v0.10.0

func ERC721SafeTransferWithDataCalldata(from, to []byte, tokenID *big.Int, data []byte) []byte

ERC721SafeTransferWithDataCalldata builds safeTransferFrom(from, to, tokenId, data) calldata.

func ERC721SetApprovalForAllCalldata ¶ added in v0.10.0

func ERC721SetApprovalForAllCalldata(operator []byte, approved bool) []byte

ERC721SetApprovalForAllCalldata builds setApprovalForAll(operator, approved) calldata.

func ERC721TransferCalldata ¶ added in v0.10.0

func ERC721TransferCalldata(from, to []byte, tokenID *big.Int) []byte

ERC721TransferCalldata builds transferFrom(from, to, tokenId) calldata.

func ERC721TransferLog ¶ added in v0.10.0

func ERC721TransferLog(log *EthLog) (from, to string, tokenID *big.Int, err error)

ERC721TransferLog decodes a standard ERC-721 Transfer(address,address,uint256) event log. Topics[1]=from, Topics[2]=to, Topics[3]=tokenId (all indexed). Returns ErrTxDecode if the log does not match the Transfer event signature.

func ERC1155SafeBatchTransferCalldata ¶ added in v0.10.0

func ERC1155SafeBatchTransferCalldata(from, to []byte, ids, amounts []*big.Int, data []byte) []byte

ERC1155SafeBatchTransferCalldata builds safeBatchTransferFrom(from, to, ids, amounts, data) calldata.

func ERC1155SafeTransferCalldata ¶ added in v0.10.0

func ERC1155SafeTransferCalldata(from, to []byte, id, amount *big.Int, data []byte) []byte

ERC1155SafeTransferCalldata builds safeTransferFrom(from, to, id, amount, data) calldata.

func ERC1155SetApprovalForAllCalldata ¶ added in v0.10.0

func ERC1155SetApprovalForAllCalldata(operator []byte, approved bool) []byte

ERC1155SetApprovalForAllCalldata builds setApprovalForAll(operator, approved) calldata.

func EncodeRLP ¶ added in v0.2.2

func EncodeRLP(item RLPItem) []byte

EncodeRLP encodes an RLP tree to its canonical byte serialization.

func EstimateBitcoinFee ¶ added in v0.6.0

func EstimateBitcoinFee(inputs []BitcoinInputKind, outputs []BitcoinOutputKind, satPerVbyte int64) int64

EstimateBitcoinFee returns the estimated fee (satoshis) for a transaction of the given input/output kinds at satPerVbyte sat/vbyte. It is fee-planning guidance, not a consensus value: fee = EstimateTxVsize * satPerVbyte.

func EstimateTxVsize ¶ added in v0.6.0

func EstimateTxVsize(inputs []BitcoinInputKind, outputs []BitcoinOutputKind) int64

EstimateTxVsize returns an approximate virtual size (vbytes) for a transaction spending the given input kinds to the given output kinds. It is a coarse estimate for fee planning only (not consensus-exact): per-type constants are measured against btcd's blockchain/txsizes, with a fixed overhead for the version, locktime, the input/output counts and the amortised SegWit marker/flag when any input carries a witness.

ponytail: coarse per-type constants, good enough for fee math; refine if fee-rate accuracy ever matters.

func EthGasLimit ¶ added in v0.10.0

func EthGasLimit(in *ethereum.SigningInput) uint64

EthGasLimit returns a conservative gas limit estimate for the given signing input. Native transfers return exactly 21000. Known selectors return the table value. Contract deploys and generic calls use calldata cost + headroom.

func EthereumPersonalMessageHash ¶ added in v0.2.2

func EthereumPersonalMessageHash(message []byte) []byte

EthereumPersonalMessageHash returns the 32-byte keccak256 digest that EIP-191 personal_sign signs for the given message. len(message) is rendered as its decimal ASCII representation, per the standard.

func ExtractMultisigTx ¶ added in v0.11.0

func ExtractMultisigTx(psbtBytes []byte) ([]byte, error)

ExtractMultisigTx finalizes (if needed) a signed multisig PSBT and returns the network-serialized signed transaction ready for broadcast.

func ExtractPSBTTx ¶ added in v0.6.0

func ExtractPSBTTx(psbtBytes []byte) ([]byte, error)

ExtractPSBTTx finalizes (if needed) and extracts the network-serialized signed transaction from a signed PSBT.

func ExtractPSBTV2Tx ¶ added in v0.10.0

func ExtractPSBTV2Tx(psbtBytes []byte) ([]byte, error)

ExtractPSBTV2Tx finalizes (if needed) and extracts the network-serialized signed transaction from a BIP-370 PSBT.

func FinalizeMultisigPSBT ¶ added in v0.11.0

func FinalizeMultisigPSBT(psbtBytes []byte) ([]byte, error)

FinalizeMultisigPSBT runs the BIP-174 finalizer over a signed multisig PSBT and returns the finalized packet bytes. The finalizer assembles:

• P2SH: OP_FALSE <ordered-sigs...> <redeemScript> as the scriptSig
• P2WSH: <nil> <ordered-sigs...> <witnessScript> as the witness stack

btcd's finalizer orders signatures by the position of the corresponding pubkey in the redeemScript/witnessScript (required for multisig validation). It returns an error if fewer than m signatures are present.

func FinalizePSBT ¶ added in v0.6.0

func FinalizePSBT(psbtBytes []byte) ([]byte, error)

FinalizePSBT runs the BIP-174 Finalizer over a fully signed packet and returns the finalized serialized PSBT.

func FinalizePSBTV2 ¶ added in v0.10.0

func FinalizePSBTV2(psbtBytes []byte) ([]byte, error)

FinalizePSBTV2 runs the BIP-370 finalizer over a signed packet: it moves partial signatures into the final scriptSig / witness fields.

func FormatAmount ¶ added in v0.11.0

func FormatAmount(chain Chain, raw *big.Int) (string, error)

FormatAmount converts a raw integer amount (in the coin's native smallest unit) to a human-readable decimal string using the decimal count registered for chain. It returns ErrUnsupportedCoin for an unknown chain.

This is the native-coin helper. For ERC-20, SPL, or TRC-20 tokens whose decimal count comes from the token contract, use FormatUnits directly.

Examples:

FormatAmount(BTC, big.NewInt(100_000_000)) // "1"   (1 BTC = 1e8 satoshis)
FormatAmount(ETH, big.NewInt(1_500_000_000_000_000_000)) // "1.5"

func FormatUnits ¶ added in v0.11.0

func FormatUnits(raw *big.Int, decimals uint8) string

FormatUnits converts a raw integer amount to a human-readable decimal string with the given decimal precision. It is the coin-agnostic primitive used by FormatAmount, and is the correct helper for ERC-20, SPL, and TRC-20 tokens where the decimal count is provided by the token contract's metadata rather than the native coin registry.

Trailing fractional zeros are stripped ("1.500" → "1.5"). A nil raw is treated as zero. Negative raw values are formatted with a leading "-".

Examples (decimals=18):

FormatUnits(big.NewInt(0), 18)                              // "0"
FormatUnits(big.NewInt(1_000_000_000_000_000_000), 18)      // "1"
FormatUnits(big.NewInt(1_500_000_000_000_000_000), 18)      // "1.5"
FormatUnits(big.NewInt(1), 18)                              // "0.000000000000000001"

func GenerateMnemonic ¶

func GenerateMnemonic() (string, error)

GenerateMnemonic returns a fresh 12-word BIP-39 mnemonic as a Go string.

Security note: Go strings are GC-managed and cannot be reliably wiped from memory. For security-sensitive applications (hardware wallets, HSMs) prefer GenerateMnemonicBuffer, which returns the phrase in a page-locked enclave that is wiped on Destroy. If you use this function, call FromMnemonicBytes immediately and discard the string rather than storing it.

func GenerateMnemonicBuffer ¶ added in v0.10.0

func GenerateMnemonicBuffer() (*memguard.LockedBuffer, error)

GenerateMnemonicBuffer returns a fresh 12-word BIP-39 mnemonic in a page-locked, encrypted-at-rest memguard buffer. The caller must call Destroy on the returned buffer when finished. This is the secure alternative to GenerateMnemonic for applications where the phrase must not linger on the Go heap.

func GenerateMnemonicBufferWithWordCount ¶ added in v0.10.0

func GenerateMnemonicBufferWithWordCount(words int) (*memguard.LockedBuffer, error)

GenerateMnemonicBufferWithWordCount returns a fresh BIP-39 mnemonic of the given length (12, 15, 18, 21, or 24 words) in a page-locked memguard buffer. An unsupported word count returns ErrInvalidWordCount.

func GenerateMnemonicWithWordCount ¶ added in v0.3.1

func GenerateMnemonicWithWordCount(words int) (string, error)

GenerateMnemonicWithWordCount returns a fresh BIP-39 mnemonic of the given length in words (12, 15, 18, 21, or 24) as a string. Like GenerateMnemonic, the returned string cannot be securely wiped; prefer NewHDWalletWithWordCount for sensitive use. An unsupported word count returns an error wrapping ErrInvalidWordCount.

func GetFunctionSignature ¶ added in v0.12.5

func GetFunctionSignature(fn ContractABIFunction) string

GetFunctionSignature returns the canonical signature string for a function, e.g. "transfer(address,uint256)".

func IsCosmosSDK ¶ added in v0.10.0

func IsCosmosSDK(chain Chain) bool

IsCosmosSDK returns true if chain uses the Cosmos SDK signing path.

func IsEVM ¶ added in v0.10.0

func IsEVM(chain Chain) bool

IsEVM returns true if chain is an EVM-compatible chain (Ethereum, BNB, Polygon, etc.)

func IsUTXO ¶ added in v0.10.0

func IsUTXO(chain Chain) bool

IsUTXO returns true if chain uses Bitcoin-style UTXO transaction model.

func IsValidAddress ¶ added in v0.2.2

func IsValidAddress(chain Chain, addr string) bool

IsValidAddress reports whether addr is a syntactically and checksum-valid address for the given network. It is a convenience wrapper over ValidateAddress.

func IsValidWord ¶ added in v0.11.0

func IsValidWord(word string) bool

IsValidWord reports whether word is present in the BIP-39 English wordlist.

func MinimumBalance ¶ added in v0.14.0

func MinimumBalance(chain Chain) (*big.Int, bool)

MinimumBalance returns the minimum native balance (in base units) an account must retain to exist on-chain, and whether the chain has such a constraint. Values are protocol parameters as of 2026-07-04 (sources in the package-level var comments above) and can change by governance — treat as sanity floors, not consensus data.

func MnemonicStrength ¶ added in v0.11.0

func MnemonicStrength(mnemonic string) (bits int, words int, err error)

MnemonicStrength validates mnemonic and returns its entropy size in bits and word count. It is intended for a "strength indicator" on a wallet-import screen, e.g. "128 bits · 12 words". Surrounding whitespace is trimmed before validation, exactly as the wallet constructors do.

Returns ErrInvalidMnemonic for an invalid phrase (wrong word count, unknown words, or bad checksum).

func MultisigP2SHAddress ¶ added in v0.11.0

func MultisigP2SHAddress(chain Chain, redeemScript []byte) (string, error)

MultisigP2SHAddress returns the P2SH address for redeemScript on chain. Only chains in btcAddrParams (BTC, LTC, DGB, SYS, VIA, STRAX) are supported.

func MultisigP2WSHAddress ¶ added in v0.11.0

func MultisigP2WSHAddress(chain Chain, witnessScript []byte) (string, error)

MultisigP2WSHAddress returns the native-SegWit P2WSH bech32 address for witnessScript on chain (the same script as the redeemScript — just the name changes to match BIP-141 terminology). Only chains in btcAddrParams are supported.

func NativeDecimals ¶ added in v0.11.0

func NativeDecimals(chain Chain) (uint8, bool)

NativeDecimals returns the number of fractional digits in the coin's native base unit (e.g. 8 for BTC/satoshis, 18 for ETH/wei, 6 for ATOM/uatom).

The second return value reports whether chain is a registered coin; an unregistered chain returns (0, false). This is a thin convenience wrapper over CoinInfo for callers that only need the decimal count.

func NormalizeXPub ¶ added in v0.10.0

func NormalizeXPub(extKey string) (string, error)

NormalizeXPub converts a ypub/zpub (or their testnet equivalents) to standard xpub format so it can be passed to WatchOnlyFromXPub. xpub/tpub inputs are returned unchanged. Returns an error for unrecognized prefixes.

func ParseAddress ¶ added in v0.2.2

func ParseAddress(chain Chain, addr string) ([]byte, error)

ParseAddress decodes addr for chain, verifies its checksum, and returns the decoded payload — e.g. the 20-byte hash160 for Bitcoin/Cosmos/Tron, the 32-byte public key for Solana/Stellar/SS58, or the 20/32-byte account identifier for EVM/Sui/Aptos. An unknown chain returns ErrUnsupportedCoin; an invalid address returns an error wrapping ErrInvalidAddress.

func ParseAmount ¶ added in v0.11.0

func ParseAmount(chain Chain, human string) (*big.Int, error)

ParseAmount parses a human-readable unsigned decimal string into its raw integer representation using the decimal count registered for chain. Returns ErrUnsupportedCoin for an unknown chain, ErrNegativeAmount for a negative input, and ErrInvalidAmount for a malformed string.

This is the native-coin helper. For ERC-20, SPL, or TRC-20 tokens whose decimal count comes from the token contract, use ParseUnits directly.

Examples:

ParseAmount(BTC, "0.5")  // big.Int: 50_000_000
ParseAmount(ETH, "1.5")  // big.Int: 1_500_000_000_000_000_000

func ParseUnits ¶ added in v0.11.0

func ParseUnits(human string, decimals uint8) (*big.Int, error)

ParseUnits parses a human-readable unsigned decimal string into its raw integer representation with the given decimal precision. It is the coin-agnostic primitive used by ParseAmount, and is the correct helper for ERC-20, SPL, and TRC-20 tokens where the decimal count is provided by the token contract's metadata.

Parsing rules:

• Negative values are rejected with ErrNegativeAmount.
• The fractional part must not exceed decimals digits; extra precision is rejected with ErrInvalidAmount (no silent truncation — a wrong value means lost funds).
• Non-numeric characters and multiple decimal points return ErrInvalidAmount.
• A leading dot (e.g. ".5") is accepted and treated as "0.5".

Examples (decimals=18):

ParseUnits("1",   18) // 1_000_000_000_000_000_000
ParseUnits("1.5", 18) // 1_500_000_000_000_000_000
ParseUnits("0",   18) // 0

func RecoverEthereumAddress ¶ added in v0.2.2

func RecoverEthereumAddress(message, sig []byte) (string, error)

RecoverEthereumAddress recovers the EIP-55 checksummed Ethereum address that produced sig over message under EIP-191 personal_sign. It is a convenience for callers that want the signer's address rather than a boolean match.

func SolanaComputeBudgetInstructions ¶ added in v0.10.0

func SolanaComputeBudgetInstructions(units uint32, priorityMicroLamportsPerCU uint64) [][]byte

SolanaComputeBudgetInstructions returns the serialized ComputeBudget program instructions to prepend: SetComputeUnitLimit (always) and SetComputeUnitPrice (only when priorityMicroLamportsPerCU > 0). Encoding: discriminator byte + little-endian value (no Borsh library needed).

func SolanaComputeUnits ¶ added in v0.10.0

func SolanaComputeUnits(in *solana.SigningInput) uint32

SolanaComputeUnits returns a conservative compute unit estimate for the input.

func SolanaTokenAccountAddress ¶ added in v0.14.0

func SolanaTokenAccountAddress(walletAddress, mintAddress string) (string, error)

SolanaTokenAccountAddress returns the SPL associated token account (ATA) — the canonical token account address — for a wallet address and token mint, both base58. It is a pure offline derivation: no wallet, no secrets, no network. Use it to compute deposit token accounts and withdrawal destinations for SPL tokens.

This derives against the classic SPL Token program; for a Token-2022 (Token Extensions) mint use SolanaTokenAccountAddressWithProgram.

func SolanaTokenAccountAddressWithProgram ¶ added in v0.14.0

func SolanaTokenAccountAddressWithProgram(walletAddress, mintAddress, tokenProgramID string) (string, error)

SolanaTokenAccountAddressWithProgram is SolanaTokenAccountAddress with an explicit token-program id (base58), so the ATA can be derived for the classic SPL Token program or the Token-2022 (Token Extensions) program — the seeds are [wallet, tokenProgramID, mint], and the token-program id enters the PDA derivation directly. Pure offline derivation: no wallet, no secrets, no network.

func SuggestFinalWords ¶ added in v0.11.0

func SuggestFinalWords(words []string) ([]string, error)

SuggestFinalWords takes a slice of 11, 14, 17, 20, or 23 valid BIP-39 words (the first N–1 words of a mnemonic) and returns every word from the English wordlist that, when appended, yields a valid BIP-39 checksum. Results are in wordlist (alphabetical) order.

Expected result counts per prefix length:

11 words → 12-word / 128-bit mnemonic → 128 valid completions
14 words → 15-word / 160-bit mnemonic →  64 valid completions
17 words → 18-word / 192-bit mnemonic →  32 valid completions
20 words → 21-word / 224-bit mnemonic →  16 valid completions
23 words → 24-word / 256-bit mnemonic →   8 valid completions

The function returns an error if the prefix length is not one of the values above, or if any word in words is not in the BIP-39 English wordlist.

func TransactionID ¶ added in v0.9.0

func TransactionID(out proto.Message) (string, error)

TransactionID returns one canonical transaction id for any SigningOutput produced by (*HDWallet).SignTransaction, hiding the per-family differences in field name, byte order and text encoding behind a single accessor so callers need not special-case each chain.

out must be one of the eight per-family SigningOutput messages. The id source, by family, is:

• Bitcoin (and the UTXO altcoins BTC/LTC/DOGE/DASH/BCH/ZEC) — the conventional "txid" reverse(sha256d(tx without witnesses)); from the bytes field TransactionId.
• Tron — sha256(raw_data); from the bytes field Id.
• Ethereum / EVM — keccak256(signed RLP); from the string field TxId, which the signer stores as "0x"+hex.
• Cosmos — sha256(TxRaw broadcast bytes); from the string field TxId, which the signer stores as upper-case hex.
• Ripple / XRP — sha512Half(signed tx) (SHA-512(tx)[:32]); from the string field TxId, which the signer stores as upper-case hex.
• Polkadot — BLAKE2b-256(Encoded), Substrate's standard extrinsic hash (matches the on-chain/Subscan "extrinsic hash"); computed from the bytes field Encoded.

For these five hash-based families the result is normalised to LOWER-CASE hex with NO "0x" prefix, irrespective of how the underlying field stores it. The two byte-typed ids (Bitcoin TransactionId, Tron Id) are already in display (big-endian) order and are hex-encoded as-is — no reversal is applied here.

Solana is the deliberate exception: its transaction id is NOT a hash but the base58-encoded fee-payer signature (Solana identifies a transaction by its first signature). It is returned exactly as the signer produced it — base58, unchanged — and must not be interpreted as hex.

An empty id, or any message that is not one of the eight recognised SigningOutput types (including a nil proto.Message), returns ErrNoTxID. The helper reads only the public output and touches no secret material.

func TronBandwidth ¶ added in v0.10.0

func TronBandwidth(_ *tron.SigningInput) int64

TronBandwidth returns the estimated bandwidth for a Tron signing input. All transactions consume at least 268 bandwidth units.

func TronEnergy ¶ added in v0.10.0

func TronEnergy(in *tron.SigningInput) int64

TronEnergy returns the estimated energy for a Tron signing input. Returns 0 for non-contract transactions; 65000 for TRC-20 transfers; 100000 for generic smart contract calls.

func UserOperationHash ¶ added in v0.10.0

func UserOperationHash(op *UserOperation, entryPoint []byte, chainID *big.Int) []byte

UserOperationHash computes the ERC-4337 v0.6 userOp hash (the value to sign).

Inner hash: keccak256(abi.encode(sender, nonce, keccak256(initCode), keccak256(callData), callGasLimit, verificationGasLimit, preVerificationGas, maxFeePerGas, maxPriorityFeePerGas, keccak256(paymasterAndData)))

Outer hash: keccak256(abi.encode(innerHash, entryPoint, chainID))

func ValidateAddress ¶ added in v0.2.2

func ValidateAddress(chain Chain, addr string) error

ValidateAddress returns nil if addr is a valid address for chain, or a descriptive error wrapping ErrInvalidAddress (bad checksum, wrong prefix, wrong length, …) or ErrUnsupportedCoin for an unknown chain.

func ValidateMnemonic ¶ added in v0.9.0

func ValidateMnemonic(mnemonic string) error

ValidateMnemonic reports whether mnemonic is a valid BIP-39 seed phrase. It returns nil if the phrase is valid and ErrInvalidMnemonic otherwise, applying the same wordlist, word-count, and checksum checks FromMnemonic does — but without constructing a wallet or retaining the phrase, so an import UI can validate user input before building anything. Surrounding whitespace is trimmed first, exactly as the constructors do.

func ValidateMnemonicBytes ¶ added in v0.9.0

func ValidateMnemonicBytes(mnemonic []byte) error

ValidateMnemonicBytes is ValidateMnemonic for a mnemonic held in a byte slice, mirroring the FromMnemonic/FromMnemonicBytes string/bytes pairing. Unlike the constructors it neither wipes nor modifies the slice: this is a read-only validity check, not a wallet entry point.

func ValidateSigningInput ¶ added in v0.10.0

func ValidateSigningInput(chain Chain, input proto.Message) error

ValidateSigningInput performs a quick sanity check on the signing input for chain. Returns ErrTxInput with a descriptive message if a required field appears missing. This does NOT validate chain-level correctness (nonce sequence, balance) — only that structurally required proto fields are non-zero.

func Verify ¶ added in v0.2.0

func Verify(curve Curve, pub, data []byte, sig *Signature) bool

Verify reports whether sig is a valid signature of data by the public key pub on the given curve. For ECDSA curves data is the 32-byte digest that was signed; for ed25519 it is the message.

func VerifyBitcoinMessage ¶ added in v0.3.1

func VerifyBitcoinMessage(address string, message []byte, sigBase64 string) bool

VerifyBitcoinMessage reports whether sigBase64 is a valid Bitcoin signed-message signature of message by the key behind a legacy P2PKH (base58check, "1"-prefix) address. It recovers the public key from the compact signature and checks its legacy address equals address.

func VerifyCosmosADR36 ¶ added in v0.11.0

func VerifyCosmosADR36(signer string, data []byte, sigBase64 string) bool

VerifyCosmosADR36 reports whether sigBase64 is a valid ADR-36 signature of data by the key behind the bech32 signer address. sigBase64 must be a base64-encoded 65-byte R‖S‖V signature (V ∈ {0,1}) as returned by SignCosmosADR36. It recovers the public key from the signature and checks that its bech32 Cosmos address (same HRP as signer) equals signer.

func VerifyEthereumMessage ¶ added in v0.2.2

func VerifyEthereumMessage(addressOrPubKey string, message, sig []byte) bool

VerifyEthereumMessage reports whether sig (65-byte r||s||v, v in {27,28} or {0,1}) is a valid EIP-191 personal_sign signature of message by the signer identified by addressOrPubKey. addressOrPubKey may be a 0x-hex Ethereum address (20 bytes), or a hex/raw secp256k1 public key (33-byte compressed or 65-byte uncompressed). It ecrecovers the signer and compares.

func VerifyEthereumTypedData ¶ added in v0.2.2

func VerifyEthereumTypedData(addressOrPubKey string, typedDataJSON, sig []byte) bool

VerifyEthereumTypedData is the EIP-712 counterpart of VerifyEthereumMessage.

func VerifyRawMessage ¶ added in v0.11.0

func VerifyRawMessage(chain Chain, pub, message []byte, sig *Signature) (bool, error)

VerifyRawMessage reports whether sig is a valid raw signature of message by the public key pub for the coin chain. It is the Chain-keyed counterpart to SignRawMessage and wraps VerifySignature.

As with SignRawMessage, message is the 32-byte digest for ECDSA chains and the raw message for ed25519 chains. An unknown chain returns a wrapped ErrUnsupportedCoin; a non-32-byte input for an ECDSA chain returns a wrapped ErrInvalidDigest. It needs no secret and is a free function.

func VerifySignature ¶ added in v0.8.0

func VerifySignature(chain Chain, pub, data []byte, sig *Signature) (bool, error)

VerifySignature reports whether sig is a valid signature of data by the public key pub for the coin chain. It is the Chain-keyed counterpart to Sign: the curve is resolved from the registry rather than supplied directly.

As with Sign/SignIndex, data is the 32-byte digest for ECDSA chains (secp256k1) and the raw message for ed25519 chains. A non-32-byte input for an ECDSA chain returns a wrapped ErrInvalidDigest, mirroring SignIndex; an unknown chain returns a wrapped ErrUnsupportedCoin.

It needs no secret and so is a free function, not a wallet method.

func VerifySolanaMessage ¶ added in v0.3.1

func VerifySolanaMessage(address string, message []byte, sigBase58 string) bool

VerifySolanaMessage reports whether sigBase58 is a valid Solana off-chain message signature for message under the given base58 account address (which is itself the 32-byte ed25519 public key).

func VerifyTronMessage ¶ added in v0.11.0

func VerifyTronMessage(tronAddr string, message []byte, sigHex string) bool

VerifyTronMessage reports whether sigHex is a valid Tron TIP-191 signature of message by the key behind tronAddr. sigHex is the hex-encoded 65-byte signature (with or without the "0x" prefix) where the last byte V ∈ {27, 28}.

It recovers the secp256k1 public key from the signature and derives the Tron address (keccak256(uncompressed[1:])[12:], version 0x41, base58check) to compare against tronAddr.

func WordlistPrefix ¶ added in v0.11.0

func WordlistPrefix(prefix string) []string

WordlistPrefix returns up to [wordlistMaxResults] BIP-39 English words that begin with prefix, in alphabetical (wordlist) order. It is designed for wallet-entry autocomplete: call it on every keystroke and display the results as suggestions.

An empty prefix returns the first [wordlistMaxResults] words of the wordlist. A prefix with no matches returns a nil slice.