1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
import ethUtil = require('ethereumjs-util');
var _ = require('lodash');
export abstract class CalldataBlock {
private name: string;
private signature: string;
private offsetInBytes: number;
private headerSizeInBytes: number;
private bodySizeInBytes: number;
private relocatable: boolean;
constructor(name: string, signature: string, offsetInBytes: number, headerSizeInBytes: number, bodySizeInBytes: number, relocatable: boolean) {
this.name = name;
this.signature = signature;
this.offsetInBytes = offsetInBytes;
this.headerSizeInBytes = headerSizeInBytes;
this.bodySizeInBytes = bodySizeInBytes;
this.relocatable = relocatable;
}
public getName(): string {
return this.name;
}
public getSignature(): string {
return this.signature;
}
public isRelocatable(): boolean {
return this.relocatable;
}
public getHeaderSizeInBytes(): number {
return this.headerSizeInBytes;
}
public getBodySizeInBytes(): number {
return this.bodySizeInBytes;
}
public getSizeInBytes(): number {
return this.headerSizeInBytes + this.bodySizeInBytes;
}
public getOffsetInBytes(): number {
return this.offsetInBytes;
}
public abstract toHexString(): string;
}
export class PayloadCalldataBlock extends CalldataBlock {
private payload: Buffer;
constructor(name: string, signature: string, offsetInBytes: number, relocatable: boolean, payload: Buffer) {
const headerSizeInBytes = 0;
const bodySizeInBytes = payload.byteLength;
super(name, signature, offsetInBytes, headerSizeInBytes, bodySizeInBytes, relocatable);
this.payload = payload;
}
public toHexString(): string {
const payloadHex = ethUtil.bufferToHex(this.payload);
return payloadHex;
}
}
export class DependentCalldataBlock extends CalldataBlock {
public static DEPENDENT_PAYLOAD_SIZE_IN_BYTES = 32;
private parent: CalldataBlock;
private dependency: CalldataBlock;
constructor(name: string, signature: string, offsetInBytes: number, relocatable: boolean, parent: CalldataBlock, dependency: CalldataBlock) {
const headerSizeInBytes = 0;
const bodySizeInBytes = DependentCalldataBlock.DEPENDENT_PAYLOAD_SIZE_IN_BYTES;
super(name, signature, offsetInBytes, headerSizeInBytes, bodySizeInBytes, relocatable);
this.parent = parent;
this.dependency = dependency;
}
public toHexString(): string {
const dependencyOffset = this.dependency.getOffsetInBytes();
const parentOffset = this.parent.getOffsetInBytes();
const parentHeaderSize = this.parent.getHeaderSizeInBytes();
const pointer = dependencyOffset - parentOffset + parentHeaderSize;
const pointerBuf = new Buffer(`0x${pointer.toString(16)}`);
const evmWordWidthInBytes = 32;
const pointerBufPadded = ethUtil.setLengthLeft(pointerBuf, evmWordWidthInBytes);
const pointerHex = ethUtil.bufferToHex(pointerBufPadded);
return pointerHex;
}
}
export class MemberCalldataBlock extends CalldataBlock {
private static DEPENDENT_PAYLOAD_SIZE_IN_BYTES = 32;
private header: Buffer | undefined;
private members: CalldataBlock[];
constructor(name: string, signature: string, offsetInBytes: number, relocatable: boolean, members: CalldataBlock[], header?: Buffer) {
const headerSizeInBytes = (header === undefined) ? 0 : header.byteLength;
let bodySizeInBytes = 0;
_.each(members, (member: Memblock) => {
bodySizeInBytes += member.getSizeInBytes();
});
super(name, signature, offsetInBytes, headerSizeInBytes, bodySizeInBytes, relocatable);
this.members = members;
this.header = header;
}
public toHexString(): string {
let valueBuffers: Buffer[] = [];
if (this.header !== undefined) valueBuffers.push(this.header);
_.each(this.members, (member: CalldataBlock) => {
const memberHexString = member.toHexString();
const memberBuf = ethUtil.toBuffer(memberHexString);
valueBuffers.push(memberBuf);
});
const combinedValueBufs = Buffer.concat(valueBuffers);
const combinedValuesAsHex = ethUtil.bufferToHex(combinedValueBufs);
return combinedValuesAsHex;
}
}
export class Calldata {
private selector: string;
private sizeInBytes: number;
private blocks: CalldataBlock[];
constructor() {
this.selector = '0x';
this.sizeInBytes = 0;
this.blocks = [];
}
public toHexString(): string {
let calldataString = `${this.selector}`;
_.each(this.blocks, (block: CalldataBlock) => {
const blockAsHexString = block.toHexString();
const blockAsHexWithoutPrefix = ethUtil.stripHexPrefix(blockAsHexString);
calldataString += blockAsHexWithoutPrefix;
});
return calldataString;
}
public getSelectorHex(): string {
return this.selector;
}
public getSizeInBytes(): number {
return this.sizeInBytes;
}
public toAnnotatedString(): string {
return "";
}
public pushBlock(block: CalldataBlock) {
this.blocks.push(block);
this.sizeInBytes += block.getSizeInBytes();
}
public setSelector(selector: string) {
// Ensure we have a 0x prefix
if (selector.startsWith('0x')) {
this.selector = selector;
} else {
this.selector = `$0x${selector}`;
}
// The selector must be 10 characters: '0x' followed by 4 bytes (two hex chars per byte)
if (this.selector.length !== 10) {
throw new Error(`Invalid selector '${this.selector}'`);
}
this.sizeInBytes += 8;
}
}
|
