diff --git a/core/api/src/main/java/org/onosproject/net/flow/criteria/PiCriterion.java b/core/api/src/main/java/org/onosproject/net/flow/criteria/PiCriterion.java
index 17d1270..3970e76 100644
--- a/core/api/src/main/java/org/onosproject/net/flow/criteria/PiCriterion.java
+++ b/core/api/src/main/java/org/onosproject/net/flow/criteria/PiCriterion.java
@@ -23,6 +23,7 @@
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiRangeFieldMatch;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 
@@ -350,6 +351,54 @@
         }
 
         /**
+         * Adds an optional field match for the given fieldId and value.
+         *
+         * @param fieldId protocol-independent header field Id
+         * @param value   optional match value
+         * @return this
+         */
+        public Builder matchOptional(PiMatchFieldId fieldId, short value) {
+            fieldMatchMapBuilder.put(fieldId, new PiOptionalFieldMatch(fieldId, copyFrom(value)));
+            return this;
+        }
+
+        /**
+         * Adds an optional field match for the given fieldId and value.
+         *
+         * @param fieldId protocol-independent header field Id
+         * @param value   optional match value
+         * @return this
+         */
+        public Builder matchOptional(PiMatchFieldId fieldId, int value) {
+            fieldMatchMapBuilder.put(fieldId, new PiOptionalFieldMatch(fieldId, copyFrom(value)));
+            return this;
+        }
+
+        /**
+         * Adds an optional field match for the given fieldId and value.
+         *
+         * @param fieldId protocol-independent header field Id
+         * @param value   optional match value
+         * @return this
+         */
+        public Builder matchOptional(PiMatchFieldId fieldId, long value) {
+            fieldMatchMapBuilder.put(fieldId, new PiOptionalFieldMatch(fieldId, copyFrom(value)));
+            return this;
+        }
+
+        /**
+         * Adds an optional field match for the given fieldId and value.
+         *
+         * @param fieldId protocol-independent header field Id
+         * @param value   optional match value
+         * @return this
+         */
+        public Builder matchOptional(PiMatchFieldId fieldId, byte[] value) {
+            fieldMatchMapBuilder.put(fieldId, new PiOptionalFieldMatch(fieldId, copyFrom(value)));
+            return this;
+        }
+
+        /**
          * Builds a PiCriterion.
          *
          * @return PiCriterion
diff --git a/core/api/src/main/java/org/onosproject/net/pi/model/PiMatchType.java b/core/api/src/main/java/org/onosproject/net/pi/model/PiMatchType.java
index f4fce3e..a0cb161 100644
--- a/core/api/src/main/java/org/onosproject/net/pi/model/PiMatchType.java
+++ b/core/api/src/main/java/org/onosproject/net/pi/model/PiMatchType.java
@@ -42,5 +42,10 @@
     /**
      * Range match type.
      */
-    RANGE
+    RANGE,
+
+    /**
+     * Optional match type.
+     */
+    OPTIONAL
 }
diff --git a/core/api/src/main/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatch.java b/core/api/src/main/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatch.java
new file mode 100644
index 0000000..cb34981
--- /dev/null
+++ b/core/api/src/main/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatch.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * 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.onosproject.net.pi.runtime;
+
+import com.google.common.annotations.Beta;
+import com.google.common.base.Objects;
+import org.onlab.util.ImmutableByteSequence;
+import org.onosproject.net.pi.model.PiMatchFieldId;
+import org.onosproject.net.pi.model.PiMatchType;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Instance of an optional field match in a protocol-independent pipeline.
+ * The optional match field behaves like an exact match if specified, otherwise
+ * it is logically equivalent to a wildcard match.
+ */
+@Beta
+public final class PiOptionalFieldMatch extends PiFieldMatch {
+
+    private final ImmutableByteSequence value;
+
+    /**
+     * Creates an optional field match.
+     *
+     * @param fieldId field identifier
+     * @param value   value
+     */
+    public PiOptionalFieldMatch(PiMatchFieldId fieldId, ImmutableByteSequence value) {
+        super(fieldId);
+        this.value = checkNotNull(value);
+        checkArgument(value.size() > 0, "Value can't have size 0");
+    }
+
+    @Override
+    public PiMatchType type() {
+        return PiMatchType.OPTIONAL;
+    }
+
+    /**
+     * Returns the byte sequence value to be matched.
+     *
+     * @return an immutable byte sequence
+     */
+    public ImmutableByteSequence value() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        PiOptionalFieldMatch that = (PiOptionalFieldMatch) o;
+        return Objects.equal(this.fieldId(), that.fieldId()) &&
+                Objects.equal(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(this.fieldId(), value);
+    }
+
+    @Override
+    public String toString() {
+        return this.fieldId().toString() + "=" + value.toString();
+    }
+}
diff --git a/core/api/src/test/java/org/onosproject/net/flow/criteria/PiCriteriaTest.java b/core/api/src/test/java/org/onosproject/net/flow/criteria/PiCriteriaTest.java
index bd11252..fc95e00 100644
--- a/core/api/src/test/java/org/onosproject/net/flow/criteria/PiCriteriaTest.java
+++ b/core/api/src/test/java/org/onosproject/net/flow/criteria/PiCriteriaTest.java
@@ -22,6 +22,7 @@
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiRangeFieldMatch;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 
@@ -74,6 +75,40 @@
     private Criterion matchPiExactLong2 = PiCriterion.builder()
             .matchExact(ethMatchFieldId, matchExactLong2).build();
 
