1
State.ProfitContract.Value =
2
    Context.GetContractAddressByName(SmartContractConstants.ProfitContractSystemName);
3
var schemeToken = HashHelper.ComputeFrom(Context.Self);
4
State.ProfitContract.CreateScheme.Send(new CreateSchemeInput
5
{
6
    Manager = Context.Self,
7
    CanRemoveBeneficiaryDirectly = true,
8
    IsReleaseAllBalanceEveryTimeByDefault = true,
9
    Token = schemeToken
10
});
11
State.ProfitSchemeId.Value = Context.GenerateId(State.ProfitContract.Value, schemeToken);

1
State.TokenHolderContract.Value =
2
    Context.GetContractAddressByName(SmartContractConstants.TokenHolderContractSystemName);
3
State.TokenHolderContract.CreateScheme.Send(new CreateTokenHolderProfitSchemeInput
4
{
5
    Symbol = Context.Variables.NativeSymbol,
6
    MinimumLockMinutes = input.MinimumLockMinutes
7
});
8
return new Empty();

1
public override Empty Donate(DonateInput input)
2
{
3
    State.TokenContract.TransferFrom.Send(new TransferFromInput
4
    {
5
        From = Context.Sender,
6
        Symbol = input.Symbol,
7
        Amount = input.Amount,
8
        To = Context.Self
9
    });
10
    State.TokenContract.Approve.Send(new ApproveInput
11
    {
12
        Symbol = input.Symbol,
13
        Amount = input.Amount,
14
        Spender = State.TokenHolderContract.Value
15
    });
16
    State.TokenHolderContract.ContributeProfits.Send(new ContributeProfitsInput
17
    {
18
        SchemeManager = Context.Self,
19
        Symbol = input.Symbol,
20
        Amount = input.Amount
21
    });
22
    Context.Fire(new DonationReceived
23
    {
24
        From = Context.Sender,
25
        Symbol = input.Symbol,
26
        Amount = input.Amount,
27
        PoolContract = Context.Self
28
    });
29
    var currentReceivedDividends = State.ReceivedDividends[Context.CurrentHeight];
30
    if (currentReceivedDividends != null && currentReceivedDividends.Value.ContainsKey(input.Symbol))
31
    {
32
        currentReceivedDividends.Value[input.Symbol] =
33
            currentReceivedDividends.Value[input.Symbol].Add(input.Amount);
34
    }
35
    else
36
    {
37
        currentReceivedDividends = new Dividends
38
        {
39
            Value =
40
            {
41
                {
42
                    input.Symbol, input.Amount
43
                }
44
            }
45
        };
46
    }
47
    State.ReceivedDividends[Context.CurrentHeight] = currentReceivedDividends;
48
    Context.LogDebug(() => string.Format("Contributed {0} {1}s to side chain dividends pool.", input.Amount, input.Symbol));
49
    return new Empty();
50
}

1
public override Empty Release(ReleaseInput input)
2
{
3
    State.TokenHolderContract.DistributeProfits.Send(new DistributeProfitsInput
4
    {
5
        SchemeManager = Context.Self
6
    });
7
    return new Empty();
8
}

1
public override SymbolList GetSymbolList(Empty input)
2
{
3
    return new SymbolList
4
    {
5
        Value =
6
        {
7
            GetDividendPoolScheme().ReceivedTokenSymbols
8
        }
9
    };
10
}
11
private Scheme GetDividendPoolScheme()
12
{
13
    if (State.DividendPoolSchemeId.Value == null)
14
    {
15
        var tokenHolderScheme = State.TokenHolderContract.GetScheme.Call(Context.Self);
16
        State.DividendPoolSchemeId.Value = tokenHolderScheme.SchemeId;
17
    }
18
    return Context.Call<Scheme>(
19
        Context.GetContractAddressByName(SmartContractConstants.ProfitContractSystemName),
20
        nameof(ProfitContractContainer.ProfitContractReferenceState.GetScheme),
21
        State.DividendPoolSchemeId.Value);
22
}

1
public override Dividends GetUndistributedDividends(Empty input)
2
{
3
    var scheme = GetDividendPoolScheme();
4
    return new Dividends
5
    {
6
        Value =
7
        {
8
            scheme.ReceivedTokenSymbols.Select(s => State.TokenContract.GetBalance.Call(new GetBalanceInput
9
            {
10
                Owner = scheme.VirtualAddress,
11
                Symbol = s
12
            })).ToDictionary(b => b.Symbol, b => b.Balance)
13
        }
14
    };
15
}

1
const long amount = 10_00000000;
2
var keyPair = SampleECKeyPairs.KeyPairs[0];
3
var address = Address.FromPublicKey(keyPair.PublicKey);
4
var acs10DemoContractStub =
5
    GetTester<ACS10DemoContractContainer.ACS10DemoContractStub>(DAppContractAddress, keyPair);
6
var tokenContractStub =
7
    GetTester<TokenContractContainer.TokenContractStub>(TokenContractAddress, keyPair);
8
var tokenHolderContractStub =
9
    GetTester<TokenHolderContractContainer.TokenHolderContractStub>(TokenHolderContractAddress,
10
        keyPair);

1
await tokenContractStub.Approve.SendAsync(new ApproveInput
2
{
3
    Spender = TokenHolderContractAddress,
4
    Symbol = "ELF",
5
    Amount = long.MaxValue
6
});
7
await tokenContractStub.Approve.SendAsync(new ApproveInput
8
{
9
    Spender = DAppContractAddress,
10
    Symbol = "ELF",
11
    Amount = long.MaxValue
12
});

1
await tokenHolderContractStub.RegisterForProfits.SendAsync(new RegisterForProfitsInput
2
{
3
    SchemeManager = DAppContractAddress,
4
    Amount = amount
5
});

1
await acs10DemoContractStub.Donate.SendAsync(new DonateInput
2
{
3
    Symbol = "ELF",
4
    Amount = amount
5
});

1
// Check undistributed dividends before releasing.
2
{
3
    var undistributedDividends =
4
        await acs10DemoContractStub.GetUndistributedDividends.CallAsync(new Empty());
5
    undistributedDividends.Value["ELF"].ShouldBe(amount);
6
}
7
var blockchainService = Application.ServiceProvider.GetRequiredService<IBlockchainService>();
8
var currentBlockHeight = (await blockchainService.GetChainAsync()).BestChainHeight;
9
var dividends =
10
    await acs10DemoContractStub.GetDividends.CallAsync(new Int64Value {Value = currentBlockHeight});
11
dividends.Value["ELF"].ShouldBe(amount);

1
await acs10DemoContractStub.Release.SendAsync(new ReleaseInput
2
{
3
    PeriodNumber = 1
4
});
5
// Check undistributed dividends after releasing.
6
{
7
    var undistributedDividends =
8
        await acs10DemoContractStub.GetUndistributedDividends.CallAsync(new Empty());
9
    undistributedDividends.Value["ELF"].ShouldBe(0);
10
}

1
var balanceBeforeClaimForProfits = await tokenContractStub.GetBalance.CallAsync(new GetBalanceInput
2
{
3
    Owner = address,
4
    Symbol = "ELF"
5
});
6
await tokenHolderContractStub.ClaimProfits.SendAsync(new ClaimProfitsInput
7
{
8
    SchemeManager = DAppContractAddress,
9
    Beneficiary = address
10
});
11
var balanceAfterClaimForProfits = await tokenContractStub.GetBalance.CallAsync(new GetBalanceInput
12
{
13
    Owner = address,
14
    Symbol = "ELF"
15
});
16
balanceAfterClaimForProfits.Balance.ShouldBe(balanceBeforeClaimForProfits.Balance + amount);