Distinguished token type from token format

Signed-off-by: Alexandros Filios <[email protected]>

Author: alexandrosfilios

token/core/common/loaders.go

@@ -116,7 +116,7 @@ func (s *VaultLedgerTokenLoader[T]) isAnyPending(ids ...*token.ID) (anyPending b
 }
 
 type LoadedToken[T any, M any] struct {
-	TokenType token.TokenType
+	TokenType token.TokenFormat
 	Token     T
 	Metadata  M
 }

token/core/common/ws.go

@@ -24,7 +24,7 @@ var (
 
 type TokenVault interface {
 	IsPending(id *token.ID) (bool, error)
-	GetTokenOutputsAndMeta(ctx context.Context, ids []*token.ID) ([][]byte, [][]byte, []token.TokenType, error)
+	GetTokenOutputsAndMeta(ctx context.Context, ids []*token.ID) ([][]byte, [][]byte, []token.TokenFormat, error)
 	GetTokenOutputs(ids []*token.ID, callback driver.QueryCallbackFunc) error
 	UnspentTokensIteratorBy(ctx context.Context, id string, tokenType token.TokenType) (driver.UnspentTokensIterator, error)
 	ListHistoryIssuedTokens() (*token.IssuedTokens, error)

token/core/fabtoken/tokens.go

@@ -19,19 +19,19 @@ import (
 
 type TokensService struct {
 	*common.TokensService
-	OutputTokenType token2.TokenType
+	OutputTokenFormat token2.TokenFormat
 }
 
 func NewTokensService(pp *PublicParams) (*TokensService, error) {
-	supportedTokens, err := supportedTokenTypes(pp.QuantityPrecision)
+	supportedTokens, err := supportedTokenFormat(pp.QuantityPrecision)
 	if err != nil {
 		return nil, errors.WithMessagef(err, "failed getting supported token types")
 	}
-	return &TokensService{TokensService: common.NewTokensService(), OutputTokenType: supportedTokens}, nil
+	return &TokensService{TokensService: common.NewTokensService(), OutputTokenFormat: supportedTokens}, nil
 }
 
 // Deobfuscate returns a deserialized token and the identity of its issuer
-func (s *TokensService) Deobfuscate(output []byte, outputMetadata []byte) (*token2.Token, driver.Identity, token2.TokenType, error) {
+func (s *TokensService) Deobfuscate(output []byte, outputMetadata []byte) (*token2.Token, driver.Identity, token2.TokenFormat, error) {
 	tok := &Output{}
 	if err := tok.Deserialize(output); err != nil {
 		return nil, nil, "", errors.Wrap(err, "failed unmarshalling token")
@@ -45,14 +45,14 @@ func (s *TokensService) Deobfuscate(output []byte, outputMetadata []byte) (*toke
 		Owner:    tok.Owner,
 		Type:     tok.Type,
 		Quantity: tok.Quantity,
-	}, metadata.Issuer, s.OutputTokenType, nil
+	}, metadata.Issuer, s.OutputTokenFormat, nil
 }
 
-func (s *TokensService) SupportedTokenTypes() []token2.TokenType {
-	return []token2.TokenType{s.OutputTokenType}
+func (s *TokensService) SupportedTokenTypes() []token2.TokenFormat {
+	return []token2.TokenFormat{s.OutputTokenFormat}
 }
 
-func supportedTokenTypes(precision uint64) (token2.TokenType, error) {
+func supportedTokenFormat(precision uint64) (token2.TokenFormat, error) {
 	hasher := common.NewSHA256Hasher()
 	if err := errors2.Join(
 		hasher.AddInt32(fabtoken.Type),
@@ -61,5 +61,5 @@ func supportedTokenTypes(precision uint64) (token2.TokenType, error) {
 	); err != nil {
 		return "", errors.Wrapf(err, "failed to generator token type")
 	}
-	return token2.TokenType(hasher.HexDigest()), nil
+	return token2.TokenFormat(hasher.HexDigest()), nil
 }

token/core/zkatdlog/nogh/tokens.go

@@ -22,45 +22,45 @@ import (
 type TokensService struct {
 	*common.TokensService
 	PublicParametersManager common.PublicParametersManager[*crypto.PublicParams]
-	OutputTokenType         token.TokenType
+	OutputTokenFormat       token.TokenFormat
 }
 
 func NewTokensService(publicParametersManager common.PublicParametersManager[*crypto.PublicParams]) (*TokensService, error) {
 	// compute supported tokens
 	// dlog without graph hiding
-	commTokenTypes, err := supportedTokenTypes(publicParametersManager.PublicParams())
+	commTokenTypes, err := supportedTokenFormat(publicParametersManager.PublicParams())
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed computing comm token types")
 	}
 
 	return &TokensService{
 		TokensService:           common.NewTokensService(),
 		PublicParametersManager: publicParametersManager,
-		OutputTokenType:         commTokenTypes,
+		OutputTokenFormat:       commTokenTypes,
 	}, nil
 }
 
 // Deobfuscate unmarshals a token and token info from raw bytes
 // It checks if the un-marshalled token matches the token info. If not, it returns
 // an error. Else it returns the token in cleartext and the identity of its issuer
-func (s *TokensService) Deobfuscate(output []byte, outputMetadata []byte) (*token.Token, driver.Identity, token.TokenType, error) {
+func (s *TokensService) Deobfuscate(output []byte, outputMetadata []byte) (*token.Token, driver.Identity, token.TokenFormat, error) {
 	_, metadata, tok, err := s.deserializeToken(output, outputMetadata, false)
 	if err != nil {
 		return nil, nil, "", err
 	}
-	return tok, metadata.Issuer, s.OutputTokenType, nil
+	return tok, metadata.Issuer, s.OutputTokenFormat, nil
 }
 
-func (s *TokensService) SupportedTokenTypes() []token.TokenType {
-	return []token.TokenType{s.OutputTokenType}
+func (s *TokensService) SupportedTokenTypes() []token.TokenFormat {
+	return []token.TokenFormat{s.OutputTokenFormat}
 }
 
-func (s *TokensService) DeserializeToken(outputType token.TokenType, outputRaw []byte, metadataRaw []byte) (*token2.Token, *token2.Metadata, *token2.ConversionWitness, error) {
+func (s *TokensService) DeserializeToken(outputType token.TokenFormat, outputRaw []byte, metadataRaw []byte) (*token2.Token, *token2.Metadata, *token2.ConversionWitness, error) {
 	// Here we have to check if what we get in input is already as expected.
 	// If not, we need to check if a conversion is possible.
 	// If not, a failure is to be returned
-	if outputType != s.OutputTokenType {
-		return nil, nil, nil, errors.Errorf("invalid token type [%s], expected [%s]", outputType, s.OutputTokenType)
+	if outputType != s.OutputTokenFormat {
+		return nil, nil, nil, errors.Errorf("invalid token type [%s], expected [%s]", outputType, s.OutputTokenFormat)
 	}
 
 	// get zkatdlog token
@@ -115,7 +115,7 @@ func (s *TokensService) getOutput(outputRaw []byte, checkOwner bool) (*token2.To
 	return output, nil
 }
 
-func supportedTokenTypes(pp *crypto.PublicParams) (token.TokenType, error) {
+func supportedTokenFormat(pp *crypto.PublicParams) (token.TokenFormat, error) {
 	hasher := common.NewSHA256Hasher()
 	if err := errors2.Join(
 		hasher.AddInt32(comm.Type),
@@ -126,5 +126,5 @@ func supportedTokenTypes(pp *crypto.PublicParams) (token.TokenType, error) {
 	); err != nil {
 		return "", errors.Wrapf(err, "failed to generator token type")
 	}
-	return token.TokenType(hasher.HexDigest()), nil
+	return token.TokenFormat(hasher.HexDigest()), nil
 }

token/core/zkatdlog/nogh/transfer.go

@@ -31,7 +31,7 @@ type TokenLoader interface {
 }
 
 type TokenDeserializer interface {
-	DeserializeToken(outputType token2.TokenType, outputRaw []byte, metadataRaw []byte) (*token.Token, *token.Metadata, *token.ConversionWitness, error)
+	DeserializeToken(outputType token2.TokenFormat, outputRaw []byte, metadataRaw []byte) (*token.Token, *token.Metadata, *token.ConversionWitness, error)
 }
 
 type TransferService struct {