15663061800

Committed 15 Jun 2025 12:13PM UTC coverage: 84.0%. First build

Build # 15663061800

Build Type

push

github

Committed by

code-z2

Commit Message

feat: implement EIP-712 structured data signing

- Add core EIP-712 signing functionality with v3/v4 support
- Introduce TypedDataEncoder class for message encoding
- Add domain separator and type validation support
- Implement comprehensive type handling including arrays and custom structs
- Add utilities for hex/bigint conversions and ABI encoding
- Include example usage and update documentation
- Set up CI/CD with coverage reporting

Run Details

210 of 250 new or added lines in 5 files covered. (84.0%)

210 of 250 relevant lines covered (84.0%)

1.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.0

/lib/src/models.dart

part of 'typed_data.dart';

typedef TypeValuePair = ({String type, Object value});

@JsonEnum(valueField: 'version')
enum TypedDataVersion {
  v3(version: 'V3'),
  v4(version: 'V4');

  final String version;

  const TypedDataVersion({required this.version});
}

class EthereumAddressConverter extends JsonConverter<EthereumAddress, Object> {
  const EthereumAddressConverter();

  @override
  fromJson(address) {
    if (address is EthereumAddress) {
      return address;
    }
    return EthereumAddress.fromHex(address.toString());
  }

  @override
  toJson(address) {
    return address.with0x;
  }
}

class U8AConverter extends JsonConverter<Uint8List, Object> {
  const U8AConverter();

  @override
  fromJson(bytes) {
    if (bytes is Uint8List) {
      return bytes;
    } else if (bytes is List<int>) {
      return Uint8List.fromList(bytes);
    }
    return hexToBytes(bytes.toString());
  }

  @override
  toJson(bytes) {
    return bytesToHex(bytes, include0x: true);
  }
}

class BigintConverter extends JsonConverter<BigInt, Object> {
  const BigintConverter();

  @override
  fromJson(value) {
    return BigInt.parse(value.toString());
  }

  @override
  toJson(value) {
    return value.toInt();
  }
}

@freezed
abstract class MessageTypeProperty with _$MessageTypeProperty {
  const factory MessageTypeProperty({
    required String name,
    required String type,
  }) = _MessageTypeProperty;

  factory MessageTypeProperty.fromJson(Map<String, String> json) =>
      _$MessageTypePropertyFromJson(json);
}

@freezed
abstract class TypedMessage with _$TypedMessage {
  const factory TypedMessage({
    required Map<String, List<MessageTypeProperty>> types,
    required String primaryType,
    required EIP712Domain? domain,
    required Map<String, dynamic> message,
  }) = _TypedMessage;

  factory TypedMessage.fromJson(Map<String, Object?> json) =>
      _$TypedMessageFromJson(json);
}

@freezed
abstract class EIP712Domain with _$EIP712Domain {
  const EIP712Domain._();

  const factory EIP712Domain({
    required String? name,
    required String? version,
    @BigintConverter() required BigInt? chainId,
    @EthereumAddressConverter() required EthereumAddress? verifyingContract,
    @U8AConverter() required Uint8List? salt,
  }) = _EIP712Domain;

  factory EIP712Domain.fromJson(Map<String, Object?> json) =>
      _$EIP712DomainFromJson(json);

  dynamic operator [](String key) {
    switch (key) {
      case 'name':
        return name;
      case 'version':
        return version;
      case 'chainId':
        return chainId;
      case 'verifyingContract':
        return verifyingContract;
      case 'salt':
        return salt;
      default:
        throw ArgumentError("Var $key is not declared in EIP712Domain");
    }
  }
}

@freezed
sealed class MessageTypes with _$MessageTypes {
  const factory MessageTypes.eip712Domain({required EIP712Domain? value}) =
      Eip712Domain;

  const factory MessageTypes.additionalData({
    required Map<String, dynamic>? value,
  }) = AdditionalData;

  factory MessageTypes.from(dynamic raw) =>
      MessageTypes.additionalData(value: raw as Map<String, dynamic>);
}

