update neo to 3.2.1

Converter/Converter.csproj

@@ -2,13 +2,13 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
     <None Remove="Neo" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Neo" Version="3.0.2" />
+    <PackageReference Include="Neo" Version="3.0.3" />
   </ItemGroup>
 </Project>

Fura/Cache/Cache.cs

@@ -34,12 +34,14 @@ public static DBCache Ins
         }
         public CacheAddress cacheAddress { get; }
         public CacheAddressAsset cacheAddressAsset { get; }
+        public CacheMarket cacheMarket { get; }
         public CacheAsset cacheAsset { get; }
         public CacheCandidate cacheCandidate { get; }
         public CacheContract cacheContract { get; }
         public CacheNep11TransferNotification cacheNep11TransferNotification { get; }
         public CacheScVoteCall cacheScVoteCall { get; }
         public CacheTransferNotification cacheTransferNotification;
+        public CacheMatketNotification cacheMatketNotification;
         public CacheVote cacheVote { get; }
         public CacheScCall cacheScCall { get; }
         public CacheExecution cacheExecution { get; }
@@ -57,6 +59,9 @@ public DBCache()
             cacheAddressAsset = new CacheAddressAsset();
             caches.Add(cacheAddressAsset);
 
+            cacheMarket = new CacheMarket();
+            caches.Add(cacheMarket);
+
             cacheAsset = new CacheAsset();
             caches.Add(cacheAsset);
 
@@ -75,6 +80,9 @@ public DBCache()
             cacheTransferNotification = new CacheTransferNotification();
             caches.Add(cacheTransferNotification);
 
+            cacheMatketNotification = new CacheMatketNotification();
+            caches.Add(cacheMatketNotification);
+
             cacheVote = new CacheVote();
             caches.Add(cacheVote);
 

Fura/Cache/Cache_AddressAsset.cs

@@ -86,7 +86,7 @@ public void AddOrUpdate(UInt160 address, UInt160 asset, BigInteger balance, stri
             }
             else
             {
-                addressAssetModel.Balance = BsonDecimal128.Create(balance.ToString());
+                addressAssetModel.Balance = BsonDecimal128.Create(balance.ToString().WipeNumStrToFitDecimal128());
             }
             D_AddressAssetModel[(address, asset, tokenid)] = addressAssetModel;
         }

Fura/Cache/Cache_Asset.cs

@@ -85,7 +85,7 @@ public void AddOrUpdate(UInt160 contractHash, ulong firstTransferTime, string to
                 assetModel.TokenName = tokenName;
                 assetModel.Decimals = decimals;
                 assetModel.Symbol = symbol;
-                assetModel.TotalSupply = BsonDecimal128.Create(totalSupply.ToString());
+                assetModel.TotalSupply = BsonDecimal128.Create(totalSupply.ToString().WipeNumStrToFitDecimal128());
             }
             D_AssetModel[contractHash] = assetModel;
         }

Fura/Cache/Cache_Contract.cs

@@ -14,6 +14,7 @@ public class CacheContractParams
         public UInt160 Hash;
         public ulong Time;
         public UInt256 Txid;
+        public bool IsDestroy;
     }
 
     public class CacheContract : IDBCache
@@ -33,9 +34,9 @@ public void Clear()
             D_Contract = new ConcurrentDictionary<UInt160, CacheContractParams>();
         }
 
-        public void AddNeedUpdate(UInt160 contractHash, ulong createTime, UInt256 txid)
+        public void AddNeedUpdate(UInt160 contractHash, ulong createTime, UInt256 txid, bool isDestroy = false)
         {
-            D_Contract[contractHash] = new() { Hash = contractHash, Time = createTime, Txid = txid };
+            D_Contract[contractHash] = new() { Hash = contractHash, Time = createTime, Txid = txid , IsDestroy = isDestroy };
         }
 
         public List<CacheContractParams> GetNeedUpdate()
@@ -48,7 +49,7 @@ public void Update(NeoSystem system, DataCache snapshot)
             List<CacheContractParams> list = GetNeedUpdate();
             Parallel.For(0, list.Count, (i) =>
             {
-                AddOrUpdate(list[i].Hash, snapshot, list[i].Time, list[i].Txid);
+                AddOrUpdate(list[i].Hash, snapshot, list[i].Time, list[i].Txid, list[i].IsDestroy);
             });
         }
 
@@ -64,24 +65,21 @@ public ContractModel Get(UInt160 contractHash)
             }
         }
 
-        public void AddOrUpdate(UInt160 contractHash, DataCache snapshot, ulong createTime, UInt256 txid)
+        public void AddOrUpdate(UInt160 contractHash, DataCache snapshot, ulong createTime, UInt256 txid, bool isDestroy)
         {
             ContractModel contractModel = Get(contractHash);
-            if (contractModel is null)
+
+            if (isDestroy)
             {
-                StorageKey key = new KeyBuilder(Neo.SmartContract.Native.NativeContract.ContractManagement.Id, 8).Add(contractHash);
-                ContractState contract = snapshot.TryGet(key)?.GetInteroperable<ContractState>();
-                contractModel = new(contractHash, contract.Manifest.Name, contract.Id, contract.UpdateCounter, contract.Nef.ToJson(), contract.Manifest.ToJson(), createTime, txid);
+                contractModel = new ContractModel() { UpdateCounter = -1, CreateTime = createTime, Hash = contractHash, _ID = -999, CreateTxid = txid, Manifest = "", Name = "", Nef = ""};
             }
             else
             {
-                if (contractModel.CreateTime == createTime)
-                    return;
                 StorageKey key = new KeyBuilder(Neo.SmartContract.Native.NativeContract.ContractManagement.Id, 8).Add(contractHash);
                 ContractState contract = snapshot.TryGet(key)?.GetInteroperable<ContractState>();
-                if (contractModel.UpdateCounter == contract.UpdateCounter)
+                if (contractModel is not null && (contract is null || contractModel.CreateTxid == txid || contractModel.UpdateCounter == contract.UpdateCounter))
                     return;
-                contractModel = new(contractHash, contract.Manifest.Name, contract.Id, contract.UpdateCounter, contract.Nef.ToJson(), contract.Manifest.ToJson(), createTime, txid);
+                contractModel = new(contractHash, contract.Manifest.Name, contract.Id, (short)contract.UpdateCounter, contract.Nef.ToJson(), contract.Manifest.ToJson(), createTime, txid);
             }
             D_ContractModel[contractHash] = contractModel;
         }

Fura/Cache/Cache_GasMintBurn.cs

@@ -31,11 +31,24 @@ public void Clear()
 
         public void Save(Transaction tran)
         {
-            if(GasMintBurnParams.BlockIndex > 0 || GasMintBurnParams.BurnAmount > 0 || GasMintBurnParams.MintAmount > 0)
+            BigInteger totalBurnAmount = 0;
+            BigInteger totalMintAmount = 0;
+            if(GasMintBurnParams.BlockIndex > 0)
             {
-                GasMintBurnModel gasMintBurnModel = new GasMintBurnModel() { BurnAmount = BsonDecimal128.Create(GasMintBurnParams.BurnAmount.ToString()), MintAmount = BsonDecimal128.Create(GasMintBurnParams.MintAmount.ToString()), BlockIndex = GasMintBurnParams.BlockIndex };
-                tran.SaveAsync(gasMintBurnModel).Wait();
+                //获取上一个块的total来计算本块的数据
+                GasMintBurnModel gasMintBurnModel_Pre = GasMintBurnModel.Get(GasMintBurnParams.BlockIndex - 1);
+                totalBurnAmount = BigInteger.Parse(gasMintBurnModel_Pre.TotalBurnAmount.ToString());
+                totalMintAmount = BigInteger.Parse(gasMintBurnModel_Pre.TotalMintAmount.ToString());
             }
+            GasMintBurnModel gasMintBurnModel = new GasMintBurnModel()
+            {
+                BurnAmount = BsonDecimal128.Create(GasMintBurnParams.BurnAmount.ToString().WipeNumStrToFitDecimal128()),
+                TotalBurnAmount = BsonDecimal128.Create((totalBurnAmount + GasMintBurnParams.BurnAmount).ToString().WipeNumStrToFitDecimal128()),
+                MintAmount = BsonDecimal128.Create(GasMintBurnParams.MintAmount.ToString().WipeNumStrToFitDecimal128()),
+                TotalMintAmount = BsonDecimal128.Create((totalMintAmount + GasMintBurnParams.MintAmount).ToString().WipeNumStrToFitDecimal128()),
+                BlockIndex = GasMintBurnParams.BlockIndex
+            };
+            tran.SaveAsync(gasMintBurnModel).Wait();
         }
 
         public void Add(uint blockIndex, BigInteger burnAmount, BigInteger mintAmount)