+    private Criterion matchPiOptionalByte1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchExactBytes1).build();
+    private Criterion sameAsMatchPiOptionalByte1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchExactBytes1).build();
+    private Criterion matchPiOptionalByte2 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchExactBytes2).build();
+
+    private short matchOptionalShort1 = 0x800;
+    private short matchOptionalShort2 = 0x806;
+    private Criterion matchPiOptionalShort1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalShort1).build();
+    private Criterion sameAsMatchPiOptionalShort1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalShort1).build();
+    private Criterion matchPiOptionalShort2 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalShort2).build();
+
+    private int matchOptionalInt1 = 0x800;
+    private int matchOptionalInt2 = 0x806;
+    private Criterion matchPiOptionalInt1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalInt1).build();
+    private Criterion sameAsMatchPiOptionalInt1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalInt1).build();
+    private Criterion matchPiOptionalInt2 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalInt2).build();
+
+    private long matchOptionalLong1 = 0x800;
+    private long matchOptionalLong2 = 0x806;
+    private Criterion matchPiOptionalLong1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalLong1).build();
+    private Criterion sameAsMatchPiOptionalLong1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalLong1).build();
+    private Criterion matchPiOptionalLong2 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalLong2).build();
+
     private PiMatchFieldId ipv4MatchFieldId = PiMatchFieldId.of("ipv4_t.dstAddr");
     private int mask = 0x00ffffff;
     private byte[] matchLpmBytes1 = {0x0a, 0x01, 0x01, 0x01};
@@ -242,6 +277,37 @@
     }
 
     /**
+     * Test the OptionalMatchPi method.
+     */
+    @Test
+    public void testOptionalMatchPiMethod() {
+
+        Criterion matchPiBytes = PiCriterion.builder().matchOptional(ethMatchFieldId, matchExactBytes1).build();
+        PiCriterion piCriterionBytes = checkAndConvert(matchPiBytes, Criterion.Type.PROTOCOL_INDEPENDENT,
+                                                       PiCriterion.class);
+        PiFieldMatch expectedMatchBytes = new PiOptionalFieldMatch(ethMatchFieldId, copyFrom(matchExactBytes1));
+        assertThat(piCriterionBytes.fieldMatches().iterator().next(), is(expectedMatchBytes));
+
+        Criterion matchPiShort = PiCriterion.builder().matchOptional(ethMatchFieldId, matchExactShort1).build();
+        PiCriterion piCriterionShort = checkAndConvert(matchPiShort, Criterion.Type.PROTOCOL_INDEPENDENT,
+                                                       PiCriterion.class);
+        PiFieldMatch expectedMatchShort = new PiOptionalFieldMatch(ethMatchFieldId, copyFrom(matchExactShort1));
+        assertThat(piCriterionShort.fieldMatches().iterator().next(), is(expectedMatchShort));
+
+        Criterion matchPiInt = PiCriterion.builder().matchOptional(ethMatchFieldId, matchExactInt1).build();
+        PiCriterion piCriterionInt = checkAndConvert(matchPiInt, Criterion.Type.PROTOCOL_INDEPENDENT,
+                                                     PiCriterion.class);
+        PiFieldMatch expectedMatchInt = new PiOptionalFieldMatch(ethMatchFieldId, copyFrom(matchExactInt1));
+        assertThat(piCriterionInt.fieldMatches().iterator().next(), is(expectedMatchInt));
+
+        Criterion matchPiLong = PiCriterion.builder().matchOptional(ethMatchFieldId, matchExactLong1).build();
+        PiCriterion piCriterionLong = checkAndConvert(matchPiLong, Criterion.Type.PROTOCOL_INDEPENDENT,
+                                                      PiCriterion.class);
+        PiFieldMatch expectedMatchLong = new PiOptionalFieldMatch(ethMatchFieldId, copyFrom(matchExactLong1));
+        assertThat(piCriterionLong.fieldMatches().iterator().next(), is(expectedMatchLong));
+    }
+
+    /**
      * Test the LpmMatchPi method.
      */
     @Test
@@ -388,6 +454,32 @@
      * Test the equals() method of the PiCriterion class.
      */
     @Test
