outscript

package module
v0.3.24 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 28, 2026 License: MIT Imports: 28 Imported by: 0

README

outscript

Generate potential outscripts for a given public key.

Documentation

Overview

Package outscript generates potential output scripts for a given public key.

It supports Bitcoin and Bitcoin-like cryptocurrency output script formats (P2PKH, P2SH, P2WPKH, P2WSH, P2PK, P2TR, etc.), EVM-based networks (Ethereum and compatible chains), and other blockchains such as Litecoin, Dogecoin, Namecoin, Monacoin, Electraproto, Dash, Bitcoin Cash, and Massa.

The package also provides transaction building and signing for both Bitcoin-style (with segwit witness data) and EVM transactions, as well as block reward calculations for various cryptocurrency networks.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// Formats maps script format names (e.g. "p2pkh", "p2wpkh", "eth") to their
	// corresponding [Format] definitions.
	Formats = map[string]Format{
		"p2pkh":  Format{Bytes{0x76, 0xa9}, IPushBytes{IHash160(Lookup("pubkey:comp"))}, Bytes{0x88, 0xac}},
		"p2pukh": Format{Bytes{0x76, 0xa9}, IPushBytes{IHash160(Lookup("pubkey:uncomp"))}, Bytes{0x88, 0xac}},
		"p2pk":   Format{IPushBytes{Lookup("pubkey:comp")}, Bytes{0xac}},
		"p2puk":  Format{IPushBytes{Lookup("pubkey:uncomp")}, Bytes{0xac}},
		"p2wpkh": Format{Bytes{0}, IPushBytes{IHash160(Lookup("pubkey:comp"))}},

		"p2sh:p2pkh":  Format{Bytes{0xa9}, IPushBytes{IHash160(Lookup("p2pkh"))}, Bytes{0x87}},
		"p2sh:p2pukh": Format{Bytes{0xa9}, IPushBytes{IHash160(Lookup("p2pukh"))}, Bytes{0x87}},
		"p2sh:p2pk":   Format{Bytes{0xa9}, IPushBytes{IHash160(Lookup("p2pk"))}, Bytes{0x87}},
		"p2sh:p2puk":  Format{Bytes{0xa9}, IPushBytes{IHash160(Lookup("p2puk"))}, Bytes{0x87}},
		"p2sh:p2wpkh": Format{Bytes{0xa9}, IPushBytes{IHash160(Lookup("p2wpkh"))}, Bytes{0x87}},

		"p2wsh:p2pkh":  Format{Bytes{0}, IPushBytes{IHash(Lookup("p2pkh"), sha256.New)}},
		"p2wsh:p2pukh": Format{Bytes{0}, IPushBytes{IHash(Lookup("p2pukh"), sha256.New)}},
		"p2wsh:p2pk":   Format{Bytes{0}, IPushBytes{IHash(Lookup("p2pk"), sha256.New)}},
		"p2wsh:p2puk":  Format{Bytes{0}, IPushBytes{IHash(Lookup("p2puk"), sha256.New)}},
		"p2wsh:p2wpkh": Format{Bytes{0}, IPushBytes{IHash(Lookup("p2wpkh"), sha256.New)}},

		"eth": Format{IHash(Lookup("pubkey:uncomp"), newEtherHash)},

		"massa_pubkey": Format{Bytes{0}, Lookup("pubkey:ed25519")},
		"massa":        Format{Bytes{0, 0}, IHash(Lookup("massa_pubkey"), newMassaHash)},
	}

	// FormatsPerNetwork is a table listing the typically available formats for each network
	FormatsPerNetwork = map[string][]string{
		"bitcoin":      []string{"p2wpkh", "p2sh:p2wpkh", "p2puk", "p2pk", "p2pukh", "p2pkh"},
		"bitcoin-cash": []string{"p2puk", "p2pk", "p2pukh", "p2pkh"},
		"litecoin":     []string{"p2wpkh", "p2sh:p2wpkh", "p2puk", "p2pk", "p2pukh", "p2pkh"},
		"dogecoin":     []string{"p2puk", "p2pk", "p2pukh", "p2pkh"},
		"evm":          []string{"eth"},
		"massa":        []string{"massa"},
	}
)

