fix asset alias (#1456)

[bytom/bytom.git] / asset / asset.go

diff --git a/asset/asset.go b/asset/asset.go
index 8871599..54096ad 100644 (file)
--- a/asset/asset.go
+++ b/asset/asset.go
@@ -56,7 +56,7 @@ func aliasKey(name string) []byte {
        return append(aliasPrefix, []byte(name)...)
 }
 
-// AssetKey asset store prefix
+// Key store asset prefix
 func Key(id *bc.AssetID) []byte {
        return append(assetPrefix, id.Bytes()...)
 }
@@ -126,37 +126,43 @@ func (reg *Registry) getNextAssetIndex() uint64 {
 }
 
 // Define defines a new Asset.
-func (reg *Registry) Define(xpubs []chainkd.XPub, quorum int, definition map[string]interface{}, alias string) (*Asset, error) {
-       if len(xpubs) == 0 {
-               return nil, errors.Wrap(signers.ErrNoXPubs)
-       }
+func (reg *Registry) Define(xpubs []chainkd.XPub, quorum int, definition map[string]interface{}, alias string, issuanceProgram chainjson.HexBytes) (*Asset, error) {
+       var err error
+       var assetSigner *signers.Signer
 
-       normalizedAlias := strings.ToUpper(strings.TrimSpace(alias))
-       if normalizedAlias == "" {
+       alias = strings.ToUpper(strings.TrimSpace(alias))
+       if alias == "" {
                return nil, errors.Wrap(ErrNullAlias)
        }
 
-       if normalizedAlias == consensus.BTMAlias {
+       if alias == consensus.BTMAlias {
                return nil, ErrInternalAsset
        }
 
-       nextAssetIndex := reg.getNextAssetIndex()
-       assetSigner, err := signers.Create("asset", xpubs, quorum, nextAssetIndex)
-       if err != nil {
-               return nil, err
-       }
-
        rawDefinition, err := serializeAssetDef(definition)
        if err != nil {
                return nil, ErrSerializing
        }
 
-       path := signers.Path(assetSigner, signers.AssetKeySpace)
-       derivedXPubs := chainkd.DeriveXPubs(assetSigner.XPubs, path)
-       derivedPKs := chainkd.XPubKeys(derivedXPubs)
-       issuanceProgram, vmver, err := multisigIssuanceProgram(derivedPKs, assetSigner.Quorum)
-       if err != nil {
-               return nil, err
+       vmver := uint64(1)
+       if len(issuanceProgram) == 0 {
+               if len(xpubs) == 0 {
+                       return nil, errors.Wrap(signers.ErrNoXPubs)
+               }
+
+               nextAssetIndex := reg.getNextAssetIndex()
+               assetSigner, err = signers.Create("asset", xpubs, quorum, nextAssetIndex, signers.BIP0032)
+               if err != nil {
+                       return nil, err
+               }
+
+               path := signers.GetBip0032Path(assetSigner, signers.AssetKeySpace)
+               derivedXPubs := chainkd.DeriveXPubs(assetSigner.XPubs, path)
+               derivedPKs := chainkd.XPubKeys(derivedXPubs)
+               issuanceProgram, vmver, err = multisigIssuanceProgram(derivedPKs, assetSigner.Quorum)
+               if err != nil {
+                       return nil, err
+               }
        }
 
        defHash := bc.NewHash(sha3.Sum256(rawDefinition))
@@ -167,11 +173,12 @@ func (reg *Registry) Define(xpubs []chainkd.XPub, quorum int, definition map[str
                IssuanceProgram:   issuanceProgram,
                AssetID:           bc.ComputeAssetID(issuanceProgram, vmver, &defHash),
                Signer:            assetSigner,
-               Alias:             &normalizedAlias,
+               Alias:             &alias,
        }
-       return a, reg.SaveAsset(a, normalizedAlias)
+       return a, reg.SaveAsset(a, alias)
 }
 
+// SaveAsset store asset
 func (reg *Registry) SaveAsset(a *Asset, alias string) error {
        reg.assetMu.Lock()
        defer reg.assetMu.Unlock()
@@ -289,9 +296,14 @@ func (reg *Registry) GetAsset(id string) (*Asset, error) {
        }
 
        if extAsset := reg.db.Get(ExtAssetKey(&assetID)); extAsset != nil {
-               if err := json.Unmarshal(extAsset, asset); err != nil {
+               definitionMap := make(map[string]interface{})
+               if err := json.Unmarshal(extAsset, &definitionMap); err != nil {
                        return nil, err
                }
+               alias := assetID.String()
+               asset.Alias = &alias
+               asset.AssetID = assetID
+               asset.DefinitionMap = definitionMap
                return asset, nil
        }
 
@@ -299,8 +311,32 @@ func (reg *Registry) GetAsset(id string) (*Asset, error) {
 }
 
 // ListAssets returns the accounts in the db
-func (reg *Registry) ListAssets() ([]*Asset, error) {
+func (reg *Registry) ListAssets(id string) ([]*Asset, error) {
        assets := []*Asset{DefaultNativeAsset}
+
+       assetIDStr := strings.TrimSpace(id)
+       if assetIDStr == DefaultNativeAsset.AssetID.String() {
+               return assets, nil
+       }
+
+       if assetIDStr != "" {
+               assetID := &bc.AssetID{}
+               if err := assetID.UnmarshalText([]byte(assetIDStr)); err != nil {
+                       return nil, err
+               }
+
+               asset := &Asset{}
+               interAsset := reg.db.Get(Key(assetID))
+               if interAsset != nil {
+                       if err := json.Unmarshal(interAsset, asset); err != nil {
+                               return nil, err
+                       }
+                       return []*Asset{asset}, nil
+               }
+
+               return []*Asset{}, nil
+       }
+
        assetIter := reg.db.IteratorPrefix(assetPrefix)
        defer assetIter.Release()
 
@@ -341,17 +377,20 @@ func multisigIssuanceProgram(pubkeys []ed25519.PublicKey, nrequired int) (progra
 //UpdateAssetAlias updates asset alias
 func (reg *Registry) UpdateAssetAlias(id, newAlias string) error {
        oldAlias := reg.GetAliasByID(id)
-       normalizedAlias := strings.ToUpper(strings.TrimSpace(newAlias))
+       newAlias = strings.ToUpper(strings.TrimSpace(newAlias))
 
        if oldAlias == consensus.BTMAlias || newAlias == consensus.BTMAlias {
                return ErrInternalAsset
        }
 
-       if oldAlias == "" || normalizedAlias == "" {
+       if oldAlias == "" || newAlias == "" {
                return ErrNullAlias
        }
 
-       if _, err := reg.FindByAlias(normalizedAlias); err == nil {
+       reg.assetMu.Lock()
+       defer reg.assetMu.Unlock()
+
+       if _, err := reg.FindByAlias(newAlias); err == nil {
                return ErrDuplicateAlias
        }
 
@@ -361,7 +400,7 @@ func (reg *Registry) UpdateAssetAlias(id, newAlias string) error {
        }
 
        storeBatch := reg.db.NewBatch()
-       findAsset.Alias = &normalizedAlias
+       findAsset.Alias = &newAlias
        assetID := &findAsset.AssetID
        rawAsset, err := json.Marshal(findAsset)
        if err != nil {