Fura/Cache/Cache_Market.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using MongoDB.Entities;
+using Neo.Persistence;
+using Neo.Plugins.Models;
+using System.Numerics;
+using System.Threading.Tasks;
+
+namespace Neo.Plugins.Cache
+{
+    public class CacheMarketParams
+    {
+        public int NotificationIndex;
+        public bool SimpleUpdate;
+        public UInt160 Owner;
+        public UInt160 Asset;
+        public string TokenId;
+        public BigInteger Amount;
+        public UInt160 Market;
+        public uint AuctionType;
+        public UInt160 Auctor;
+        public UInt160 AuctionAsset;
+        public BigInteger AuctionAmount;
+        public ulong Deadline;
+        public UInt160 Bidder;
+        public BigInteger BidAmount;
+        public BigInteger Timestamp;
+    }
+
+    public class CacheMarket : IDBCache
+    {
+        private ConcurrentDictionary<(UInt160, UInt160, string), CacheMarketParams> D_Market;
+
+        private ConcurrentDictionary<(UInt160, UInt160, string), MarketModel> D_MarketModel;
+
+        public void AddNeedUpdate(int notificationIndex, bool simpleUpdate, UInt160 asset, UInt160 owner, string tokenid, BigInteger timestamp)
+        {
+            lock (D_Market)
+            {
+                if (!D_Market.ContainsKey((asset, owner, tokenid)) || notificationIndex > D_Market[(asset, owner, tokenid)].NotificationIndex )
+                {
+                    D_Market[(asset, owner, tokenid)] = new()
+                    {
+                        NotificationIndex = notificationIndex,
+                        SimpleUpdate = simpleUpdate,
+                        Asset = asset,
+                        TokenId = tokenid,
+                        Owner = owner,
+                        Timestamp = timestamp
+                    };
+                }
+            }
+
+        }
+
+        public void AddNeedUpdate(int notificationIndex, bool simpleUpdate, UInt160 asset, UInt160 owner, string tokenid, UInt160 market, BigInteger auctionType, UInt160 auctor, UInt160 auctionAsset, BigInteger auctionAmount, BigInteger deadline, UInt160 bidder, BigInteger bidAmount, BigInteger timestamp)
+        {
+            lock (D_Market)
+            {
+                if (!D_Market.ContainsKey((asset, owner, tokenid)) || notificationIndex > D_Market[(asset, owner, tokenid)].NotificationIndex)
+                {
+                    D_Market[(asset, owner, tokenid)] = new()
+                    {
+                        SimpleUpdate = simpleUpdate,
+                        Asset = asset,
+                        TokenId = tokenid,
+                        Owner = owner,
+                        Market = market,
+                        AuctionType = (uint)auctionType,
+                        Auctor = auctor,
+                        AuctionAsset = auctionAsset,
+                        AuctionAmount = auctionAmount,
+                        Deadline = (ulong)deadline,
+                        Bidder = bidder,
+                        BidAmount = bidAmount,
+                        Timestamp = timestamp,
+                        NotificationIndex = notificationIndex
+                    };
+                }
+            }
+        }
+
+        public List<CacheMarketParams> GetNeedUpdate()
+        {
+            return D_Market.Values.ToList();
+        }
+
+        public void Update(NeoSystem system, DataCache snapshot)
+        {
+            List<CacheMarketParams> list = GetNeedUpdate();
+            Parallel.For(0, list.Count, (i) =>
+            {
+                list[i].Amount = Neo.Plugins.VM.Helper.GetNep11BalanceOf(system, snapshot, list[i].Asset, list[i].TokenId, list[i].Owner);
+                AddOrUpdate(list[i]);
+            });
+        }
+
+        public MarketModel Get(UInt160 owner, UInt160 asset, string tokenid)
+        {
+            if (D_MarketModel.ContainsKey((owner, asset, tokenid)))
+            {
+                return D_MarketModel[(owner, asset, tokenid)];
+            }
+            else
+            {
+                return MarketModel.Get(owner, asset, tokenid);
+            }
+        }
+
+        public void AddOrUpdate(CacheMarketParams cacheMarketParams)
+        {
+            if (cacheMarketParams.Owner == null || cacheMarketParams.Asset == null)
+                return;
+            MarketModel marketModel = Get(cacheMarketParams.Owner, cacheMarketParams.Asset, cacheMarketParams.TokenId);
+            if (marketModel is null)
+            {
+                marketModel = new MarketModel()
+                {
+                    Asset = cacheMarketParams.Asset,
+                    TokenId = cacheMarketParams.TokenId,
+                    Owner = cacheMarketParams.Owner,
+                    Amount = MongoDB.Bson.BsonDecimal128.Create(cacheMarketParams.Amount.ToString().WipeNumStrToFitDecimal128()),
+                    Market = cacheMarketParams.Market,
+                    AuctionType = cacheMarketParams.AuctionType,
+                    AuctionAmount = MongoDB.Bson.BsonDecimal128.Create(cacheMarketParams.AuctionAmount.ToString().WipeNumStrToFitDecimal128()),
+                    AuctionAsset = cacheMarketParams.AuctionAsset,
+                    Auctor = cacheMarketParams.Auctor,
+                    BidAmount = MongoDB.Bson.BsonDecimal128.Create(cacheMarketParams.BidAmount.ToString().WipeNumStrToFitDecimal128()),
+                    Bidder = cacheMarketParams.Bidder,
+                    Deadline = cacheMarketParams.Deadline,
+                    Timestamp = (ulong)cacheMarketParams.Timestamp
+                };
+            }
+            else if(cacheMarketParams.SimpleUpdate)
+            {
+                marketModel.Timestamp = (ulong)cacheMarketParams.Timestamp;
+                marketModel.Amount = MongoDB.Bson.BsonDecimal128.Create(cacheMarketParams.Amount.ToString().WipeNumStrToFitDecimal128());
+            }
+            else
+            {
+                marketModel.Asset = cacheMarketParams.Asset;
+                marketModel.TokenId = cacheMarketParams.TokenId;
+                marketModel.Owner = cacheMarketParams.Owner;
+                marketModel.Amount = MongoDB.Bson.BsonDecimal128.Create(cacheMarketParams.Amount.ToString().WipeNumStrToFitDecimal128());
+                marketModel.Market = cacheMarketParams.Market;
+                marketModel.AuctionType = cacheMarketParams.AuctionType;
+                marketModel.AuctionAmount = MongoDB.Bson.BsonDecimal128.Create(cacheMarketParams.AuctionAmount.ToString().WipeNumStrToFitDecimal128());
+                marketModel.AuctionAsset = cacheMarketParams.AuctionAsset;
+                marketModel.Auctor = cacheMarketParams.Auctor;
+                marketModel.BidAmount = MongoDB.Bson.BsonDecimal128.Create(cacheMarketParams.BidAmount.ToString().WipeNumStrToFitDecimal128());
+                marketModel.Bidder = cacheMarketParams.Bidder;
+                marketModel.Deadline = cacheMarketParams.Deadline;
+                marketModel.Timestamp = (ulong)cacheMarketParams.Timestamp;
+            }
+            D_MarketModel[((marketModel.Owner, marketModel.Asset, marketModel.TokenId))] = marketModel;
+        }
+
+        public void Clear()
+        {
+            D_Market = new ConcurrentDictionary<(UInt160, UInt160, string), CacheMarketParams>();
+            D_MarketModel = new ConcurrentDictionary<(UInt160, UInt160, string), MarketModel>();
+        }
+
+        public void Save(Transaction tran)
+        {
+            if (D_MarketModel.Values.Count > 0)
+                tran.SaveAsync(D_MarketModel.Values).Wait();
+        }
+    }
+}
+

