public void Equality()
{
FungibleAssetValue foo100a = FungibleAssetValue.FromRawValue(FOO, 100);
FungibleAssetValue foo100b = FungibleAssetValue.FromRawValue(FOO, 100);
FungibleAssetValue foo200a = FungibleAssetValue.FromRawValue(FOO, 200);
FungibleAssetValue foo200b = FungibleAssetValue.FromRawValue(FOO, 200);
FungibleAssetValue bar100a = FungibleAssetValue.FromRawValue(BAR, 100);
FungibleAssetValue bar100b = FungibleAssetValue.FromRawValue(BAR, 100);
FungibleAssetValue bar200a = FungibleAssetValue.FromRawValue(BAR, 200);
FungibleAssetValue bar200b = FungibleAssetValue.FromRawValue(BAR, 200);
Assert.Equal(foo100b, foo100a);
Assert.Equal(foo100b.GetHashCode(), foo100a.GetHashCode());
Assert.True(foo100b.Equals((object)foo100a));
Assert.True(foo100b == foo100a);
Assert.False(foo100b != foo100a);
Assert.Equal(foo200b, foo200a);
Assert.Equal(foo200b.GetHashCode(), foo200a.GetHashCode());
Assert.True(foo200b.Equals((object)foo200a));
Assert.True(foo200b == foo200a);
Assert.False(foo200b != foo200a);
Assert.Equal(bar100b, bar100a);
Assert.Equal(bar100b.GetHashCode(), bar100a.GetHashCode());
Assert.True(bar100b.Equals((object)bar100a));
Assert.True(bar100b == bar100a);
Assert.False(bar100b != bar100a);
Assert.Equal(bar200b, bar200a);
Assert.Equal(bar200b.GetHashCode(), bar200a.GetHashCode());
Assert.True(bar200b.Equals((object)bar200a));
Assert.True(bar200b == bar200a);
Assert.False(bar200b != bar200a);
Assert.NotEqual(foo100a, foo200a);
Assert.False(foo100a.Equals((object)foo200a));
Assert.False(foo100a == foo200a);
Assert.True(foo100a != foo200a);
Assert.NotEqual(foo100a, bar100a);
Assert.False(foo100a.Equals((object)bar100a));
Assert.False(foo100a == bar100a);
Assert.True(foo100a != bar100a);
Assert.NotEqual(foo100a, bar200a);
Assert.False(foo100a.Equals((object)bar200a));
Assert.False(foo100a == bar200a);
Assert.True(foo100a != bar200a);
Assert.NotEqual(bar100a, foo200a);
Assert.False(bar100a.Equals((object)foo200a));
Assert.False(bar100a == foo200a);
Assert.True(bar100a != foo200a);
Assert.NotEqual(foo100a, bar100a);
Assert.False(foo100a.Equals((object)bar100a));
Assert.False(foo100a == bar100a);
Assert.True(foo100a != bar100a);
Assert.NotEqual(foo100a, bar200a);
Assert.False(foo100a.Equals((object)bar200a));
Assert.False(foo100a == bar200a);
Assert.True(foo100a != bar200a);
Assert.False(foo100a.Equals(100));
Assert.False(foo200a.Equals(200));
}
public void Multiply()
{
FungibleAssetValue foo_2 = FungibleAssetValue.FromRawValue(FOO, -2);
FungibleAssetValue foo_1 = FungibleAssetValue.FromRawValue(FOO, -1);
FungibleAssetValue foo0 = new FungibleAssetValue(FOO);
FungibleAssetValue foo1 = FungibleAssetValue.FromRawValue(FOO, 1);
FungibleAssetValue foo2 = FungibleAssetValue.FromRawValue(FOO, 2);
FungibleAssetValue foo4 = FungibleAssetValue.FromRawValue(FOO, 4);
Assert.Equal(foo2, foo1 * 2);
Assert.Equal(foo2, 2 * foo1);
Assert.Equal(foo2, foo2 * 1);
Assert.Equal(foo2, 1 * foo2);
Assert.Equal(foo_2, foo2 * -1);
Assert.Equal(foo_2, -1 * foo2);
Assert.Equal(foo_2, foo_1 * 2);
Assert.Equal(foo_2, 2 * foo_1);
Assert.Equal(foo_1, foo_1 * 1);
Assert.Equal(foo_1, 1 * foo_1);
Assert.Equal(foo4, foo2 * 2);
Assert.Equal(foo4, 2 * foo2);
Assert.Equal(foo0, foo2 * 0);
Assert.Equal(foo0, 0 * foo2);
Assert.Equal(foo0, foo_1 * 0);
Assert.Equal(foo0, 0 * foo_1);
}
public void Serializable()
{
var minter = new Address(new byte[]
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
});
var account = new Address(new byte[]
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
});
var currency = new Currency("PLT", 0, minter);
var exc = new InsufficientBalanceException(
account,
FungibleAssetValue.FromRawValue(currency, 99),
"for testing"
);
var formatter = new BinaryFormatter();
using (var ms = new MemoryStream())
{
formatter.Serialize(ms, exc);
ms.Seek(0, SeekOrigin.Begin);
var deserialized = (InsufficientBalanceException)formatter.Deserialize(ms);
Assert.Equal("for testing", deserialized.Message);
Assert.Equal(account, deserialized.Address);
Assert.Equal(FungibleAssetValue.FromRawValue(currency, 99), deserialized.Balance);
}
}
public void String()
{
FungibleAssetValue foo100 = FungibleAssetValue.FromRawValue(FOO, 100);
FungibleAssetValue bar90000000 = FungibleAssetValue.FromRawValue(BAR, 90000000);
Assert.Equal("1 FOO", foo100.ToString());
Assert.Equal("90000000 BAR", bar90000000.ToString());
}
public void Abs()
{
FungibleAssetValue foo_3 = FungibleAssetValue.FromRawValue(FOO, -3);
FungibleAssetValue foo0 = new FungibleAssetValue(FOO);
FungibleAssetValue foo3 = FungibleAssetValue.FromRawValue(FOO, 3);
Assert.Equal(foo3, foo3.Abs());
Assert.Equal(foo3, foo_3.Abs());
Assert.Equal(foo0, foo0.Abs());
}
public void Negate()
{
FungibleAssetValue foo_3 = FungibleAssetValue.FromRawValue(FOO, -3);
FungibleAssetValue foo0 = new FungibleAssetValue(FOO);
FungibleAssetValue foo3 = FungibleAssetValue.FromRawValue(FOO, 3);
Assert.Equal(foo_3, -foo3);
Assert.Equal(foo3, -foo_3);
Assert.Equal(foo0, -foo0);
}
public void Serialize()
{
FungibleAssetValue foo100 = FungibleAssetValue.FromRawValue(FOO, 100);
var f = new BinaryFormatter();
var s = new MemoryStream();
f.Serialize(s, foo100);
s.Seek(0, SeekOrigin.Begin);
var deserialized = f.Deserialize(s);
Assert.IsType <FungibleAssetValue>(deserialized);
Assert.Equal(foo100, (FungibleAssetValue)deserialized);
}
public FungibleAssetValue GetBalance(Address address, Currency currency)
{
var result = _service.GetBalance(
address.ToByteArray(),
_codec.Encode(currency.Serialize())
);
byte[] raw = result.ResponseAsync.Result;
var serialized = (Bencodex.Types.List)_codec.Decode(raw);
return(FungibleAssetValue.FromRawValue(
CurrencyExtensions.Deserialize((Bencodex.Types.Dictionary)serialized.ElementAt(0)),
serialized.ElementAt(1).ToBigInteger()));
}
public void Subtract()
{
FungibleAssetValue foo_1 = FungibleAssetValue.FromRawValue(FOO, -1);
FungibleAssetValue foo0 = new FungibleAssetValue(FOO);
FungibleAssetValue foo1 = FungibleAssetValue.FromRawValue(FOO, 1);
FungibleAssetValue foo2 = FungibleAssetValue.FromRawValue(FOO, 2);
FungibleAssetValue bar3 = FungibleAssetValue.FromRawValue(BAR, 3);
Assert.Equal(foo0, foo1 - foo1);
Assert.Equal(foo_1, foo1 - foo2);
Assert.Equal(foo2, foo1 - foo_1);
Assert.Equal(foo0, foo_1 - foo_1);
Assert.Throws <ArgumentException>(() => bar3 - foo1);
}
public static Block <T> AttachStateRootHash <T>(
this Block <T> block, IStateStore stateStore, IAction blockAction)
where T : IAction, new()
{
IValue StateGetter(
Address address, HashDigest <SHA256>?blockHash, StateCompleter <T> stateCompleter) =>
blockHash is null
? null
: stateStore.GetState(ToStateKey(address), blockHash.Value);
FungibleAssetValue FungibleAssetValueGetter(
Address address,
Currency currency,
HashDigest <SHA256>?blockHash,
FungibleAssetStateCompleter <T> stateCompleter)
{
if (blockHash is null)
{
return(FungibleAssetValue.FromRawValue(currency, 0));
}
IValue value = stateStore.GetState(
ToFungibleAssetKey(address, currency), blockHash.Value);
return(FungibleAssetValue.FromRawValue(
currency,
value is Bencodex.Types.Integer i ? i.Value : 0));
}
var blockEvaluator = new BlockEvaluator <T>(
blockAction, StateGetter, FungibleAssetValueGetter, null);
var actionEvaluationResult = blockEvaluator
.EvaluateActions(block, StateCompleterSet <T> .Reject)
.GetTotalDelta(ToStateKey, ToFungibleAssetKey);
stateStore.SetStates(block, actionEvaluationResult);
if (stateStore is TrieStateStore trieStateStore)
{
block = new Block <T>(block, trieStateStore.GetRootHash(block.Hash));
stateStore.SetStates(block, actionEvaluationResult);
}
return(block);
}
public void Add()
{
FungibleAssetValue foo_1 = FungibleAssetValue.FromRawValue(FOO, -1);
FungibleAssetValue foo0 = new FungibleAssetValue(FOO);
FungibleAssetValue foo1 = FungibleAssetValue.FromRawValue(FOO, 1);
FungibleAssetValue foo2 = FungibleAssetValue.FromRawValue(FOO, 2);
FungibleAssetValue foo3 = FungibleAssetValue.FromRawValue(FOO, 3);
FungibleAssetValue bar3 = FungibleAssetValue.FromRawValue(BAR, 3);
Assert.Equal(foo1, foo1 + foo0);
Assert.Equal(foo1, foo0 + foo1);
Assert.Equal(foo2, foo1 + foo1);
Assert.Equal(foo3, foo1 + foo2);
Assert.Equal(foo3, foo2 + foo1);
Assert.Equal(foo1, foo2 + foo_1);
Assert.Equal(foo1, foo_1 + foo2);
Assert.Equal(foo_1, foo_1 + foo0);
Assert.Equal(foo_1, foo0 + foo_1);
Assert.Throws <ArgumentException>(() => foo1 + bar3);
}
public void Compare()
{
FungibleAssetValue foo100a = FungibleAssetValue.FromRawValue(FOO, 100);
FungibleAssetValue foo100b = FungibleAssetValue.FromRawValue(FOO, 100);
FungibleAssetValue foo200 = FungibleAssetValue.FromRawValue(FOO, 200);
FungibleAssetValue bar100 = FungibleAssetValue.FromRawValue(BAR, 100);
Assert.Equal(0, foo100a.CompareTo(foo100b));
Assert.Equal(0, foo100a.CompareTo((object)foo100b));
Assert.False(foo100a < foo100b);
Assert.True(foo100a <= foo100b);
Assert.False(foo100a > foo100b);
Assert.True(foo100a >= foo100b);
Assert.True(foo100a.CompareTo(foo200) < 0);
Assert.True(foo100a.CompareTo((object)foo200) < 0);
Assert.True(foo100a < foo200);
Assert.True(foo100a <= foo200);
Assert.False(foo100a > foo200);
Assert.False(foo100a >= foo200);
Assert.True(foo200.CompareTo(foo100b) > 0);
Assert.True(foo200.CompareTo((object)foo100b) > 0);
Assert.False(foo200 < foo100b);
Assert.False(foo200 <= foo100b);
Assert.True(foo200 > foo100b);
Assert.True(foo200 >= foo100b);
Assert.Throws <ArgumentException>(() => foo100a.CompareTo(bar100));
Assert.Throws <ArgumentException>(() => foo100a.CompareTo((object)bar100));
Assert.Throws <ArgumentException>(() => foo100a < bar100);
Assert.Throws <ArgumentException>(() => foo100a <= bar100);
Assert.Throws <ArgumentException>(() => foo100a > bar100);
Assert.Throws <ArgumentException>(() => foo100a >= bar100);
Assert.Throws <ArgumentException>(() => foo100a.CompareTo(100));
}
public void DivRem()
{
FungibleAssetValue foo7 = FungibleAssetValue.FromRawValue(FOO, 7);
FungibleAssetValue foo6 = FungibleAssetValue.FromRawValue(FOO, 6);
FungibleAssetValue foo3 = FungibleAssetValue.FromRawValue(FOO, 3);
FungibleAssetValue foo2 = FungibleAssetValue.FromRawValue(FOO, 2);
FungibleAssetValue foo1 = FungibleAssetValue.FromRawValue(FOO, 1);
FungibleAssetValue foo0 = new FungibleAssetValue(FOO);
FungibleAssetValue rem;
Assert.Equal((foo6, foo0), foo6.DivRem(1));
Assert.Equal(foo6, foo6.DivRem(1, out rem));
Assert.Equal(foo0, rem);
Assert.Equal(foo0, foo6 % 1);
Assert.Equal((foo2, foo0), foo6.DivRem(3));
Assert.Equal(foo2, foo6.DivRem(3, out rem));
Assert.Equal(foo0, rem);
Assert.Equal(foo0, foo6 % 3);
Assert.Equal((foo2, foo1), foo7.DivRem(3));
Assert.Equal(foo2, foo7.DivRem(3, out rem));
Assert.Equal(foo1, rem);
Assert.Equal(foo1, foo7 % 3);
Assert.Equal((foo0, foo6), foo6.DivRem(7));
Assert.Equal(foo0, foo6.DivRem(7, out rem));
Assert.Equal(foo6, rem);
Assert.Equal(foo6, foo6 % 7);
Assert.Equal((foo0, foo0), foo0.DivRem(2));
Assert.Equal(foo0, foo0.DivRem(2, out rem));
Assert.Equal(foo0, rem);
Assert.Equal(foo0, foo0 % 2);
Assert.Equal((6, foo0), foo6.DivRem(foo1));
Assert.Equal(6, foo6.DivRem(foo1, out rem));
Assert.Equal(foo0, rem);
Assert.Equal(foo0, foo6 % foo1);
Assert.Equal((2, foo0), foo6.DivRem(foo3));
Assert.Equal(2, foo6.DivRem(foo3, out rem));
Assert.Equal(foo0, rem);
Assert.Equal(foo0, foo6 % foo3);
Assert.Equal((2, foo1), foo7.DivRem(foo3));
Assert.Equal(2, foo7.DivRem(foo3, out rem));
Assert.Equal(foo1, rem);
Assert.Equal(foo1, foo7 % foo3);
Assert.Equal((0, foo6), foo6.DivRem(foo7));
Assert.Equal(0, foo6.DivRem(foo7, out rem));
Assert.Equal(foo6, rem);
Assert.Equal(foo6, foo6 % foo7);
Assert.Equal((0, foo0), foo0.DivRem(foo2));
Assert.Equal(0, foo0.DivRem(foo2, out rem));
Assert.Equal(foo0, rem);
Assert.Equal(foo0, foo0 % foo2);
Assert.Throws <DivideByZeroException>(() => foo1.DivRem(0));
Assert.Throws <DivideByZeroException>(() => foo1.DivRem(0, out rem));
Assert.Throws <DivideByZeroException>(() => foo1 % 0);
Assert.Throws <DivideByZeroException>(() => foo1.DivRem(foo0));
Assert.Throws <DivideByZeroException>(() => foo1.DivRem(foo0, out rem));
Assert.Throws <DivideByZeroException>(() => foo1 % foo0);
FungibleAssetValue bar1 = FungibleAssetValue.FromRawValue(BAR, 1);
Assert.Throws <ArgumentException>(() => bar1.DivRem(foo1));
Assert.Throws <ArgumentException>(() => bar1.DivRem(foo1, out rem));
Assert.Throws <ArgumentException>(() => bar1 % foo1);
}
public FungibleAssetValue GetBalance(Address address, Currency currency) =>
_rawStates.TryGetValue(ToBalanceKey(address, currency), out IValue value)
? FungibleAssetValue.FromRawValue(currency, value is Bencodex.Types.Integer i ? i.Value : 0)
: currency * 0;
public async Task Query(int goldBalance, string decimalString)
{
const string query = @"
{
address
avatarStates {
address
name
}
gold
monsterCollectionRound
monsterCollectionLevel
hasTradedItem
}";
var goldCurrency = new Currency("NCG", 2, minter: null);
var agentState = new AgentState(new Address());
agentState.avatarAddresses[0] = Fixtures.AvatarAddress;
Address monsterCollectionAddress = MonsterCollectionState.DeriveAddress(agentState.address, 0);
MonsterCollectionState monsterCollectionState = new MonsterCollectionState(monsterCollectionAddress, 7, 0, Fixtures.TableSheetsFX.MonsterCollectionRewardSheet);
IValue?GetStateMock(Address address)
{
if (GoldCurrencyState.Address == address)
{
return(new GoldCurrencyState(goldCurrency).Serialize());
}
if (monsterCollectionAddress == address)
{
return(monsterCollectionState.Serialize());
}
if (Fixtures.AvatarAddress == address)
{
return(Fixtures.AvatarStateFX.Serialize());
}
return(null);
}
FungibleAssetValue GetBalanceMock(Address address, Currency currency)
{
if (address == agentState.address)
{
return(new FungibleAssetValue(currency, goldBalance, 0));
}
return(FungibleAssetValue.FromRawValue(currency, 0));
}
var queryResult = await ExecuteQueryAsync <AgentStateType>(
query,
source : (
agentState,
(AccountStateGetter)GetStateMock,
(AccountBalanceGetter)GetBalanceMock)
);
var expected = new Dictionary <string, object>()
{
["address"] = agentState.address.ToString(),
["avatarStates"] = new List <Dictionary <string, object> >
{
new Dictionary <string, object>
{
["address"] = Fixtures.AvatarAddress.ToString(),
["name"] = Fixtures.AvatarStateFX.name,
},
},
["gold"] = decimalString,
["monsterCollectionRound"] = 0L,
["monsterCollectionLevel"] = 7L,
["hasTradedItem"] = false,
};
Assert.Equal(expected, queryResult.Data);
}
public void Constructor()
{
FungibleAssetValue v;
v = new FungibleAssetValue(FOO, 123, 45);
Assert.Equal(new FungibleAssetValue(FOO, 1, 123, 45), v);
Assert.Equal(12345, v.RawValue);
Assert.Equal(123, v.MajorUnit);
Assert.Equal(45, v.MinorUnit);
Assert.Equal(1, v.Sign);
v = new FungibleAssetValue(FOO, 456, 9);
Assert.Equal(new FungibleAssetValue(FOO, 1, 456, 9), v);
Assert.Equal(45609, v.RawValue);
Assert.Equal(456, v.MajorUnit);
Assert.Equal(9, v.MinorUnit);
Assert.Equal(1, v.Sign);
v = new FungibleAssetValue(FOO, 0, 10);
Assert.Equal(new FungibleAssetValue(FOO, 1, 0, 10), v);
Assert.Equal(10, v.RawValue);
Assert.Equal(0, v.MajorUnit);
Assert.Equal(10, v.MinorUnit);
Assert.Equal(1, v.Sign);
v = new FungibleAssetValue(FOO, 0, 9);
Assert.Equal(new FungibleAssetValue(FOO, 1, 0, 9), v);
Assert.Equal(9, v.RawValue);
Assert.Equal(0, v.MajorUnit);
Assert.Equal(9, v.MinorUnit);
Assert.Equal(1, v.Sign);
v = new FungibleAssetValue(FOO, -789, 1);
Assert.Equal(new FungibleAssetValue(FOO, -1, 789, 1), v);
Assert.Equal(-78901, v.RawValue);
Assert.Equal(789, v.MajorUnit);
Assert.Equal(1, v.MinorUnit);
Assert.Equal(-1, v.Sign);
v = new FungibleAssetValue(FOO, 0, -2);
Assert.Equal(new FungibleAssetValue(FOO, -1, 0, 2), v);
Assert.Equal(-2, v.RawValue);
Assert.Equal(0, v.MajorUnit);
Assert.Equal(2, v.MinorUnit);
Assert.Equal(-1, v.Sign);
v = new FungibleAssetValue(FOO, 123, 0);
Assert.Equal(new FungibleAssetValue(FOO, 1, 123, 0), v);
Assert.Equal(12300, v.RawValue);
Assert.Equal(123, v.MajorUnit);
Assert.Equal(0, v.MinorUnit);
Assert.Equal(1, v.Sign);
v = new FungibleAssetValue(BAR, 1, 0);
Assert.Equal(new FungibleAssetValue(BAR, 1, 1, 0), v);
Assert.Equal(FungibleAssetValue.FromRawValue(BAR, 1), v);
Assert.Equal(1, v.RawValue);
Assert.Equal(1, v.MajorUnit);
Assert.Equal(0, v.MinorUnit);
Assert.Equal(1, v.Sign);
v = new FungibleAssetValue(FOO, 0, 0);
Assert.Equal(new FungibleAssetValue(FOO, 0, 0, 0), v);
Assert.Equal(new FungibleAssetValue(FOO), v);
Assert.Equal(0, v.RawValue);
Assert.Equal(0, v.MajorUnit);
Assert.Equal(0, v.MinorUnit);
Assert.Equal(0, v.Sign);
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, -2, 1, 0));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, 2, 1, 0));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, 0, 1, 0));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, 0, 0, 1));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, 1, -1, 0));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, 1, 1, -1));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, 1, 1, 100));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, 10, -10));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, -10, -10));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(FOO, 1, 100));
Assert.Throws <ArgumentException>(() => new FungibleAssetValue(BAR, 1, 2));
}
.ToImmutableDictionary(
pair => pair.Item1,
pair => FungibleAssetValue.FromRawValue(pair.Item1, (BigInteger)pair.Item2)
)
);