Functions

func BlockReward added in v0.3.10 

func BlockReward(network string, blockHeight uint64) (*big.Int, error)

BlockReward returns the block reward at the given blockHeight for the specified network, reading from chainConfigs.

func CumulativeReward added in v0.3.11 

func CumulativeReward(network string, blockHeight uint64) (*big.Int, error)

CumulativeReward returns the total minted coins from block 0 through blockHeight (inclusive) for the specified network.

func EvmCall added in v0.2.7 

func EvmCall(method string, params ...any) ([]byte, error)

EvmCall generates calldata for a given EVM call, performing absolutely no check on the provided parameters as to whether these match the ABI or not.

func GuessPubKeyAndHashByInScript added in v0.3.15 

func GuessPubKeyAndHashByInScript(scriptBytes []byte) (foundPubKey []byte, foundPubKeyHash []byte)

GuessPubKeyAndHashByInScript will attempt to guess the pubkey hash (address component) and possibly the pubkey from an input script.

func GuessPubKeyAndHashByOutScript added in v0.3.15 

func GuessPubKeyAndHashByOutScript(scriptBytes []byte) (foundPubKey []byte, foundPubKeyHash []byte)

GuessPubKeyAndHashByOutScript will attempt to guess the pubkey hash (address component) and possibly the pubkey from a output script.

func ParsePushBytes added in v0.3.15 

func ParsePushBytes(v []byte) ([]byte, int)

ParsePushBytes decodes a Bitcoin script push operation at the start of v, returning the pushed data and the total number of bytes consumed. It returns (nil, 0) on error.

func PushBytes added in v0.3.15 

func PushBytes(v []byte) []byte

PushBytes encodes a byte slice as a Bitcoin script push operation, choosing the appropriate opcode (direct push for <=75 bytes, OP_PUSHDATA1/2/4 for larger data).

Types

type AbiBuffer added in v0.2.7 

type AbiBuffer struct {
	// contains filtered or unexported fields
}

AbiBuffer is a builder for EVM ABI-encoded data. It supports encoding uint256, address, bytes, and string types, as well as generating method call data with the 4-byte function selector.

func NewAbiBuffer added in v0.2.7 

func NewAbiBuffer(buf []byte) *AbiBuffer

NewAbiBuffer returns a new AbiBuffer initialized with the given byte slice.

func (*AbiBuffer) AppendAddressAny added in v0.2.7 

func (buf *AbiBuffer) AppendAddressAny(v any) error

AppendAddressAny appends a value as an ABI address parameter.

func (*AbiBuffer) AppendBigInt added in v0.2.7 

func (buf *AbiBuffer) AppendBigInt(v *big.Int) error

AppendBigInt appends a big.Int value to the buffer

func (*AbiBuffer) AppendBufferAny added in v0.2.7 

func (buf *AbiBuffer) AppendBufferAny(v any) error

AppendBufferAny appends a value as an ABI bytes/string parameter. Supported Go types are []byte and string.

func (*AbiBuffer) AppendBytes added in v0.2.7 

func (buf *AbiBuffer) AppendBytes(v []byte)

AppendBytes adds a byte buffer as parameter (which will be actually an offset to a later area)

func (*AbiBuffer) AppendUint256Any added in v0.2.7 

func (buf *AbiBuffer) AppendUint256Any(v any) error

AppendUint256Any appends a value as a uint256-style ABI parameter. Supported Go types are bool, int, and *big.Int.

func (*AbiBuffer) Bytes added in v0.2.7 

func (buf *AbiBuffer) Bytes() []byte

Bytes will return the encoded ABI buffer

func (*AbiBuffer) Call added in v0.2.7 

func (buf *AbiBuffer) Call(method string) []byte