+    public void testPiOptionalCriterionEquals() {
+        new EqualsTester()
+                .addEqualityGroup(matchPiOptionalByte1, sameAsMatchPiOptionalByte1)
+                .addEqualityGroup(matchPiOptionalByte2)
+                .testEquals();
+
+        new EqualsTester()
+                .addEqualityGroup(matchPiOptionalShort1, sameAsMatchPiOptionalShort1)
+                .addEqualityGroup(matchPiOptionalShort2)
+                .testEquals();
+
+        new EqualsTester()
+                .addEqualityGroup(matchPiOptionalInt1, sameAsMatchPiOptionalInt1)
+                .addEqualityGroup(matchPiOptionalInt2)
+                .testEquals();
+
+        new EqualsTester()
+                .addEqualityGroup(matchPiOptionalLong1, sameAsMatchPiOptionalLong1)
+                .addEqualityGroup(matchPiOptionalLong2)
+                .testEquals();
+    }
+
+    /**
+     * Test the equals() method of the PiCriterion class.
+     */
+    @Test
     public void testPiLpmCriterionEquals() {
         new EqualsTester()
                 .addEqualityGroup(matchPiLpmByte1, sameAsMatchPiLpmByte1)
diff --git a/core/api/src/test/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatchTest.java b/core/api/src/test/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatchTest.java
new file mode 100644
index 0000000..6e0c3d9
--- /dev/null
+++ b/core/api/src/test/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatchTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * 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.onosproject.net.pi.runtime;
+
+import com.google.common.testing.EqualsTester;
+import org.junit.Test;
+import org.onlab.util.ImmutableByteSequence;
+import org.onosproject.net.pi.model.PiMatchFieldId;
+import org.onosproject.net.pi.model.PiMatchType;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+import static org.onlab.util.ImmutableByteSequence.copyFrom;
+import static org.onosproject.net.pi.runtime.PiConstantsTest.*;
+
+/**
+ * Unit tests for PiOptionalFieldMatch class.
+ */
+public class PiOptionalFieldMatchTest {
+
+    private final ImmutableByteSequence value1 = copyFrom(0x0800);
+    private final ImmutableByteSequence value2 = copyFrom(0x0806);
+    private final PiMatchFieldId piMatchField = PiMatchFieldId.of(ETH_HEADER_NAME + DOT + ETH_TYPE);
+    private PiOptionalFieldMatch piOptionalFieldMatch1 = new PiOptionalFieldMatch(piMatchField, value1);
+    private PiOptionalFieldMatch sameAsPiOptionalFieldMatch1 = new PiOptionalFieldMatch(piMatchField, value1);
+    private PiOptionalFieldMatch piOptionalFieldMatch2 = new PiOptionalFieldMatch(piMatchField, value2);
+
+    /**
+     * Checks that the PiOptionalFieldMatch class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(PiOptionalFieldMatch.class);
+    }
+
+    /**
+     * Checks the operation of equals(), hashCode() and toString() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester()
+                .addEqualityGroup(piOptionalFieldMatch1, sameAsPiOptionalFieldMatch1)
+                .addEqualityGroup(piOptionalFieldMatch2)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a PiOptionalFieldMatch object.
+     */
+    @Test
+    public void testConstruction() {
+        final ImmutableByteSequence value = copyFrom(0x0806);
+        final PiMatchFieldId piMatchField = PiMatchFieldId.of(ETH_HEADER_NAME + DOT + ETH_TYPE);
+        PiOptionalFieldMatch piOptionalFieldMatch = new PiOptionalFieldMatch(piMatchField, value);
+        assertThat(piOptionalFieldMatch, is(notNullValue()));
+        assertThat(piOptionalFieldMatch.value(), is(value));
+        assertThat(piOptionalFieldMatch.type(), is(PiMatchType.OPTIONAL));
+    }
+}
diff --git a/core/common/src/main/java/org/onosproject/codec/impl/DecodeCriterionCodecHelper.java b/core/common/src/main/java/org/onosproject/codec/impl/DecodeCriterionCodecHelper.java
index 9516ed3..cf4cfa2 100644
--- a/core/common/src/main/java/org/onosproject/codec/impl/DecodeCriterionCodecHelper.java
+++ b/core/common/src/main/java/org/onosproject/codec/impl/DecodeCriterionCodecHelper.java
@@ -666,9 +666,18 @@
                                                                     CriterionCodec.PI_MATCH_LOW_VALUE +
                                                                             MISSING_MEMBER_MESSAGE).asText(), null),
                                     HexString.fromHexString(nullIsIllegal(node.get(CriterionCodec.PI_MATCH_HIGH_VALUE),
-                                                                    CriterionCodec.PI_MATCH_HIGH_VALUE +
-                                                                            MISSING_MEMBER_MESSAGE).asText(), null)
-                                    );
+                                                                     CriterionCodec.PI_MATCH_HIGH_VALUE +
+                                                                             MISSING_MEMBER_MESSAGE).asText(), null));
+                            break;
+                        case OPTIONAL:
+                            builder.matchOptional(
+                                    PiMatchFieldId.of(
+                                            nullIsIllegal(node.get(CriterionCodec.PI_MATCH_FIELD_ID),
+                                                          CriterionCodec.PI_MATCH_FIELD_ID +
+                                                                  MISSING_MEMBER_MESSAGE).asText()),
+                                    HexString.fromHexString(nullIsIllegal(node.get(CriterionCodec.PI_MATCH_VALUE),
+                                                                    CriterionCodec.PI_MATCH_VALUE +
+                                                                            MISSING_MEMBER_MESSAGE).asText(), null));
                             break;
                         default:
                             throw new IllegalArgumentException("Type " + type + " is unsupported");
diff --git a/core/common/src/main/java/org/onosproject/codec/impl/EncodeCriterionCodecHelper.java b/core/common/src/main/java/org/onosproject/codec/impl/EncodeCriterionCodecHelper.java
index c99e353..03cab28 100644
--- a/core/common/src/main/java/org/onosproject/codec/impl/EncodeCriterionCodecHelper.java
+++ b/core/common/src/main/java/org/onosproject/codec/impl/EncodeCriterionCodecHelper.java
@@ -56,6 +56,7 @@
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiRangeFieldMatch;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 import org.onosproject.store.serializers.KryoNamespaces;
@@ -555,6 +556,17 @@
         return matchRangeNode;
     }
 
