protocol/bc/asset.go

   1 package bc
   2
   3 import (
   4         "database/sql/driver"
   5         "errors"
   6         "io"
   7
   8         "github.com/bytom/crypto/sha3pool"
   9         "github.com/bytom/encoding/blockchain"
  10 )
  11
  12 // AssetID is the Hash256 of the asset definition.
  13
  14 func NewAssetID(b [32]byte) (a AssetID) {
  15         return AssetID(NewHash(b))
  16 }
  17
  18 func (a AssetID) Byte32() (b32 [32]byte)               { return Hash(a).Byte32() }
  19 func (a AssetID) MarshalText() ([]byte, error)         { return Hash(a).MarshalText() }
  20 func (a *AssetID) UnmarshalText(b []byte) error        { return (*Hash)(a).UnmarshalText(b) }
  21 func (a *AssetID) UnmarshalJSON(b []byte) error        { return (*Hash)(a).UnmarshalJSON(b) }
  22 func (a AssetID) Bytes() []byte                        { return Hash(a).Bytes() }
  23 func (a AssetID) Value() (driver.Value, error)         { return Hash(a).Value() }
  24 func (a *AssetID) Scan(val interface{}) error          { return (*Hash)(a).Scan(val) }
  25 func (a AssetID) WriteTo(w io.Writer) (int64, error)   { return Hash(a).WriteTo(w) }
  26 func (a *AssetID) ReadFrom(r io.Reader) (int64, error) { return (*Hash)(a).ReadFrom(r) }
  27 func (a *AssetID) IsZero() bool                        { return (*Hash)(a).IsZero() }
  28
  29 func (ad *AssetDefinition) ComputeAssetID() (assetID AssetID) {
  30         h := sha3pool.Get256()
  31         defer sha3pool.Put256(h)
  32         writeForHash(h, *ad) // error is impossible
  33         var b [32]byte
  34         h.Read(b[:]) // error is impossible
  35         return NewAssetID(b)
  36 }
  37
  38 func ComputeAssetID(prog []byte, vmVersion uint64, data *Hash) AssetID {
  39         def := &AssetDefinition{
  40                 IssuanceProgram: &Program{
  41                         VmVersion: vmVersion,
  42                         Code:      prog,
  43                 },
  44                 Data: data,
  45         }
  46         return def.ComputeAssetID()
  47 }
  48
  49 func (a *AssetAmount) ReadFrom(r *blockchain.Reader) (err error) {
  50         var assetID AssetID
  51         if _, err = assetID.ReadFrom(r); err != nil {
  52                 return err
  53         }
  54         a.AssetId = &assetID
  55         a.Amount, err = blockchain.ReadVarint63(r)
  56         return err
  57 }
  58
  59 func (a AssetAmount) WriteTo(w io.Writer) (int64, error) {
  60         n, err := a.AssetId.WriteTo(w)
  61         if err != nil {
  62                 return n, err
  63         }
  64         n2, err := blockchain.WriteVarint63(w, a.Amount)
  65         return n + int64(n2), err
  66 }
  67
  68 func (a *AssetAmount) Equal(other *AssetAmount) (eq bool, err error) {
  69         if a == nil || other == nil {
  70                 return false, errors.New("empty asset amount")
  71         }
  72         if a.AssetId == nil || other.AssetId == nil {
  73                 return false, errors.New("empty asset id")
  74         }
  75         return a.Amount == other.Amount && *a.AssetId == *other.AssetId, nil
  76 }