Refactor: Certificate Constructor:

lib/common/certificate/certificate.go

@@ -3,6 +3,7 @@
 package certificate
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/sirupsen/logrus"
@@ -143,9 +144,9 @@ func (c *Certificate) Data() (data []byte) {
 	return
 }
 
-// NewCertificate creates a new Certficiate from []byte
+// readCertificate creates a new Certficiate from []byte
 // returns err if the certificate is too short or if the payload doesn't match specified length.
-func NewCertificate(data []byte) (certificate Certificate, err error) {
+func readCertificate(data []byte) (certificate Certificate, err error) {
 	certificate = Certificate{}
 	switch len(data) {
 	case 0:
@@ -197,7 +198,7 @@ func NewCertificate(data []byte) (certificate Certificate, err error) {
 // ReadCertificate creates a Certificate from []byte and returns any ExcessBytes at the end of the input.
 // returns err if the certificate could not be read.
 func ReadCertificate(data []byte) (certificate Certificate, remainder []byte, err error) {
-	certificate, err = NewCertificate(data)
+	certificate, err = readCertificate(data)
 	if err != nil && err.Error() == "certificate parsing warning: certificate data is longer than specified by length" {
 		log.Warn("Certificate data longer than specified length")
 		err = nil
@@ -208,3 +209,42 @@ func ReadCertificate(data []byte) (certificate Certificate, remainder []byte, er
 	}).Debug("Read certificate and extracted remainder")
 	return
 }
+
+// NewCertificate creates a new Certificate with default NULL type
+func NewCertificate() *Certificate {
+    return &Certificate{
+        kind:     Integer([]byte{CERT_NULL}),
+        len:      Integer([]byte{0}),
+        payload:  make([]byte, 0),
+    }
+}
+
+// NewCertificateWithType creates a new Certificate with specified type and payload
+func NewCertificateWithType(certType uint8, payload []byte) (*Certificate, error) {
+    // Validate certificate type
+    switch certType {
+    case CERT_NULL, CERT_HASHCASH, CERT_HIDDEN, CERT_SIGNED, CERT_MULTIPLE, CERT_KEY:
+        // Valid type
+    default:
+        return nil, fmt.Errorf("invalid certificate type: %d", certType)
+    }
+
+    // For NULL certificates, payload should be empty
+    if certType == CERT_NULL && len(payload) > 0 {
+        return nil, errors.New("NULL certificates must have empty payload")
+    }
+	length, _ := NewIntegerFromInt(len(payload), 2)
+	
+    cert := &Certificate{
+        kind:          Integer([]byte{certType}),
+        len:           *length,
+        payload: make([]byte, len(payload)),
+    }
+
+    // Copy payload if present
+    if len(payload) > 0 {
+        copy(cert.payload, payload)
+    }
+
+    return cert, nil
+}

lib/common/certificate/certificate_test.go

@@ -10,7 +10,7 @@ func TestCertificateTypeIsFirstByte(t *testing.T) {
 	assert := assert.New(t)
 
 	bytes := []byte{0x03, 0x00, 0x00}
-	certificate, err := NewCertificate(bytes)
+	certificate, err := readCertificate(bytes)
 	cert_type := certificate.Type()
 
 	assert.Equal(cert_type, 3, "certificate.Type() should be the first bytes in a certificate")
@@ -21,7 +21,7 @@ func TestCertificateLengthCorrect(t *testing.T) {
 	assert := assert.New(t)
 
 	bytes := []byte{0x03, 0x00, 0x02, 0xff, 0xff}
-	certificate, err := NewCertificate(bytes)
+	certificate, err := readCertificate(bytes)
 	cert_len := certificate.Length()
 
 	assert.Equal(cert_len, 2, "certificate.Length() should return integer from second two bytes")
@@ -45,7 +45,7 @@ func TestCertificateLengthErrWhenDataTooShort(t *testing.T) {
 	assert := assert.New(t)
 
 	bytes := []byte{0x03, 0x00, 0x02, 0xff}
-	certificate, err := NewCertificate(bytes)
+	certificate, err := readCertificate(bytes)
 	cert_len := certificate.Length()
 
 	assert.Equal(cert_len, 2, "certificate.Length() did not return indicated length when data was actually missing")
@@ -58,7 +58,7 @@ func TestCertificateDataWhenCorrectSize(t *testing.T) {
 	assert := assert.New(t)
 
 	bytes := []byte{0x03, 0x00, 0x01, 0xaa}
-	certificate, err := NewCertificate(bytes)
+	certificate, err := readCertificate(bytes)
 	cert_data := certificate.Data()
 
 	assert.Nil(err, "certificate.Data() returned error with valid data")
@@ -85,7 +85,7 @@ func TestCertificateDataWhenTooShort(t *testing.T) {
 	assert := assert.New(t)
 
 	bytes := []byte{0x03, 0x00, 0x02, 0xff}
-	certificate, err := NewCertificate(bytes)
+	certificate, err := readCertificate(bytes)
 	cert_data := certificate.Data()
 
 	if assert.NotNil(err) {

lib/common/keys_and_cert/keys_and_cert.go

@@ -165,3 +165,4 @@ func ReadKeysAndCert(data []byte) (keys_and_cert KeysAndCert, remainder []byte,
 
 	return
 }
+