+    private ObjectNode parsePiMatchOptional(PiOptionalFieldMatch optionalFieldMatch) {
+
+        ObjectNode optionalExactNode = context.mapper().createObjectNode();
+        optionalExactNode.put(CriterionCodec.PI_MATCH_FIELD_ID, optionalFieldMatch.fieldId().id());
+        optionalExactNode.put(CriterionCodec.PI_MATCH_TYPE, PiMatchType.OPTIONAL.name().toLowerCase());
+        optionalExactNode.put(CriterionCodec.PI_MATCH_VALUE,
+                           HexString.toHexString(optionalFieldMatch.value().asArray(),
+                                                 null));
+        return optionalExactNode;
+    }
+
     private class FormatProtocolIndependent implements CriterionTypeFormatter {
         @Override
         public ObjectNode encodeCriterion(ObjectNode root, Criterion criterion) {
@@ -574,6 +586,9 @@
                     case RANGE:
                         matchNodes.add(parsePiMatchRange((PiRangeFieldMatch) fieldMatch));
                         break;
+                    case OPTIONAL:
+                        matchNodes.add(parsePiMatchOptional((PiOptionalFieldMatch) fieldMatch));
+                        break;
                     default:
                         throw new IllegalArgumentException("Type " + fieldMatch.type().name() + " is unsupported");
                 }
diff --git a/core/common/src/test/java/org/onosproject/codec/impl/CriterionCodecTest.java b/core/common/src/test/java/org/onosproject/codec/impl/CriterionCodecTest.java
index 2628827..f2fd5e5 100644
--- a/core/common/src/test/java/org/onosproject/codec/impl/CriterionCodecTest.java
+++ b/core/common/src/test/java/org/onosproject/codec/impl/CriterionCodecTest.java
@@ -49,6 +49,7 @@
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiRangeFieldMatch;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 
@@ -519,6 +520,12 @@
                 .matchRange(ipv4MatchFieldId, matchRangeBytes1, matchRangeHighBytes).build();
         ObjectNode rangeResult = criterionCodec.encode(rangeBytesCriterion, context);
         assertThat(rangeResult, matchesCriterion(rangeBytesCriterion));
+
+        byte[] matchOptionalBytes = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
+        Criterion optionalBytesCriterion = PiCriterion.builder().matchOptional(ethMatchFieldId,
+                                                                               matchOptionalBytes).build();
+        ObjectNode optionalResult = criterionCodec.encode(optionalBytesCriterion, context);
+        assertThat(optionalResult, matchesCriterion(optionalBytesCriterion));
     }
 
     /**
@@ -556,6 +563,11 @@
                     Assert.assertThat(((PiRangeFieldMatch) piFieldMatch).lowValue(),
                                       is(copyFrom((byte) 0x10)));
                     break;
+                case OPTIONAL:
+                    Assert.assertThat(piFieldMatch.fieldId().id(), is("eth_dst"));
+                    Assert.assertThat(((PiOptionalFieldMatch) piFieldMatch).value(),
+                                      is(copyFrom(new byte[]{0x00, 0x11, 0x22, 0x33, 0x44, 0x55})));
+                    break;
                 default:
                     Assert.fail();
             }
diff --git a/core/common/src/test/java/org/onosproject/codec/impl/CriterionJsonMatcher.java b/core/common/src/test/java/org/onosproject/codec/impl/CriterionJsonMatcher.java
index b19ee53..d1e1f19 100644
--- a/core/common/src/test/java/org/onosproject/codec/impl/CriterionJsonMatcher.java
+++ b/core/common/src/test/java/org/onosproject/codec/impl/CriterionJsonMatcher.java
@@ -57,6 +57,7 @@
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiRangeFieldMatch;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 
@@ -633,6 +634,14 @@
                             return false;
                         }
                         break;
+                    case OPTIONAL:
+                        if (!Objects.equals(copyFrom(HexString.fromHexString(matchNode.get("value")
+                                                                                     .textValue(), null)),
+                                            ((PiOptionalFieldMatch) fieldMatch).value())) {
+                            description.appendText("match value was " + ((PiOptionalFieldMatch) fieldMatch).value());
+                            return false;
+                        }
+                        break;
                     default:
                         description.appendText("match type was " + fieldMatch.type().name().toLowerCase());
                         return false;
diff --git a/core/common/src/test/resources/org/onosproject/codec/impl/PiCriterion.json b/core/common/src/test/resources/org/onosproject/codec/impl/PiCriterion.json
index d1df49e..6635641 100644
--- a/core/common/src/test/resources/org/onosproject/codec/impl/PiCriterion.json
+++ b/core/common/src/test/resources/org/onosproject/codec/impl/PiCriterion.json
@@ -23,6 +23,11 @@
             "match": "range",
             "highValue": "20",
             "lowValue": "10"
+        },
+        {
+            "field": "eth_dst",
+            "match": "optional",
+            "value": "001122334455"
         }
     ]
 }
diff --git a/core/net/src/main/java/org/onosproject/net/pi/impl/CriterionTranslatorHelper.java b/core/net/src/main/java/org/onosproject/net/pi/impl/CriterionTranslatorHelper.java
index 4b64b0c..a6b213b 100644
--- a/core/net/src/main/java/org/onosproject/net/pi/impl/CriterionTranslatorHelper.java
+++ b/core/net/src/main/java/org/onosproject/net/pi/impl/CriterionTranslatorHelper.java
@@ -85,6 +85,7 @@
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 import org.onosproject.net.pi.service.PiTranslationException;
 
@@ -163,6 +164,8 @@
             switch (matchType) {
                 case EXACT:
                     return new PiExactFieldMatch(fieldId, translator.exactMatch());
+                case OPTIONAL:
+                    return new PiOptionalFieldMatch(fieldId, translator.exactMatch());
                 case TERNARY:
                     final Pair<ImmutableByteSequence, ImmutableByteSequence> tp = translator.ternaryMatch();
                     return new PiTernaryFieldMatch(fieldId, tp.getLeft(), tp.getRight());
diff --git a/core/net/src/main/java/org/onosproject/net/pi/impl/PiFlowRuleTranslatorImpl.java b/core/net/src/main/java/org/onosproject/net/pi/impl/PiFlowRuleTranslatorImpl.java
index 8350549..f399508 100644
--- a/core/net/src/main/java/org/onosproject/net/pi/impl/PiFlowRuleTranslatorImpl.java
+++ b/core/net/src/main/java/org/onosproject/net/pi/impl/PiFlowRuleTranslatorImpl.java
@@ -44,6 +44,7 @@
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
 import org.onosproject.net.pi.runtime.PiMatchKey;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiRangeFieldMatch;
 import org.onosproject.net.pi.runtime.PiTableAction;
 import org.onosproject.net.pi.runtime.PiTableEntry;
@@ -114,7 +115,8 @@
             // Need to ignore priority if no TCAM lookup match field
             needPriority = tableModel.matchFields().stream()
                     .anyMatch(match -> match.matchType() == PiMatchType.TERNARY ||
-                            match.matchType() == PiMatchType.RANGE);
+                            match.matchType() == PiMatchType.RANGE ||
+                            match.matchType() == PiMatchType.OPTIONAL);
         }
         // Translate treatment.
         final PiTableAction piTableAction = translateTreatment(rule.treatment(), interpreter, piTableId, pipelineModel);
@@ -362,6 +364,7 @@
                     case TERNARY:
                     case LPM:
                     case RANGE:
+                    case OPTIONAL:
                         // Skip field.
                         break;
                     default:
@@ -447,6 +450,15 @@
                     fieldMatch.fieldId(), fieldModel.matchType().name(), fieldMatch.type().name()));
         }
 
+        // Check if the arbitrary bit width is supported
+        if (!fieldModel.hasBitWidth() &&
+                !fieldModel.matchType().equals(PiMatchType.EXACT) &&
+                !fieldModel.matchType().equals(PiMatchType.OPTIONAL)) {
+            throw new PiTranslationException(format(
+                    "Arbitrary bit width for field '%s' and match type %s is not supported",
+                    fieldMatch.fieldId(), fieldModel.matchType().name()));
+        }
+
         int modelBitWidth = fieldModel.bitWidth();
 
         /*
@@ -461,7 +473,6 @@
         try {
             switch (fieldModel.matchType()) {
                 case EXACT:
-                    // TODO: arbitrary bit width is supported only for the EXACT match case.
                     PiExactFieldMatch exactField = (PiExactFieldMatch) fieldMatch;
                     return new PiExactFieldMatch(fieldMatch.fieldId(),
                                                  fieldModel.hasBitWidth() ?
@@ -492,6 +503,12 @@
                     return new PiRangeFieldMatch(fieldMatch.fieldId(),
                                                  ((PiRangeFieldMatch) fieldMatch).lowValue().fit(modelBitWidth),
                                                  ((PiRangeFieldMatch) fieldMatch).highValue().fit(modelBitWidth));
+                case OPTIONAL:
+                    PiOptionalFieldMatch optionalField = (PiOptionalFieldMatch) fieldMatch;
+                    return new PiOptionalFieldMatch(fieldMatch.fieldId(),
+                                                    fieldModel.hasBitWidth() ?
+                                                            optionalField.value().fit(modelBitWidth) :
+                                                            optionalField.value());
                 default:
                     // Should never be here.
                     throw new IllegalArgumentException(
diff --git a/protocols/p4runtime/ctl/src/test/java/org/onosproject/p4runtime/ctl/codec/TableEntryEncoderTest.java b/protocols/p4runtime/ctl/src/test/java/org/onosproject/p4runtime/ctl/codec/TableEntryEncoderTest.java
index c213753..8614527 100644
--- a/protocols/p4runtime/ctl/src/test/java/org/onosproject/p4runtime/ctl/codec/TableEntryEncoderTest.java
+++ b/protocols/p4runtime/ctl/src/test/java/org/onosproject/p4runtime/ctl/codec/TableEntryEncoderTest.java
@@ -34,19 +34,24 @@
 import org.onosproject.net.pi.runtime.PiCounterCellData;
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiMatchKey;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiTableEntry;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 import org.onosproject.p4runtime.ctl.utils.P4InfoBrowser;
 import org.onosproject.p4runtime.ctl.utils.PipeconfHelper;
+import p4.v1.P4RuntimeOuterClass;
 import p4.v1.P4RuntimeOuterClass.Action;
 import p4.v1.P4RuntimeOuterClass.CounterData;
 import p4.v1.P4RuntimeOuterClass.TableEntry;
 
 import java.net.URL;
 import java.util.Random;
+import java.util.stream.Collectors;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.hasItem;
 import static org.onlab.util.ImmutableByteSequence.copyFrom;
 import static org.onlab.util.ImmutableByteSequence.ofOnes;
 import static org.onosproject.net.pi.model.PiPipeconf.ExtensionType.P4_INFO_TEXT;
@@ -92,6 +97,7 @@
             .build();
 
     private final P4InfoBrowser browser = PipeconfHelper.getP4InfoBrowser(defaultPipeconf);
+    private final P4InfoBrowser browser2 = PipeconfHelper.getP4InfoBrowser(defaultPipeconf2);
     private final ImmutableByteSequence ethAddr = copyFrom(rand.nextInt()).fit(48);
     private final ImmutableByteSequence ethAddrString = ImmutableByteSequence.copyFrom(
             "00:11:22:33:44:55:66".getBytes());
@@ -139,7 +145,7 @@
                                   .addFieldMatch(new PiExactFieldMatch(inPortFieldId2, portValue32Bit))
                                   .addFieldMatch(new PiExactFieldMatch(ethDstAddrFieldId, ethAddrString))
                                   .addFieldMatch(new PiExactFieldMatch(ethSrcAddrFieldId, ethAddrString))
-                                  .addFieldMatch(new PiExactFieldMatch(ethTypeFieldId, portValue))
+                                  .addFieldMatch(new PiOptionalFieldMatch(ethTypeFieldId, portValue))
                                   .build())
             .withAction(PiAction
                                 .builder()
@@ -157,7 +163,7 @@
                                   .addFieldMatch(new PiExactFieldMatch(inPortFieldId2, portValue32Bit))
                                   .addFieldMatch(new PiExactFieldMatch(ethDstAddrFieldId, ethAddrString))
                                   .addFieldMatch(new PiExactFieldMatch(ethSrcAddrFieldId, ethAddrString))
-                                  .addFieldMatch(new PiExactFieldMatch(ethTypeFieldId, portValue))
+                                  .addFieldMatch(new PiOptionalFieldMatch(ethTypeFieldId, portValue))
                                   .build())
             .withAction(PiAction
                                 .builder()
@@ -168,6 +174,23 @@
             .withCookie(2)
             .build();
 
+    private final PiTableEntry piTableEntryWithoutOptionalField = PiTableEntry
+            .builder()
+            .forTable(tableId)
+            .withMatchKey(PiMatchKey.builder()
+                                  .addFieldMatch(new PiExactFieldMatch(inPortFieldId2, portValue32Bit))
+                                  .addFieldMatch(new PiExactFieldMatch(ethDstAddrFieldId, ethAddrString))
+                                  .addFieldMatch(new PiExactFieldMatch(ethSrcAddrFieldId, ethAddrString))
+                                  .build())
+            .withAction(PiAction
+                                .builder()
+                                .withId(outActionId)
+                                .withParameter(new PiActionParam(portParamId, portValueString))
+                                .build())
+            .withPriority(1)
+            .withCookie(2)
+            .build();
+
     private final PiTableEntry piTableEntryWithoutAction = PiTableEntry
             .builder()
             .forTable(tableId)
@@ -294,6 +317,31 @@
     }
 
     @Test
+    public void testTableEntryEncoderWithoutOptionalField() throws Exception {
+        TableEntry tableEntryMsg = Codecs.CODECS.tableEntry().encode(
+                piTableEntryWithoutOptionalField, null, defaultPipeconf2);
+        PiTableEntry decodedPiTableEntry = Codecs.CODECS.tableEntry().decode(
+                tableEntryMsg, null, defaultPipeconf2);
+
+        // Table ID.
+        int p4InfoTableId = browser2.tables().getByName(tableId.id()).getPreamble().getId();
+        int encodedTableId = tableEntryMsg.getTableId();
+        assertThat(encodedTableId, is(p4InfoTableId));
+
+        // Test equality for decoded entry.
+        new EqualsTester()
+                .addEqualityGroup(piTableEntryWithoutOptionalField, decodedPiTableEntry)
+                .testEquals();
+
+        // no optional field
+        assertThat(tableEntryMsg.getMatchCount(), is(3));
+        assertThat(tableEntryMsg.getMatchList().stream()
+                           .map(P4RuntimeOuterClass.FieldMatch::getFieldMatchTypeCase)
+                           .collect(Collectors.toList()),
+                   not(hasItem(P4RuntimeOuterClass.FieldMatch.FieldMatchTypeCase.OPTIONAL)));
+    }
+
+    @Test
     public void testActopProfileGroup() throws Exception {
         TableEntry tableEntryMsg = Codecs.CODECS.tableEntry().encode(
                 piTableEntryWithGroupAction, null, defaultPipeconf);
diff --git a/protocols/p4runtime/ctl/src/test/resources/test_p4runtime_translation.p4 b/protocols/p4runtime/ctl/src/test/resources/test_p4runtime_translation.p4
index 6ebf306..7f5431c 100644
--- a/protocols/p4runtime/ctl/src/test/resources/test_p4runtime_translation.p4
+++ b/protocols/p4runtime/ctl/src/test/resources/test_p4runtime_translation.p4
@@ -130,7 +130,7 @@
             local_metadata.ingress_port : exact;
             hdr.ethernet.srcAddr        : exact;
             hdr.ethernet.dstAddr        : exact;
-            hdr.ethernet.etherType      : exact;
+            hdr.ethernet.etherType      : optional;
         }
         actions = {
             set_egress_port;
diff --git a/protocols/p4runtime/ctl/src/test/resources/test_p4runtime_translation_p4info.txt b/protocols/p4runtime/ctl/src/test/resources/test_p4runtime_translation_p4info.txt
index 241d989..b984b4c 100644
--- a/protocols/p4runtime/ctl/src/test/resources/test_p4runtime_translation_p4info.txt
+++ b/protocols/p4runtime/ctl/src/test/resources/test_p4runtime_translation_p4info.txt
@@ -36,7 +36,7 @@
     id: 4
     name: "hdr.ethernet.etherType"
     bitwidth: 16
-    match_type: EXACT
+    match_type: OPTIONAL
   }
   action_refs {
     id: 27607748
diff --git a/protocols/p4runtime/model/src/main/java/org/onosproject/p4runtime/model/P4InfoParser.java b/protocols/p4runtime/model/src/main/java/org/onosproject/p4runtime/model/P4InfoParser.java
index 6558d80..b2f662b 100644
--- a/protocols/p4runtime/model/src/main/java/org/onosproject/p4runtime/model/P4InfoParser.java
+++ b/protocols/p4runtime/model/src/main/java/org/onosproject/p4runtime/model/P4InfoParser.java
@@ -114,6 +114,7 @@
                     .put(MatchField.MatchType.LPM, PiMatchType.LPM)
                     .put(MatchField.MatchType.TERNARY, PiMatchType.TERNARY)
                     .put(MatchField.MatchType.RANGE, PiMatchType.RANGE)
+                    .put(MatchField.MatchType.OPTIONAL, PiMatchType.OPTIONAL)
                     // Don't map UNSPECIFIED as we don't support it at the moment.
                     .build();
     public static final int NO_SIZE = -1;
diff --git a/protocols/p4runtime/model/src/test/java/org/onosproject/p4runtime/model/P4InfoParserTest.java b/protocols/p4runtime/model/src/test/java/org/onosproject/p4runtime/model/P4InfoParserTest.java
index 0432a18..558acb1 100644
--- a/protocols/p4runtime/model/src/test/java/org/onosproject/p4runtime/model/P4InfoParserTest.java
+++ b/protocols/p4runtime/model/src/test/java/org/onosproject/p4runtime/model/P4InfoParserTest.java
@@ -281,11 +281,11 @@
     }
 
     /**
-     * Tests parse method with P4Runtime translation fields.
+     * Tests parse method with P4Runtime translation fields and optional fields.
      * @throws Exception if equality group objects dose not match as expected
      */
     @Test
