⬆️ Bump libplanet to 4.2.0

.Lib9c.Tests/Action/Common/MockWorldState.cs

@@ -61,6 +61,11 @@ public MockWorldState SetAccountState(Address address, IAccountState accountStat
         public MockWorldState SetState(Address accountAddress, Address address, IValue state)
             => SetAccountState(accountAddress, GetMockAccountState(accountAddress).SetState(address, state));
 
+        public FungibleAssetValue GetBalance(Address address, Currency currency)
+            => GetAccountState(ReservedAddresses.LegacyAccount).Trie.Get(MockKeyConverters.ToFungibleAssetKey(address, currency)) is Integer value
+                ? FungibleAssetValue.FromRawValue(currency, value)
+                : currency * 0;
+
         public MockWorldState SetBalance(
             Address address,
             FungibleAssetValue amount)
@@ -128,6 +133,11 @@ public MockWorldState TransferBalance(
             => SubtractBalance(sender, currency, rawAmount)
             .AddBalance(recipient, currency, rawAmount);
 
+        public FungibleAssetValue GetTotalSupply(Currency currency)
+            => GetAccountState(ReservedAddresses.LegacyAccount).Trie.Get(MockKeyConverters.ToTotalSupplyKey(currency)) is Integer value
+                ? FungibleAssetValue.FromRawValue(currency, value)
+                : currency * 0;
+
         public MockWorldState SetTotalSupply(FungibleAssetValue amount)
             => SetTotalSupply(amount.Currency, amount.RawValue);
 
@@ -155,6 +165,11 @@ public MockWorldState SubtractTotalSupply(Currency currency, BigInteger rawAmoun
                 GetMockAccountState(ReservedAddresses.LegacyAccount)
                     .SubtractTotalSupply(currency, rawAmount));
 
+        public ValidatorSet GetValidatorSet()
+            => GetMockAccountState(ReservedAddresses.LegacyAccount).Trie.Get(MockKeyConverters.ValidatorSetKey) is { } value
+                ? new ValidatorSet(value)
+                : new ValidatorSet();
+
         public MockWorldState SetValidator(Validator validator)
             => SetAccountState(
                 ReservedAddresses.LegacyAccount,

.Lib9c.Tests/Policy/BlockPolicyTest.cs

@@ -396,7 +396,6 @@ public void EarnMiningGoldWhenSuccessMining()
             blockChain.Append(block, GenerateBlockCommit(block, adminPrivateKey));
             FungibleAssetValue actualBalance = blockChain
                 .GetWorldState()
-                .GetAccountState(ReservedAddresses.LegacyAccount)
                 .GetBalance(adminAddress, _currency);
             FungibleAssetValue expectedBalance = new FungibleAssetValue(_currency, 10, 0);
             Assert.True(expectedBalance.Equals(actualBalance));

.Lib9c.Tools/SubCommand/Account.cs

@@ -62,7 +62,6 @@ public void Balance(
                 FungibleAssetValue balance =
                     chain
                         .GetWorldState(offset.Hash)
-                        .GetAccountState(ReservedAddresses.LegacyAccount)
                         .GetBalance(addr, gold);
                 Console.WriteLine("{0}\t{1}", addr, balance);
                 return;
@@ -94,7 +93,6 @@ i.GoldDistributions is Bencodex.Types.List l
                         FungibleAssetValue balance =
                             chain
                                 .GetWorldState(offset.Hash)
-                                .GetAccountState(ReservedAddresses.LegacyAccount)
                                 .GetBalance(addr, gold);
                         Console.WriteLine("{0}\t{1}", addr, balance);
                         printed.Add(addr);

.Libplanet.Extensions.RemoteBlockChainStates/RemoteAccount.cs

@@ -22,21 +22,12 @@ public RemoteAccount(IAccountState baseState)
 
     public ITrie Trie => _baseState.Trie;
 
-    public FungibleAssetValue GetBalance(Address address, Currency currency)
-        => _baseState.GetBalance(address, currency);
-
     public IValue? GetState(Address address)
         => _baseState.GetState(address);
 
     public IReadOnlyList<IValue?> GetStates(IReadOnlyList<Address> addresses)
         => _baseState.GetStates(addresses);
 
-    public FungibleAssetValue GetTotalSupply(Currency currency)
-        => _baseState.GetTotalSupply(currency);
-
-    public ValidatorSet GetValidatorSet()
-        => _baseState.GetValidatorSet();
-
     public IAccount MintAsset(IActionContext context, Address recipient, FungibleAssetValue value)
     {
         throw new NotSupportedException();

.Libplanet.Extensions.RemoteBlockChainStates/RemoteAccountState.cs

@@ -8,9 +8,7 @@
 using Libplanet.Common;
 using Libplanet.Crypto;
 using Libplanet.Store.Trie;
-using Libplanet.Types.Assets;
 using Libplanet.Types.Blocks;
-using Libplanet.Types.Consensus;
 
 namespace Libplanet.Extensions.RemoteBlockChainStates;
 
@@ -121,195 +119,28 @@
         return response.Data.StateQuery.States is { } state ? codec.Decode(state) : null;
     }
 
-    public FungibleAssetValue GetBalance(Address address, Currency currency)
-    {
-        object? currencyInput = currency.TotalSupplyTrackable ? new
-        {
-            ticker = currency.Ticker,
-            decimalPlaces = currency.DecimalPlaces,
-            minters = currency.Minters?.Select(addr => addr.ToString()).ToArray(),
-            totalSupplyTrackable = currency.TotalSupplyTrackable,
-            maximumSupplyMajorUnit = currency.MaximumSupply.Value.MajorUnit,
-            maximumSupplyMinorUnit = currency.MaximumSupply.Value.MinorUnit,
-        } : new
-        {
-            ticker = currency.Ticker,
-            decimalPlaces = currency.DecimalPlaces,
-            minters = currency.Minters?.Select(addr => addr.ToString()).ToArray(),
-            totalSupplyTrackable = currency.TotalSupplyTrackable,
-        };
-        var response = _graphQlHttpClient.SendQueryAsync<GetBalanceResponseType>(
-            new GraphQLRequest(
-            @"query GetBalance(
-                $owner: Address!,
-                $currency: CurrencyInput!,
-                $accountStateRootHash: HashDigest_SHA256!)
-            {
-                stateQuery
-                {
-                    balance(
-                        owner: $owner,
-                        currency: $currency,
-                        accountStateRootHash: $accountStateRootHash)
-                    {
-                        string
-                    }
-                }
-            }",
-            operationName: "GetBalance",
-            variables: new
-            {
-                owner = address.ToString(),
-                currency = currencyInput,
-                accountStateRootHash = Trie.Hash is { } accountSrh
-                    ? ByteUtil.Hex(accountSrh.ByteArray)
-                    : null,
-            })).Result;
-
-        return FungibleAssetValue.Parse(currency, response.Data.StateQuery.Balance.String.Split()[0]);
-    }
-
-    public FungibleAssetValue GetTotalSupply(Currency currency)
-    {
-        object? currencyInput = currency.TotalSupplyTrackable ? new
-        {
-            ticker = currency.Ticker,
-            decimalPlaces = currency.DecimalPlaces,
-            minters = currency.Minters.Select(addr => addr.ToString()).ToArray(),
-            totalSupplyTrackable = currency.TotalSupplyTrackable,
-            maximumSupplyMajorUnit = currency.MaximumSupply.Value.MajorUnit,
-            maximumSupplyMinorUnit = currency.MaximumSupply.Value.MinorUnit,
-        } : new
-        {
-            ticker = currency.Ticker,
-            decimalPlaces = currency.DecimalPlaces,
-            minters = currency.Minters.Select(addr => addr.ToString()).ToArray(),
-            totalSupplyTrackable = currency.TotalSupplyTrackable,
-        };
-        var response = _graphQlHttpClient.SendQueryAsync<GetTotalSupplyResponseType>(
-            new GraphQLRequest(
-                @"query GetTotalSupply(
-                    $currency: CurrencyInput!,
-                    $accountStateRootHash: HashDigest_SHA256!)
-                {
-                    stateQuery
-                    {
-                        totalSupply(
-                            currency: $currency,
-                            offsetBlockHash: $offsetBlockHash
-                            accountStateRootHash: $accountStateRootHash)
-                        {
-                            string
-                        }
-                    }
-                }",
-                operationName: "GetTotalSupply",
-                variables: new
-                {
-                    currency = currencyInput,
-                    accountStateRootHash = Trie.Hash is { } accountSrh
-                        ? ByteUtil.Hex(accountSrh.ByteArray)
-                        : null,
-                })).Result;
-
-        return FungibleAssetValue.Parse(currency, response.Data.StateQuery.TotalSupply.String.Split()[0]);
-    }
-
-    public ValidatorSet GetValidatorSet()
-    {
-        var response = _graphQlHttpClient.SendQueryAsync<GetValidatorsResponseType>(
-            new GraphQLRequest(
-                @"query GetValidators(
-                    $accountStateRootHash: HashDigest_SHA256!)
-                {
-                    stateQuery
-                    {
-                        validators(
-                            accountStateRootHash: $accountStateRootHash)
-                        {
-                            publicKey
-                            power
-                        }
-                    }
-                }",
-                operationName: "GetValidators",
-                variables: new
-                {
-                    accountStateRootHash = Trie.Hash is { } accountSrh
-                        ? ByteUtil.Hex(accountSrh.ByteArray)
-                        : null,
-                })).Result;
-
-        return new ValidatorSet(response.Data.StateQuery.Validators
-            .Select(x =>
-                new Validator(new PublicKey(ByteUtil.ParseHex(x.PublicKey)), x.Power))
-            .ToList());
-    }
-
     private class GetAccountStateResponseType
     {
         public StateQueryWithAccountStateType StateQuery { get; set; }
     }
 
     private class StateQueryWithAccountStateType
     {
         public AccountStateType AccountState { get; set; }
     }
 
     public class AccountStateType
     {
         public string StateRootHash { get; set; }
     }
 
     private class GetStatesResponseType
     {
         public StateQueryWithStatesType StateQuery { get; set; }
     }
 
     private class StateQueryWithStatesType
     {
         public byte[] States { get; set; }
     }
-
-    private class GetBalanceResponseType
-    {
-        public StateQueryWithBalanceType StateQuery { get; set; }
-    }
-
-    private class StateQueryWithBalanceType
-    {
-        public FungibleAssetValueWithStringType Balance { get; set; }
-    }
-
-    private class FungibleAssetValueWithStringType
-    {
-        public string String { get; set; }
-    }
-
-    private class GetTotalSupplyResponseType
-    {
-        public StateQueryWithTotalSupplyType StateQuery { get; set; }
-    }
-
-    private class StateQueryWithTotalSupplyType
-    {
-        public FungibleAssetValueWithStringType TotalSupply { get; set; }
-    }
-
-    private class GetValidatorsResponseType
-    {
-        public StateQueryWithValidatorsType StateQuery { get; set; }
-    }
-
-    private class StateQueryWithValidatorsType
-    {
-        public ValidatorType[] Validators { get; set; }
-    }
-
-    private class ValidatorType
-    {
-        public string PublicKey { get; set; }
-
-        public long Power { get; set; }
-    }
 }