Fura/Cache/Cache_MarketNotification.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using Neo.Plugins.Models;
+using System.Numerics;
+using MongoDB.Entities;
+using System.Collections.Concurrent;
+using Neo.Persistence;
+
+namespace Neo.Plugins.Cache
+{
+    public class CacheMatketNotification : IDBCache
+    {
+        private ConcurrentBag<MarketNotificationModel> L_MarketNotificationModel;
+
+        public CacheMatketNotification()
+        {
+            L_MarketNotificationModel = new ConcurrentBag<MarketNotificationModel>();
+        }
+
+        public void Clear()
+        {
+            L_MarketNotificationModel = new ConcurrentBag<MarketNotificationModel>();
+        }
+
+        public void Add(UInt256 txid, UInt256 blockHash, UInt160 market, BigInteger nonce, UInt160 user, UInt160 asset, string tokenId, string eventName, string extendData, ulong timestamp)
+        {
+            MarketNotificationModel marketNotificationModel = new(txid, blockHash, nonce, user, market, asset, tokenId, eventName, extendData, timestamp);
+            L_MarketNotificationModel.Add(marketNotificationModel);
+        }
+
+        public void Update(NeoSystem system, DataCache snapshot)
+        {
+        }
+
+        public void Save(Transaction tran)
+        {
+            if (L_MarketNotificationModel.Count > 0)
+                tran.SaveAsync(L_MarketNotificationModel).Wait();
+        }
+    }
+}