-    public void testParseP4RuntimeTranslation() throws Exception {
+    public void testParseP4RuntimeTranslationAndOptional() throws Exception {
         PiPipelineModel model = P4InfoParser.parse(p4InfoUrl2);
         // Generate a P4Info object from the file
         final P4Info p4info;
@@ -312,6 +312,7 @@
                 case LPM: piMatchType = PiMatchType.LPM; break;
                 case TERNARY: piMatchType = PiMatchType.TERNARY; break;
                 case RANGE: piMatchType = PiMatchType.RANGE; break;
+                case OPTIONAL: piMatchType = PiMatchType.OPTIONAL; break;
                 default: Assert.fail(); return;
             }
             if (matchFieldIter.getTypeName().getName().equals("mac_addr_t")) {
diff --git a/protocols/p4runtime/model/src/test/resources/org/onosproject/p4runtime/model/test_p4runtime_translation_p4info.txt b/protocols/p4runtime/model/src/test/resources/org/onosproject/p4runtime/model/test_p4runtime_translation_p4info.txt
index 241d989..b984b4c 100644
--- a/protocols/p4runtime/model/src/test/resources/org/onosproject/p4runtime/model/test_p4runtime_translation_p4info.txt
+++ b/protocols/p4runtime/model/src/test/resources/org/onosproject/p4runtime/model/test_p4runtime_translation_p4info.txt
@@ -36,7 +36,7 @@
     id: 4
     name: "hdr.ethernet.etherType"
     bitwidth: 16
-    match_type: EXACT
+    match_type: OPTIONAL
   }
   action_refs {
     id: 27607748
diff --git a/protocols/p4runtime/utils/src/main/java/org/onosproject/p4runtime/ctl/codec/FieldMatchCodec.java b/protocols/p4runtime/utils/src/main/java/org/onosproject/p4runtime/ctl/codec/FieldMatchCodec.java
index 5e2ec43..d42e6b9 100644
--- a/protocols/p4runtime/utils/src/main/java/org/onosproject/p4runtime/ctl/codec/FieldMatchCodec.java
+++ b/protocols/p4runtime/utils/src/main/java/org/onosproject/p4runtime/ctl/codec/FieldMatchCodec.java
@@ -23,6 +23,7 @@
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiRangeFieldMatch;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 import org.onosproject.p4runtime.ctl.utils.P4InfoBrowser;
@@ -33,6 +34,7 @@
 import static org.onlab.util.ImmutableByteSequence.copyFrom;
 import static org.onosproject.p4runtime.ctl.codec.Utils.assertPrefixLen;
 import static org.onosproject.p4runtime.ctl.codec.Utils.assertSize;
+import static org.onosproject.p4runtime.ctl.codec.Utils.sdnStringUnsupported;
 
 /**
  * Codec for P4Runtime FieldMatch. Metadata is expected to be a Preamble for
@@ -64,6 +66,7 @@
                                    matchFieldInfo.getName(), tablePreamble.getName());
         int fieldId = matchFieldInfo.getId();
         int fieldBitwidth = matchFieldInfo.getBitwidth();
+        boolean isSdnString = browser.isTypeString(matchFieldInfo.getTypeName());
 
         messageBuilder.setFieldId(fieldId);
 
@@ -71,8 +74,7 @@
             case EXACT:
                 PiExactFieldMatch fieldMatch = (PiExactFieldMatch) piFieldMatch;
                 ByteString exactValue = ByteString.copyFrom(fieldMatch.value().asReadOnlyBuffer());
-                // We support string only for EXACT match (via p4runtime_translation)
-                if (!browser.isTypeString(matchFieldInfo.getTypeName())) {
+                if (!isSdnString) {
                     assertSize(VALUE_OF_PREFIX + entityName, exactValue, fieldBitwidth);
                 }
                 return messageBuilder.setExact(
@@ -85,6 +87,9 @@
                 PiTernaryFieldMatch ternaryMatch = (PiTernaryFieldMatch) piFieldMatch;
                 ByteString ternaryValue = ByteString.copyFrom(ternaryMatch.value().asReadOnlyBuffer());
                 ByteString ternaryMask = ByteString.copyFrom(ternaryMatch.mask().asReadOnlyBuffer());
+                if (isSdnString) {
+                    sdnStringUnsupported(entityName, piFieldMatch.type());
+                }
                 assertSize(VALUE_OF_PREFIX + entityName, ternaryValue, fieldBitwidth);
                 assertSize(MASK_OF_PREFIX + entityName, ternaryMask, fieldBitwidth);
                 return messageBuilder.setTernary(
@@ -98,6 +103,9 @@
                 PiLpmFieldMatch lpmMatch = (PiLpmFieldMatch) piFieldMatch;
                 ByteString lpmValue = ByteString.copyFrom(lpmMatch.value().asReadOnlyBuffer());
                 int lpmPrefixLen = lpmMatch.prefixLength();
+                if (isSdnString) {
+                    sdnStringUnsupported(entityName, piFieldMatch.type());
+                }
                 assertSize(VALUE_OF_PREFIX + entityName, lpmValue, fieldBitwidth);
                 assertPrefixLen(entityName, lpmPrefixLen, fieldBitwidth);
                 return messageBuilder.setLpm(
@@ -110,6 +118,9 @@
                 PiRangeFieldMatch rangeMatch = (PiRangeFieldMatch) piFieldMatch;
                 ByteString rangeHighValue = ByteString.copyFrom(rangeMatch.highValue().asReadOnlyBuffer());
                 ByteString rangeLowValue = ByteString.copyFrom(rangeMatch.lowValue().asReadOnlyBuffer());
+                if (isSdnString) {
+                    sdnStringUnsupported(entityName, piFieldMatch.type());
+                }
                 assertSize(HIGH_RANGE_VALUE_OF_PREFIX + entityName, rangeHighValue, fieldBitwidth);
                 assertSize(LOW_RANGE_VALUE_OF_PREFIX + entityName, rangeLowValue, fieldBitwidth);
                 return messageBuilder.setRange(
@@ -118,6 +129,17 @@
                                 .setLow(rangeLowValue)
                                 .build())
                         .build();
+            case OPTIONAL:
+                PiOptionalFieldMatch optionalMatch = (PiOptionalFieldMatch) piFieldMatch;
+                ByteString optionalValue = ByteString.copyFrom(optionalMatch.value().asReadOnlyBuffer());
+                if (!isSdnString) {
+                    assertSize(VALUE_OF_PREFIX + entityName, optionalValue, fieldBitwidth);
+                }
+                return messageBuilder.setOptional(
+                        P4RuntimeOuterClass.FieldMatch.Optional.newBuilder()
+                                .setValue(optionalValue)
+                                .build())
+                        .build();
             default:
                 throw new CodecException(format(
                         "Building of match type %s not implemented", piFieldMatch.type()));
@@ -156,6 +178,10 @@
                 ImmutableByteSequence rangeHighValue = copyFrom(rangeFieldMatch.getHigh().asReadOnlyByteBuffer());
                 ImmutableByteSequence rangeLowValue = copyFrom(rangeFieldMatch.getLow().asReadOnlyByteBuffer());
                 return new PiRangeFieldMatch(headerFieldId, rangeLowValue, rangeHighValue);
+            case OPTIONAL:
+                P4RuntimeOuterClass.FieldMatch.Optional optionalFieldMatch = message.getOptional();
+                ImmutableByteSequence optionalValue = copyFrom(optionalFieldMatch.getValue().asReadOnlyByteBuffer());
+                return new PiOptionalFieldMatch(headerFieldId, optionalValue);
             default:
                 throw new CodecException(format(
                         "Decoding of field match type '%s' not implemented", typeCase.name()));
diff --git a/protocols/p4runtime/utils/src/main/java/org/onosproject/p4runtime/ctl/codec/Utils.java b/protocols/p4runtime/utils/src/main/java/org/onosproject/p4runtime/ctl/codec/Utils.java
index c72489a..2895b83 100644
--- a/protocols/p4runtime/utils/src/main/java/org/onosproject/p4runtime/ctl/codec/Utils.java
+++ b/protocols/p4runtime/utils/src/main/java/org/onosproject/p4runtime/ctl/codec/Utils.java
@@ -17,6 +17,7 @@
 package org.onosproject.p4runtime.ctl.codec;
 
 import com.google.protobuf.ByteString;
+import org.onosproject.net.pi.model.PiMatchType;
 
 import static java.lang.String.format;
 
@@ -49,4 +50,11 @@
                     entityDescr, bitWidth, prefixLength));
         }
     }
+
+    static void sdnStringUnsupported(String entityDescr, PiMatchType matchType)
+            throws CodecException {
+        throw new CodecException(format(
+                "%s is expected to be a sdn_string, but it is unsupported for %s match type",
+                entityDescr, matchType.name()));
+    }
 }