typeddata

package

v1.3.21 Latest Latest Go to latest Published: Feb 20, 2024 License: MIT Imports: 18 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/router-protocol/sdk-go

Links

Open Source Insights

Documentation ¶

Index ¶

Variables
func ComputeTypedDataHash(typedData TypedData) ([]byte, error)
func SignTextValidator(validatorData ValidatorData) (hexutil.Bytes, string)
type NameValueType
- func (nvt *NameValueType) Pprint(depth int) string
type SigFormat
type Type
type TypePriority
type TypedData
type TypedDataDomain
- func (domain *TypedDataDomain) Map() map[string]interface{}
type TypedDataMessage
type Types
type ValidatorData
- func UnmarshalValidatorData(data interface{}) (ValidatorData, error)

Constants ¶

This section is empty.

Variables ¶

View Source

var (
	IntendedValidator = SigFormat{
		accounts.MimetypeDataWithValidator,
		0x00,
	}
	DataTyped = SigFormat{
		accounts.MimetypeTypedData,
		0x01,
	}
	ApplicationClique = SigFormat{
		accounts.MimetypeClique,
		0x02,
	}
	TextPlain = SigFormat{
		accounts.MimetypeTextPlain,
		0x45,
	}
)

Functions ¶

func ComputeTypedDataHash ¶

func ComputeTypedDataHash(typedData TypedData) ([]byte, error)

ComputeTypedDataHash computes keccak hash of typed data for signing.

func SignTextValidator ¶

func SignTextValidator(validatorData ValidatorData) (hexutil.Bytes, string)

SignTextWithValidator signs the given message which can be further recovered with the given validator. hash = keccak256("\x19\x00"${address}${data}).

Types ¶

type NameValueType ¶

type NameValueType struct {
	Name  string      `json:"name"`
	Value interface{} `json:"value"`
	Typ   string      `json:"type"`
}

NameValueType is a very simple struct with Name, Value and Type. It's meant for simple json structures used to communicate signing-info about typed data with the UI

func (*NameValueType) Pprint ¶

func (nvt *NameValueType) Pprint(depth int) string

Pprint returns a pretty-printed version of nvt

type SigFormat ¶

type SigFormat struct {
	Mime        string
	ByteVersion byte
}

type Type ¶

type Type struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

type TypePriority ¶

type TypePriority struct {
	Type  string
	Value uint
}

type TypedData ¶

type TypedData struct {
	Types       Types            `json:"types"`
	PrimaryType string           `json:"primaryType"`
	Domain      TypedDataDomain  `json:"domain"`
	Message     TypedDataMessage `json:"message"`
}

func (*TypedData) Dependencies ¶

func (typedData *TypedData) Dependencies(primaryType string, found []string) []string

Dependencies returns an array of custom types ordered by their hierarchical reference tree

func (*TypedData) EncodeData ¶

func (typedData *TypedData) EncodeData(primaryType string, data map[string]interface{}, depth int) (hexutil.Bytes, error)

EncodeData generates the following encoding: `enc(value₁) ‖ enc(value₂) ‖ … ‖ enc(valueₙ)`

each encoded member is 32-byte long

func (*TypedData) EncodePrimitiveValue ¶

func (typedData *TypedData) EncodePrimitiveValue(encType string, encValue interface{}, depth int) ([]byte, error)

EncodePrimitiveValue deals with the primitive values found while searching through the typed data

func (*TypedData) EncodeType ¶

func (typedData *TypedData) EncodeType(primaryType string) hexutil.Bytes

EncodeType generates the following encoding: `name ‖ "(" ‖ member₁ ‖ "," ‖ member₂ ‖ "," ‖ … ‖ memberₙ ")"`

each member is written as `type ‖ " " ‖ name` encodings cascade down and are sorted by name

func (*TypedData) Format ¶

func (typedData *TypedData) Format() ([]*NameValueType, error)

Format returns a representation of typedData, which can be easily displayed by a user-interface without in-depth knowledge about 712 rules

func (*TypedData) HashStruct ¶

func (typedData *TypedData) HashStruct(primaryType string, data TypedDataMessage) (hexutil.Bytes, error)

HashStruct generates a keccak256 hash of the encoding of the provided data

func (*TypedData) Map ¶

func (typedData *TypedData) Map() map[string]interface{}

Map generates a map version of the typed data

func (*TypedData) TypeHash ¶

func (typedData *TypedData) TypeHash(primaryType string) hexutil.Bytes

TypeHash creates the keccak256 hash of the data

type TypedDataDomain ¶

type TypedDataDomain struct {
	Name              string                `json:"name"`
	Version           string                `json:"version"`
	ChainId           *math.HexOrDecimal256 `json:"chainId"`
	VerifyingContract string                `json:"verifyingContract"`
	Salt              string                `json:"salt"`
}

func (*TypedDataDomain) Map ¶

func (domain *TypedDataDomain) Map() map[string]interface{}

Map is a helper function to generate a map version of the domain

type TypedDataMessage ¶

type TypedDataMessage = map[string]interface{}

type Types ¶

type Types map[string][]Type

type ValidatorData ¶

type ValidatorData struct {
	Address common.Address
	Message hexutil.Bytes
}

func UnmarshalValidatorData ¶

func UnmarshalValidatorData(data interface{}) (ValidatorData, error)

UnmarshalValidatorData converts the bytes input to typed data

Source Files ¶

View all Source files

typed_data.go

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL