Account type

encoding/ccf/ccf_type_id_test.go

@@ -122,7 +122,7 @@ func simpleStructType() *cadence.StructType {
 		Fields: []cadence.Field{
 			{
 				Identifier: "a",
-				Type:       cadence.IntType{},
+				Type:       cadence.IntType,
 			},
 		},
 	}
@@ -135,11 +135,11 @@ func simpleStructType2() *cadence.StructType {
 		Fields: []cadence.Field{
 			{
 				Identifier: "a",
-				Type:       cadence.IntType{},
+				Type:       cadence.IntType,
 			},
 			{
 				Identifier: "b",
-				Type:       cadence.StringType{},
+				Type:       cadence.StringType,
 			},
 		},
 	}

encoding/ccf/decode.go

@@ -410,13 +410,10 @@ func (d *Decoder) decodeValue(t cadence.Type, types *cadenceTypeByCCFTypeID) (ca
 	// If type t for the value to be decoded is a concrete type (e.g. IntType),
 	// value MUST NOT be ccf-type-and-value-message.
 
-	switch t := t.(type) {
+	switch t {
 	case cadence.VoidType:
 		return d.decodeVoid()
 
-	case *cadence.OptionalType:
-		return d.decodeOptional(t, types)
-
 	case cadence.BoolType:
 		return d.decodeBool()
 
@@ -495,27 +492,6 @@ func (d *Decoder) decodeValue(t cadence.Type, types *cadenceTypeByCCFTypeID) (ca
 	case cadence.UFix64Type:
 		return d.decodeUFix64()
 
-	case *cadence.VariableSizedArrayType:
-		return d.decodeArray(t, false, 0, types)
-
-	case *cadence.ConstantSizedArrayType:
-		return d.decodeArray(t, true, uint64(t.Size), types)
-
-	case *cadence.DictionaryType:
-		return d.decodeDictionary(t, types)
-
-	case *cadence.ResourceType:
-		return d.decodeResource(t, types)
-
-	case *cadence.StructType:
-		return d.decodeStruct(t, types)
-
-	case *cadence.EventType:
-		return d.decodeEvent(t, types)
-
-	case *cadence.ContractType:
-		return d.decodeContract(t, types)
-
 	case cadence.StoragePathType:
 		return d.decodePath()
 
@@ -536,6 +512,32 @@ func (d *Decoder) decodeValue(t cadence.Type, types *cadenceTypeByCCFTypeID) (ca
 			return nil, err
 		}
 		return cadence.NewMeteredTypeValue(d.gauge, typeValue), nil
+	}
+
+	switch t := t.(type) {
+	case *cadence.OptionalType:
+		return d.decodeOptional(t, types)
+
+	case *cadence.VariableSizedArrayType:
+		return d.decodeArray(t, false, 0, types)
+
+	case *cadence.ConstantSizedArrayType:
+		return d.decodeArray(t, true, uint64(t.Size), types)
+
+	case *cadence.DictionaryType:
+		return d.decodeDictionary(t, types)
+
+	case *cadence.ResourceType:
+		return d.decodeResource(t, types)
+
+	case *cadence.StructType:
+		return d.decodeStruct(t, types)
+
+	case *cadence.EventType:
+		return d.decodeEvent(t, types)
+
+	case *cadence.ContractType:
+		return d.decodeContract(t, types)
 
 	case *cadence.CapabilityType:
 		return d.decodeCapability(t, types)

encoding/ccf/decode_type.go

@@ -109,175 +109,12 @@ func (d *Decoder) decodeSimpleTypeID() (cadence.Type, error) {
 		return nil, err
 	}
 
-	switch simpleTypeID {
-	case TypeBool:
-		return cadence.TheBoolType, nil
-
-	case TypeString:
-		return cadence.TheStringType, nil
-
-	case TypeCharacter:
-		return cadence.TheCharacterType, nil
-
-	case TypeAddress:
-		return cadence.TheAddressType, nil
-
-	case TypeInt:
-		return cadence.TheIntType, nil
-
-	case TypeInt8:
-		return cadence.TheInt8Type, nil
-
-	case TypeInt16:
-		return cadence.TheInt16Type, nil
-
-	case TypeInt32:
-		return cadence.TheInt32Type, nil
-
-	case TypeInt64:
-		return cadence.TheInt64Type, nil
-
-	case TypeInt128:
-		return cadence.TheInt128Type, nil
-
-	case TypeInt256:
-		return cadence.TheInt256Type, nil
-
-	case TypeUInt:
-		return cadence.TheUIntType, nil
-
-	case TypeUInt8:
-		return cadence.TheUInt8Type, nil
-
-	case TypeUInt16:
-		return cadence.TheUInt16Type, nil
-
-	case TypeUInt32:
-		return cadence.TheUInt32Type, nil
-
-	case TypeUInt64:
-		return cadence.TheUInt64Type, nil
-
-	case TypeUInt128:
-		return cadence.TheUInt128Type, nil
-
-	case TypeUInt256:
-		return cadence.TheUInt256Type, nil
-
-	case TypeWord8:
-		return cadence.TheWord8Type, nil
-
-	case TypeWord16:
-		return cadence.TheWord16Type, nil
-
-	case TypeWord32:
-		return cadence.TheWord32Type, nil
-
-	case TypeWord64:
-		return cadence.TheWord64Type, nil
-
-	case TypeWord128:
-		return cadence.TheWord128Type, nil
-
-	case TypeWord256:
-		return cadence.TheWord256Type, nil
-
-	case TypeFix64:
-		return cadence.TheFix64Type, nil
-
-	case TypeUFix64:
-		return cadence.TheUFix64Type, nil
-
-	case TypePath:
-		return cadence.ThePathType, nil
-
-	case TypeCapabilityPath:
-		return cadence.TheCapabilityPathType, nil
-
-	case TypeStoragePath:
-		return cadence.TheStoragePathType, nil
-
-	case TypePublicPath:
-		return cadence.ThePublicPathType, nil
-
-	case TypePrivatePath:
-		return cadence.ThePrivatePathType, nil
-
-	case TypeAuthAccount:
-		return cadence.TheAuthAccountType, nil
-
-	case TypePublicAccount:
-		return cadence.ThePublicAccountType, nil
-
-	case TypeAuthAccountKeys:
-		return cadence.TheAuthAccountKeysType, nil
-
-	case TypePublicAccountKeys:
-		return cadence.ThePublicAccountKeysType, nil
-
-	case TypeAuthAccountContracts:
-		return cadence.TheAuthAccountContractsType, nil
-
-	case TypePublicAccountContracts:
-		return cadence.ThePublicAccountContractsType, nil
-
-	case TypeDeployedContract:
-		return cadence.TheDeployedContractType, nil
-
-	case TypeAccountKey:
-		return cadence.TheAccountKeyType, nil
-
-	case TypeBlock:
-		return cadence.TheBlockType, nil
-
-	case TypeAny:
-		return cadence.TheAnyType, nil
-
-	case TypeAnyStruct:
-		return cadence.TheAnyStructType, nil
-
-	case TypeAnyResource:
-		return cadence.TheAnyResourceType, nil
-
-	case TypeMetaType:
-		return cadence.TheMetaType, nil
-
-	case TypeNever:
-		return cadence.TheNeverType, nil
-
-	case TypeNumber:
-		return cadence.TheNumberType, nil
-
-	case TypeSignedNumber:
-		return cadence.TheSignedNumberType, nil
-
-	case TypeInteger:
-		return cadence.TheIntegerType, nil
-
-	case TypeSignedInteger:
-		return cadence.TheSignedIntegerType, nil
-
-	case TypeFixedPoint:
-		return cadence.TheFixedPointType, nil
-
-	case TypeSignedFixedPoint:
-		return cadence.TheSignedFixedPointType, nil
-
-	case TypeBytes:
-		return cadence.TheBytesType, nil
-
-	case TypeVoid:
-		return cadence.TheVoidType, nil
-
-	case TypeAnyStructAttachmentType:
-		return cadence.TheAnyStructAttachmentType, nil
-
-	case TypeAnyResourceAttachmentType:
-		return cadence.TheAnyResourceAttachmentType, nil
-
-	default:
+	ty := typeBySimpleTypeID(SimpleType(simpleTypeID))
+	if ty == nil {
 		return nil, fmt.Errorf("unsupported encoded simple type ID %d", simpleTypeID)
 	}
+
+	return ty, nil
 }
 
 // decodeOptionalType decodes optional-type or optional-type-value as

encoding/ccf/encode.go

@@ -1305,9 +1305,9 @@ func (e *Encoder) encodeTypeValueRef(id ccfTypeID) error {
 //
 //	; cbor-tag-simple-type-value
 //	#6.185(simple-type-id)
-func (e *Encoder) encodeSimpleTypeValue(id uint64) error {
+func (e *Encoder) encodeSimpleTypeValue(id SimpleType) error {
 	rawTagNum := []byte{0xd8, CBORTagSimpleTypeValue}
-	return e.encodeSimpleTypeWithRawTag(id, rawTagNum)
+	return e.encodeSimpleTypeWithRawTag(uint64(id), rawTagNum)
 }
 
 // encodeOptionalTypeValue encodes cadence.OptionalType as
@@ -2015,9 +2015,10 @@ func isOptionalNeverType(t cadence.Type) bool {
 			return false
 		}
 
-		if ot.Type.Equal(cadence.NewNeverType()) {
+		if ot.Type.Equal(cadence.NeverType) {
 			return true
 		}
+
 		t = ot.Type
 	}
 }

encoding/ccf/encode_type.go

@@ -79,7 +79,7 @@ func (e *Encoder) encodeInlineType(typ cadence.Type, tids ccfTypeIDByCadenceType
 		return e.encodeCapabilityType(typ, tids)
 
 	case *cadence.FunctionType:
-		return e.encodeSimpleType(TypeFunction)
+		return e.encodeSimpleType(SimpleTypeFunction)
 
 	default:
 		panic(cadenceErrors.NewUnexpectedError("unsupported type %s (%T)", typ.ID(), typ))
@@ -99,9 +99,9 @@ func (e *Encoder) encodeNullableInlineType(typ cadence.Type, tids ccfTypeIDByCad
 //
 //	; cbor-tag-simple-type
 //	#6.137(simple-type-id)
-func (e *Encoder) encodeSimpleType(id uint64) error {
+func (e *Encoder) encodeSimpleType(id SimpleType) error {
 	rawTagNum := []byte{0xd8, CBORTagSimpleType}
-	return e.encodeSimpleTypeWithRawTag(id, rawTagNum)
+	return e.encodeSimpleTypeWithRawTag(uint64(id), rawTagNum)
 }
 
 // encodeSimpleTypeWithRawTag encodes simple type with given tag number as