Call returns a EVM abi-encoded method call

func (*AbiBuffer) EncodeAbi added in v0.2.7 

func (buf *AbiBuffer) EncodeAbi(abi string, params ...any) error

EncodeAbi takes as first parameter an abi such as "transfer(address,uint256)" and a matching number of parameters.

func (*AbiBuffer) EncodeAuto added in v0.2.7 

func (buf *AbiBuffer) EncodeAuto(params ...any) error

EncodeAuto will encode a bunch of any values into whatever makes sense for the format they are. *big.Int will become uint256, *Script will become addresses, strings and []byte becomes bytes.

Non-compact format is fairly simple since all numeric values are uint256 (including addresses), and only strings/byte arrays are offsets to the end of the buffer where these are stored as length+data+padding

func (*AbiBuffer) EncodeTypes added in v0.2.7 

func (buf *AbiBuffer) EncodeTypes(types []string, params ...any) error

EncodeTypes encodes the given parameters according to the specified ABI type strings. Supported types are "uint", "uint8"..."uint256", "bytes4", "bytes32", "address", "bytes", and "string".

type BtcAmount added in v0.3.18 

type BtcAmount uint64

BtcAmount represents a Bitcoin amount in satoshis (1 BTC = 100,000,000 satoshis). It marshals to JSON as a decimal string with 8 decimal places and supports unmarshaling from decimal strings, integers, and hex-encoded values.

func (BtcAmount) MarshalJSON added in v0.3.18 

func (b BtcAmount) MarshalJSON() ([]byte, error)

MarshalJSON encodes the amount as a JSON number with 8 decimal places (e.g. "1.00000000").

func (*BtcAmount) UnmarshalJSON added in v0.3.18 

func (ba *BtcAmount) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes a JSON number or quoted string into a BtcAmount.

func (*BtcAmount) UnmarshalText added in v0.3.22 

func (ba *BtcAmount) UnmarshalText(b []byte) error

UnmarshalText decodes a text representation into a BtcAmount. It accepts decimal strings (e.g. "1.5"), integer strings (e.g. "100000000"), and hex-prefixed strings (e.g. "0x5f5e100").

type BtcTx added in v0.2.1 

type BtcTx struct {
	Version  uint32         `json:"version"`
	In       []*BtcTxInput  `json:"vin"`
	Out      []*BtcTxOutput `json:"vout"`
	Locktime uint32         `json:"locktime"`
}

BtcTx represents a Bitcoin transaction including its inputs, outputs, and witness data.

func (*BtcTx) AddNetOutput added in v0.2.24 

func (tx *BtcTx) AddNetOutput(network, address string, amount uint64) error

AddNetOutput adds the specified address as an output to the transaction. The address will be parsed for the given network and an error will be returned if the address is not valid. Passing "auto" as network name disables all checks and it is up to the caller to confirm the address and resulting output is valid first.

func (*BtcTx) AddOutput added in v0.2.7 

func (tx *BtcTx) AddOutput(address string, amount uint64) error

AddOutput adds the specified address as an output to the transaction. Note that this will not check if the output is valid for a given network, this is up to the caller to confirm things first.

func (*BtcTx) Bytes added in v0.2.1 

func (tx *BtcTx) Bytes() []byte

Bytes returns the serialized transaction, including witness data if present.

func (*BtcTx) ClearInputs added in v0.2.1 

func (tx *BtcTx) ClearInputs()

ClearInputs removes all the input scripts and witnesses from the transaction. Used during signing.

func (*BtcTx) ComputeSize added in v0.2.16 

func (tx *BtcTx) ComputeSize() int

EstimateSize computes the transaction size, taking into account specific rules for segwit.

func (*BtcTx) Dup added in v0.2.1 

func (tx *BtcTx) Dup() *BtcTx

Dup duplicates a transaction and its inputs/outputs

func (*BtcTx) HasWitness added in v0.2.1 

func (tx *BtcTx) HasWitness() bool

HasWitness reports whether any input in the transaction has witness data.

func (*BtcTx) Hash added in v0.2.5 

func (tx *BtcTx) Hash() ([]byte, error)

Hash computes the double SHA-256 transaction hash (txid) in the standard reversed byte order.

func (*BtcTx) MarshalBinary added in v0.2.4 

func (tx *BtcTx) MarshalBinary() ([]byte, error)

MarshalBinary implements encoding.BinaryMarshaler and returns the serialized transaction bytes.

func (*BtcTx) ReadFrom added in v0.2.1 

func (tx *BtcTx) ReadFrom(r io.Reader) (int64, error)

ReadFrom reads and parses a Bitcoin transaction from r, including segwit witness data if present.

func (*BtcTx) Sign added in v0.2.1 

func (tx *BtcTx) Sign(keys ...*BtcTxSign) error

Sign will perform signature on the transaction

func (*BtcTx) UnmarshalBinary added in v0.2.4 

func (tx *BtcTx) UnmarshalBinary(buf []byte) error

UnmarshalBinary implements encoding.BinaryUnmarshaler and parses a serialized transaction.

type BtcTxInput added in v0.2.1 

type BtcTxInput struct {
	TXID      Hex32
	Vout      uint32
	Script    []byte
	Sequence  uint32
	Witnesses [][]byte
}

BtcTxInput represents a single input in a Bitcoin transaction.

func (*BtcTxInput) Bytes added in v0.2.1 

func (in *BtcTxInput) Bytes() []byte

Bytes serializes the input into its binary representation (txid + vout + script + sequence).

func (*BtcTxInput) Dup added in v0.2.1 

func (in *BtcTxInput) Dup() *BtcTxInput

Dup returns a deep copy of the BtcTxInput.

func (*BtcTxInput) MarshalJSON added in v0.2.10 

func (in *BtcTxInput) MarshalJSON() ([]byte, error)

MarshalJSON encodes the transaction input as JSON with hex-encoded script and witness data.

func (*BtcTxInput) Prefill added in v0.2.16 

func (in *BtcTxInput) Prefill(scheme string) error

Prefill will fill the transaction input with empty data matching the expected signature length for the given scheme, if supported

func (*BtcTxInput) ReadFrom added in v0.2.1 

func (in *BtcTxInput) ReadFrom(r io.Reader) (int64, error)

ReadFrom reads and parses a transaction input from r.

type BtcTxOutput added in v0.2.1 

type BtcTxOutput struct {
	Amount BtcAmount
	N      int // not stored
	Script []byte
}

BtcTxOutput represents a single output in a Bitcoin transaction.

func (*BtcTxOutput) Bytes added in v0.2.1 

func (out *BtcTxOutput) Bytes() []byte

Bytes serializes the output into its binary representation (amount + script).

func (*BtcTxOutput) Dup added in v0.2.1 

func (out *BtcTxOutput) Dup() *BtcTxOutput

Dup returns a copy of the BtcTxOutput object; used for transaction signing.

func (*BtcTxOutput) MarshalJSON added in v0.2.10 

func (out *BtcTxOutput) MarshalJSON() ([]byte, error)

MarshalJSON encodes the transaction output as JSON.

func (*BtcTxOutput) ReadFrom added in v0.2.1 

func (out *BtcTxOutput) ReadFrom(r io.Reader) (int64, error)

ReadFrom parses a transaction output from the provided reader.

func (*BtcTxOutput) UnmarshalJSON added in v0.3.13 

func (out *BtcTxOutput) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes a JSON representation into a BtcTxOutput.

type BtcTxSign added in v0.2.1 

type BtcTxSign struct {
	Key     crypto.Signer
	Options crypto.SignerOpts
	Scheme  string    // "p2pk", "p2wpkh", "p2wsh:p2pkh", etc
	Amount  BtcAmount // value of input, required for segwit transaction signing
	SigHash uint32
}

BtcTxSign holds the signing parameters for a single transaction input.

type BtcVarInt added in v0.2.1 

type BtcVarInt uint64

BtcVarInt is a Bitcoin variable-length integer as defined in the Bitcoin protocol. Values 0-0xfc are stored as a single byte; larger values use a prefix byte (0xfd, 0xfe, or 0xff) followed by 2, 4, or 8 bytes respectively in little-endian order.

func (BtcVarInt) Bytes added in v0.2.1 

func (v BtcVarInt) Bytes() []byte

Bytes returns the encoded variable-length integer as a byte slice.

func (BtcVarInt) Len added in v0.2.16 

func (v BtcVarInt) Len() int

Len returns the number of bytes needed to encode this variable-length integer.

func (*BtcVarInt) ReadFrom added in v0.2.1 

func (v *BtcVarInt) ReadFrom(r io.Reader) (int64, error)

ReadFrom reads a variable-length integer from r.

func (BtcVarInt) WriteTo added in v0.2.1 

func (v BtcVarInt) WriteTo(w io.Writer) (int64, error)

WriteTo writes the encoded variable-length integer to w.

type Bytes added in v0.2.0 

type Bytes []byte

Bytes is an Insertable that returns a fixed byte sequence.

func (Bytes) Bytes added in v0.2.0 

func (b Bytes) Bytes(*Script) ([]byte, error)

func (Bytes) String added in v0.2.0 

func (b Bytes) String() string

type EvmTx added in v0.2.0 

type EvmTx struct {
	Nonce      uint64
	GasTipCap  *big.Int // a.k.a. maxPriorityFeePerGas
	GasFeeCap  *big.Int // a.k.a. maxFeePerGas, correspond to GasFee if tx type is legacy or eip2930
	Gas        uint64   // gas of tx, can be obtained with eth_estimateGas, 21000 if Data is empty
	To         string
	Value      *big.Int
	Data       []byte
	ChainId    uint64    // in legacy tx, chainId is encoded in v before signature
	Type       EvmTxType // type of transaction: legacy, eip2930 or eip1559
	AccessList []any     // TODO
	Signed     bool
	Y, R, S    *big.Int
}

EvmTx represents an Ethereum Virtual Machine transaction. It supports legacy, EIP-2930, EIP-1559, and EIP-4844 transaction types, and can be signed, serialized, parsed, and converted to/from JSON.

func (*EvmTx) Call added in v0.2.7 

func (tx *EvmTx) Call(method string, params ...any) error

Call sets the transaction's Data field to the ABI-encoded method call for the given method signature and parameters.

func (*EvmTx) Hash added in v0.2.5 

func (tx *EvmTx) Hash() ([]byte, error)

Hash returns the Keccak-256 hash of the signed transaction's binary encoding.

func (*EvmTx) MarshalBinary added in v0.2.4 

func (tx *EvmTx) MarshalBinary() ([]byte, error)

MarshalBinary transforms the transaction into its binary representation

func (*EvmTx) MarshalJSON added in v0.2.4 

func (tx *EvmTx) MarshalJSON() ([]byte, error)

MarshalJSON encodes the transaction as a JSON object with hex-encoded numeric fields.

func (*EvmTx) ParseTransaction added in v0.2.0 

func (tx *EvmTx) ParseTransaction(buf []byte) error

ParseTransaction will parse an incoming transaction and return an error in case of failure. In case of error, the state of tx is undefined.

func (*EvmTx) RlpFields added in v0.2.0 

func (tx *EvmTx) RlpFields() []any

RlpFields returns the Rlp fields for the given transaction, less the signature fields

func (*EvmTx) SenderAddress added in v0.2.0 

func (tx *EvmTx) SenderAddress() (string, error)

SenderAddress recovers and returns the EIP-55 checksummed sender address from the transaction signature.

func (*EvmTx) SenderPubkey added in v0.2.0 

func (tx *EvmTx) SenderPubkey() (*secp256k1.PublicKey, error)

SenderPubkey recovers the sender's public key from the transaction signature.

func (*EvmTx) Sign added in v0.2.2 

func (tx *EvmTx) Sign(key crypto.Signer) error

Sign signs the transaction using the given key with default signer options.

func (*EvmTx) SignBytes added in v0.2.0 

func (tx *EvmTx) SignBytes() ([]byte, error)

SignBytes returns the bytes used to sign the transaction

func (*EvmTx) SignWithOptions added in v0.2.19 

func (tx *EvmTx) SignWithOptions(key crypto.Signer, opts crypto.SignerOpts) error

SignWithOptions signs the transaction using the given key and signer options.

func (*EvmTx) Signature added in v0.2.0 

func (tx *EvmTx) Signature() (*secp256k1.Signature, error)

Signature returns the parsed secp256k1 signature from the signed transaction.

func (*EvmTx) UnmarshalBinary added in v0.2.4 

func (tx *EvmTx) UnmarshalBinary(buf []byte) error

UnmarshalBinary implements encoding.BinaryUnmarshaler

func (*EvmTx) UnmarshalJSON added in v0.2.8 

func (tx *EvmTx) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes a JSON representation into an EvmTx.

type EvmTxType added in v0.2.0 

type EvmTxType int

EvmTxType represents the type of EVM transaction encoding. 

const (
	EvmTxLegacy  EvmTxType = iota // Legacy (pre-EIP-2718) transaction
	EvmTxEIP2930                  // EIP-2930 access list transaction
	EvmTxEIP1559                  // EIP-1559 dynamic fee transaction
	EvmTxEIP4844                  // EIP-4844 blob transaction
)

type Format added in v0.2.0 

type Format []Insertable

Format is a sequence of Insertable values that together define how an output script is constructed from a public key.

type Hex32 added in v0.3.5 

type Hex32 [32]byte

Hex32 is a 32-byte array that marshals to and from a hex-encoded JSON string.

func (Hex32) MarshalJSON added in v0.3.5 

func (h Hex32) MarshalJSON() ([]byte, error)

MarshalJSON encodes the 32-byte value as a hex string.

func (Hex32) UnmarshalJSON added in v0.3.5 

func (h Hex32) UnmarshalJSON(v []byte) error

UnmarshalJSON decodes a hex string into the 32-byte value.

type IHashInfo added in v0.2.0 

type IHashInfo struct {
	// contains filtered or unexported fields
}

IHashInfo is an Insertable that hashes the output of another Insertable using one or more chained hash functions.

func IHash added in v0.2.0 

func IHash(v Insertable, hash ...func() hash.Hash) IHashInfo

IHash returns an IHashInfo that hashes the output of v using the given hash functions in sequence.

func IHash160 added in v0.2.0 

func IHash160(v Insertable) IHashInfo

IHash160 returns an IHashInfo that computes HASH160 (SHA-256 followed by RIPEMD-160) of the output of v.

func (IHashInfo) Bytes added in v0.2.0 

func (i IHashInfo) Bytes(s *Script) ([]byte, error)

func (IHashInfo) String added in v0.2.0 

func (i IHashInfo) String() string

type IPushBytes added in v0.2.0 

type IPushBytes struct {
	// contains filtered or unexported fields
}

IPushBytes is an Insertable that encodes the output of another Insertable as a Bitcoin script push operation.

func (IPushBytes) Bytes added in v0.2.0 

func (i IPushBytes) Bytes(s *Script) ([]byte, error)

func (IPushBytes) String added in v0.2.0 

func (i IPushBytes) String() string

type Insertable added in v0.2.0 

type Insertable interface {
	Bytes(*Script) ([]byte, error)
	String() string
}

Insertable is a component that can produce bytes for inclusion in an output script. Implementations include literal Bytes, Lookup references to other formats, IPushBytes for Bitcoin PUSHDATA encoding, and IHashInfo for hashing.

type Lookup added in v0.2.0 

type Lookup string

Lookup is an Insertable that generates bytes by looking up another named format via Script.Generate.

func (Lookup) Bytes added in v0.2.0 

func (l Lookup) Bytes(s *Script) ([]byte, error)

func (Lookup) String added in v0.2.0 

func (l Lookup) String() string

type Out added in v0.1.2 

type Out struct {
	Name   string   `json:"name"`            // p2sh, etc
	Script string   `json:"script"`          // out script
	Flags  []string `json:"flags,omitempty"` // flags
	// contains filtered or unexported fields
}

Out represents a generated output script with its format name, hex-encoded script, and optional flags indicating the target network(s).

func GetOuts added in v0.1.2 

func GetOuts(pubkey crypto.PublicKey) []*Out

GetOuts returns the potential outputs that can be opened in theory with the given pubkey. p2w* values are "pay to segwit" and can only be used on segwit-enabled chains.

func GuessOut added in v0.2.11 

func GuessOut(script []byte, pubkeyhint crypto.PublicKey) *Out

GuessOut will return a out matching the provided script, and attempt to guess the correct type. pubkeyhint can be nil and this function will still be useful, but it won't be able to differenciate between compressed and uncompressed keys if the script contains a hashed key

func ParseBitcoinAddress deprecated added in v0.2.6 

func ParseBitcoinAddress(address string) (*Out, error)

ParseBitcoinAddress parses an address in bitcoin format and returns the matching script, accepting also other networks addresses (in which cash a flag will be set)

Deprecated: use ParseBitcoinBasedAddress instead

func ParseBitcoinBasedAddress added in v0.2.23 

func ParseBitcoinBasedAddress(network, address string) (*Out, error)

ParseBitcoinBasedAddress parses an address in bitcoin format and returns the matching script, for the specified network. The special value "auto" for network will attempt to detect the network.

func ParseEvmAddress added in v0.2.6 

func ParseEvmAddress(address string) (*Out, error)

ParseEvmAddress parses an address to return an Out, supporting EVM-based networks.

func ParseMassaAddress added in v0.3.1 

func ParseMassaAddress(address string) (*Out, error)

ParseMassaAddress parses a Massa network address (starting with "AU" for user accounts or "AS" for smart contracts) and returns the corresponding Out.

func (*Out) Address added in v0.2.6 

func (out *Out) Address(flags ...string) (string, error)

Address returns an address matching the provided out. Flags will be used for hints if multiple addresses are possible.

func (*Out) Bytes added in v0.1.4 

func (o *Out) Bytes() []byte

Bytes returns the raw output script bytes.

func (*Out) Hash added in v0.2.25 

func (o *Out) Hash() []byte

Hash will extract the hash part of the Out, or return nil if there is no known hash

func (*Out) String added in v0.2.0 

func (o *Out) String() string

String returns a human-readable representation of the Out in "name:script" format.

type Script added in v0.2.0 

type Script struct {
	// contains filtered or unexported fields
}

Script holds a public key and caches generated output scripts for various formats.

func New added in v0.2.0 

func New(pubkey crypto.PublicKey) *Script

New returns a new Script object for the given public key, which can be used to generate output scripts

func (*Script) Address added in v0.3.2 

func (s *Script) Address(script string, flags ...string) (string, error)

Address formats the key using the specified script (eg. p2sh, etc) and optional flags hints. You can do things like Address("eth") where no hint is needed, or things like Address("p2pkh", "litecoin") so the appropriate format is used.

func (*Script) Generate added in v0.2.0 

func (s *Script) Generate(name string) ([]byte, error)

Generate will return the byte value for the specified script type for the current public key

func (*Script) Out added in v0.2.0 

func (s *Script) Out(name string) (*Out, error)

Out returns a Out object matching the requested script

type Transaction added in v0.2.4 

type Transaction interface {
	encoding.BinaryMarshaler
	encoding.BinaryUnmarshaler
	Hash() ([]byte, error)
}

Transaction is the common interface for cryptocurrency transactions that can be serialized to binary and produce a hash.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.