1	part of 'typed_data.dart';
2
3	typedef TypeValuePair = ({String type, Object value});
4
5	@JsonEnum(valueField: 'version')
6	enum TypedDataVersion {
7	v3(version: 'V3'),
8	v4(version: 'V4');
9
10	final String version;
11
12	const TypedDataVersion({required this.version});
13	}
14
15	class EthereumAddressConverter extends JsonConverter<EthereumAddress, Object> {
16	const EthereumAddressConverter();	3✔
17
18	@override	1✔
19	fromJson(address) {
20	if (address is EthereumAddress) {	1✔
21	return address;
22	}
23	return EthereumAddress.fromHex(address.toString());	2✔
24	}
25
NEW 26	@override	×
27	toJson(address) {
NEW 28	return address.with0x;	×
29	}
30	}
31
32	class U8AConverter extends JsonConverter<Uint8List, Object> {
33	const U8AConverter();	3✔
34
35	@override	1✔
36	fromJson(bytes) {
37	if (bytes is Uint8List) {	1✔
38	return bytes;
39	} else if (bytes is List<int>) {	1✔
NEW 40	return Uint8List.fromList(bytes);	×
41	}
42	return hexToBytes(bytes.toString());	2✔
43	}
44
NEW 45	@override	×
46	toJson(bytes) {
NEW 47	return bytesToHex(bytes, include0x: true);	×
48	}
49	}
50
51	class BigintConverter extends JsonConverter<BigInt, Object> {
52	const BigintConverter();	3✔
53
54	@override	1✔
55	fromJson(value) {
56	return BigInt.parse(value.toString());	2✔
57	}
58
NEW 59	@override	×
60	toJson(value) {
NEW 61	return value.toInt();	×
62	}
63	}
64
65	@freezed
66	abstract class MessageTypeProperty with _$MessageTypeProperty {
67	const factory MessageTypeProperty({
68	required String name,
69	required String type,
70	}) = _MessageTypeProperty;
71
72	factory MessageTypeProperty.fromJson(Map<String, String> json) =>	1✔
73	_$MessageTypePropertyFromJson(json);	1✔
74	}
75
76	@freezed
77	abstract class TypedMessage with _$TypedMessage {
78	const factory TypedMessage({
79	required Map<String, List<MessageTypeProperty>> types,
80	required String primaryType,
81	required EIP712Domain? domain,
82	required Map<String, dynamic> message,
83	}) = _TypedMessage;
84
85	factory TypedMessage.fromJson(Map<String, Object?> json) =>	1✔
86	_$TypedMessageFromJson(json);	1✔
87	}
88
89	@freezed
90	abstract class EIP712Domain with _$EIP712Domain {
91	const EIP712Domain._();	1✔
92
93	const factory EIP712Domain({
94	required String? name,
95	required String? version,
96	@BigintConverter() required BigInt? chainId,
97	@EthereumAddressConverter() required EthereumAddress? verifyingContract,
98	@U8AConverter() required Uint8List? salt,
99	}) = _EIP712Domain;
100
101	factory EIP712Domain.fromJson(Map<String, Object?> json) =>	1✔
102	_$EIP712DomainFromJson(json);	1✔
103
104	dynamic operator [](String key) {	1✔
105	switch (key) {
106	case 'name':	1✔
107	return name;	1✔
108	case 'version':	1✔
109	return version;	1✔
110	case 'chainId':	1✔
111	return chainId;	1✔
112	case 'verifyingContract':	1✔
113	return verifyingContract;	1✔
114	case 'salt':	1✔
115	return salt;	1✔
116	default:
NEW 117	throw ArgumentError("Var $key is not declared in EIP712Domain");	×
118	}
119	}
120	}
121
122	@freezed
123	sealed class MessageTypes with _$MessageTypes {
124	const factory MessageTypes.eip712Domain({required EIP712Domain? value}) =
125	Eip712Domain;
126
127	const factory MessageTypes.additionalData({
128	required Map<String, dynamic>? value,
129	}) = AdditionalData;
130
131	factory MessageTypes.from(dynamic raw) =>	1✔
132	MessageTypes.additionalData(value: raw as Map<String, dynamic>);	1✔
133	}

vaariance / eip-712 / 15663061800

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous