Add eip-2930 transaction decoding

Author: dancoombs

crypto/src/main/java/org/web3j/crypto/AccessListObject.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2021 Web3 Labs Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package org.web3j.crypto;
+
+import java.util.List;
+import java.util.Objects;
+
+public class AccessListObject {
+    private String address;
+    private List<String> storageKeys;
+
+    public AccessListObject() {}
+
+    public AccessListObject(String address, List<String> storageKeys) {
+        this.address = address;
+        this.storageKeys = storageKeys;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public List<String> getStorageKeys() {
+        return storageKeys;
+    }
+
+    public void setStorageKeys(List<String> storageKeys) {
+        this.storageKeys = storageKeys;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        AccessListObject that = (AccessListObject) o;
+        return Objects.equals(getAddress(), that.getAddress())
+                && Objects.equals(getStorageKeys(), that.getStorageKeys());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getAddress(), getStorageKeys());
+    }
+}

crypto/src/main/java/org/web3j/crypto/RawTransaction.java

@@ -13,10 +13,12 @@
 package org.web3j.crypto;
 
 import java.math.BigInteger;
+import java.util.List;
 
 import org.web3j.crypto.transaction.type.ITransaction;
 import org.web3j.crypto.transaction.type.LegacyTransaction;
 import org.web3j.crypto.transaction.type.Transaction1559;
+import org.web3j.crypto.transaction.type.Transaction2930;
 import org.web3j.crypto.transaction.type.TransactionType;
 
 /**
@@ -116,6 +118,20 @@ public static RawTransaction createTransaction(
                         maxFeePerGas));
     }
 
+    public static RawTransaction createTransaction(
+            long chainId,
+            BigInteger nonce,
+            BigInteger gasPrice,
+            BigInteger gasLimit,
+            String to,
+            BigInteger value,
+            String data,
+            List<AccessListObject> accessList) {
+        return new RawTransaction(
+                Transaction2930.createTransaction(
+                        chainId, nonce, gasPrice, gasLimit, to, value, data, accessList));
+    }
+
     public BigInteger getNonce() {
         return transaction.getNonce();
     }

crypto/src/main/java/org/web3j/crypto/TransactionDecoder.java

@@ -13,21 +13,27 @@
 package org.web3j.crypto;
 
 import java.math.BigInteger;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 
 import org.web3j.crypto.transaction.type.TransactionType;
 import org.web3j.rlp.RlpDecoder;
 import org.web3j.rlp.RlpList;
 import org.web3j.rlp.RlpString;
+import org.web3j.rlp.RlpType;
 import org.web3j.utils.Numeric;
 
 public class TransactionDecoder {
     private static final int UNSIGNED_EIP1559TX_RLP_LIST_SIZE = 9;
+    private static final int UNSIGNED_EIP2930TX_RLP_LIST_SIZE = 8;
 
     public static RawTransaction decode(final String hexTransaction) {
         final byte[] transaction = Numeric.hexStringToByteArray(hexTransaction);
         if (getTransactionType(transaction) == TransactionType.EIP1559) {
             return decodeEIP1559Transaction(transaction);
+        } else if (getTransactionType(transaction) == TransactionType.EIP2930) {
+            return decodeEIP2930Transaction(transaction);
         }
         return decodeLegacyTransaction(transaction);
     }
@@ -36,7 +42,8 @@ private static TransactionType getTransactionType(final byte[] transaction) {
         // The first byte indicates a transaction type.
         byte firstByte = transaction[0];
         if (firstByte == TransactionType.EIP1559.getRlpType()) return TransactionType.EIP1559;
-        return TransactionType.LEGACY;
+        else if (firstByte == TransactionType.EIP2930.getRlpType()) return TransactionType.EIP2930;
+        else return TransactionType.LEGACY;
     }
 
     private static RawTransaction decodeEIP1559Transaction(final byte[] transaction) {
@@ -120,4 +127,65 @@ private static RawTransaction decodeLegacyTransaction(final byte[] transaction)
                     nonce, gasPrice, gasLimit, to, value, data, signatureData);
         }
     }
+
+    private static RawTransaction decodeEIP2930Transaction(final byte[] transaction) {
+        final byte[] encodedTx = Arrays.copyOfRange(transaction, 1, transaction.length);
+        final RlpList rlpList = RlpDecoder.decode(encodedTx);
+        final RlpList values = (RlpList) rlpList.getValues().get(0);
+
+        final long chainId =
+                ((RlpString) values.getValues().get(0)).asPositiveBigInteger().longValue();
+        final BigInteger nonce = ((RlpString) values.getValues().get(1)).asPositiveBigInteger();
+        final BigInteger gasPrice = ((RlpString) values.getValues().get(2)).asPositiveBigInteger();
+        final BigInteger gasLimit = ((RlpString) values.getValues().get(3)).asPositiveBigInteger();
+        final String to = ((RlpString) values.getValues().get(4)).asString();
+        final BigInteger value = ((RlpString) values.getValues().get(5)).asPositiveBigInteger();
+        final String data = ((RlpString) values.getValues().get(6)).asString();
+        List<AccessListObject> accessList =
+                decodeAccessList(((RlpList) values.getValues().get(7)).getValues());
+
+        final RawTransaction rawTransaction =
+                RawTransaction.createTransaction(
+                        chainId, nonce, gasPrice, gasLimit, to, value, data, accessList);
+
+        if (values.getValues().size() == UNSIGNED_EIP2930TX_RLP_LIST_SIZE) {
+            return rawTransaction;
+        } else {
+            final byte[] v =
+                    Sign.getVFromRecId(
+                            Numeric.toBigInt(((RlpString) values.getValues().get(8)).getBytes())
+                                    .intValue());
+            final byte[] r =
+                    Numeric.toBytesPadded(
+                            Numeric.toBigInt(((RlpString) values.getValues().get(9)).getBytes()),
+                            32);
+            final byte[] s =
+                    Numeric.toBytesPadded(
+                            Numeric.toBigInt(((RlpString) values.getValues().get(10)).getBytes()),
+                            32);
+            final Sign.SignatureData signatureData = new Sign.SignatureData(v, r, s);
+            return new SignedRawTransaction(rawTransaction.getTransaction(), signatureData);
+        }
+    }
+
+    private static List<AccessListObject> decodeAccessList(List<RlpType> rlp) {
+        final List<AccessListObject> res = new ArrayList<AccessListObject>();
+        rlp.forEach(
+                rawEntry -> {
+                    AccessListObject entry = new AccessListObject();
+                    List<RlpType> values = ((RlpList) rawEntry).getValues();
+
+                    entry.setAddress(((RlpString) values.get(0)).asString());
+                    List<RlpType> keyList = ((RlpList) values.get(1)).getValues();
+
+                    List<String> keys = new ArrayList<>();
+                    keyList.forEach(
+                            rawKey -> {
+                                keys.add(((RlpString) rawKey).asString());
+                            });
+                    entry.setStorageKeys(keys);
+                    res.add(entry);
+                });
+        return res;
+    }
 }

crypto/src/main/java/org/web3j/crypto/TransactionEncoder.java

@@ -117,7 +117,7 @@ public static byte[] encode(RawTransaction rawTransaction, Sign.SignatureData si
         RlpList rlpList = new RlpList(values);
         byte[] encoded = RlpEncoder.encode(rlpList);
 
-        if (rawTransaction.getType().isEip1559()) {
+        if (rawTransaction.getType().isEip1559() || rawTransaction.getType().isEip2930()) {
             return ByteBuffer.allocate(encoded.length + 1)
                     .put(rawTransaction.getType().getRlpType())
                     .put(encoded)

crypto/src/main/java/org/web3j/crypto/transaction/type/Transaction2930.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2022 Web3 Labs Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package org.web3j.crypto.transaction.type;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.web3j.crypto.AccessListObject;
+import org.web3j.crypto.Sign;
+import org.web3j.rlp.RlpList;
+import org.web3j.rlp.RlpString;
+import org.web3j.rlp.RlpType;
+import org.web3j.utils.Bytes;
+import org.web3j.utils.Numeric;
+
+import static org.web3j.crypto.transaction.type.TransactionType.EIP2930;
+
+public class Transaction2930 extends LegacyTransaction {
+    private long chainId;
+    private List<AccessListObject> accessList;
+
+    public Transaction2930(
+            long chainId,
+            BigInteger nonce,
+            BigInteger gasPrice,
+            BigInteger gasLimit,
+            String to,
+            BigInteger value,
+            String data,
+            List<AccessListObject> accessList) {
+        super(EIP2930, nonce, gasPrice, gasLimit, to, value, data);
+        this.chainId = chainId;
+        this.accessList = accessList;
+    }
+
+    @Override
+    public List<RlpType> asRlpValues(Sign.SignatureData signatureData) {
+        List<RlpType> result = new ArrayList<>();
+
+        result.add(RlpString.create(getChainId()));
+        result.add(RlpString.create(getNonce()));
+        result.add(RlpString.create(getGasPrice()));
+        result.add(RlpString.create(getGasLimit()));
+
+        // an empty to address (contract creation) should not be encoded as a numeric 0 value
+        String to = getTo();
+        if (to != null && to.length() > 0) {
+            // addresses that start with zeros should be encoded with the zeros included, not
+            // as numeric values
+            result.add(RlpString.create(Numeric.hexStringToByteArray(to)));
+        } else {
+            result.add(RlpString.create(""));
+        }
+
+        result.add(RlpString.create(getValue()));
+
+        // value field will already be hex encoded, so we need to convert into binary first
+        byte[] data = Numeric.hexStringToByteArray(getData());
+        result.add(RlpString.create(data));
+
+        // access list
+        List<AccessListObject> accessList = getAccessList();
+        List<RlpType> rlpAccessList = new ArrayList<>();
+        accessList.forEach(
+                entry -> {
+                    List<RlpType> rlpAccessListObject = new ArrayList<>();
+                    rlpAccessListObject.add(
+                            RlpString.create(Numeric.hexStringToByteArray(entry.getAddress())));
+                    List<RlpType> keyList = new ArrayList<>();
+                    entry.getStorageKeys()
+                            .forEach(
+                                    key -> {
+                                        keyList.add(
+                                                RlpString.create(
+                                                        Numeric.hexStringToByteArray(key)));
+                                    });
+                    rlpAccessListObject.add(new RlpList(keyList));
+                    rlpAccessList.add(new RlpList(rlpAccessListObject));
+                });
+        result.add(new RlpList(rlpAccessList));
+
+        if (signatureData != null) {
+            result.add(RlpString.create(Sign.getRecId(signatureData, getChainId())));
+            result.add(RlpString.create(Bytes.trimLeadingZeroes(signatureData.getR())));
+            result.add(RlpString.create(Bytes.trimLeadingZeroes(signatureData.getS())));
+        }
+
+        return result;
+    }
+
+    public static Transaction2930 createEtherTransaction(
+            long chainId,
+            BigInteger nonce,
+            BigInteger gasPrice,
+            BigInteger gasLimit,
+            String to,
+            BigInteger value) {
+        return new Transaction2930(chainId, nonce, gasPrice, gasLimit, to, value, "", List.of());
+    }
+
+    public static Transaction2930 createTransaction(
+            long chainId,
+            BigInteger nonce,
+            BigInteger gasPrice,
+            BigInteger gasLimit,
+            String to,
+            BigInteger value,
+            String data,
+            List<AccessListObject> accessList) {
+        return new Transaction2930(chainId, nonce, gasPrice, gasLimit, to, value, data, accessList);
+    }
+
+    public long getChainId() {
+        return chainId;
+    }
+
+    public List<AccessListObject> getAccessList() {
+        return accessList;
+    }
+}

crypto/src/main/java/org/web3j/crypto/transaction/type/TransactionType.java

@@ -14,6 +14,7 @@
 
 public enum TransactionType {
     LEGACY(null),
+    EIP2930(((byte) 0x01)),
     EIP1559(((byte) 0x02));
 
     Byte type;
@@ -33,4 +34,8 @@ public boolean isLegacy() {
     public boolean isEip1559() {
         return this.equals(TransactionType.EIP1559);
     }
+
+    public boolean isEip2930() {
+        return this.equals(TransactionType.EIP2930);
+    }
 }