public (IList <object>, IList <object>) Execute(RecipientState state, AbstractTrigger message)
{
var messagesResult = new List <object>();
BigInteger amount = message.Amount;
int count = state.Recipients.Count;
if (count == 0)
{
throw new Exception();
}
double weightsSum = 0;
foreach (TokenPairKey <double> recipient in state.Recipients)
{
weightsSum += recipient.GetTag();
}
BigInteger portion = amount / (int)weightsSum;
// We are going to lose tokens because we are using integer
foreach (TokenPairKey <double> recipient in state.Recipients)
{
//msg.To.ChangeAgentId(state.SelfId)
var command = new TransferTokenMessage(portion, new SingleAngentTokenKey(state.SelfId), recipient);
amount -= portion;
messagesResult.Add(command);
}
return(messagesResult, null);
}
public (IList <object>, IList <object>) Execute(RecipientState _, AbstractTrigger message)
{
if (message is TokensBurnedTriggerer msg)
{
var command = new MintTokenMessage(msg.Amount, msg.From);
return(new List <object>()
{
command
}, null);
}
return(null, null);
}
public (IList <object>, IList <object>) Execute(RecipientState state, AbstractTrigger message)
{
//here To is slef
if (message is TokensTransferedNotification msg)
{
var command = new BurnTokenMessage(msg.Amount, msg.To);
var publication = new TokensBurnedTriggerer(state.SelfId, msg.Amount, msg.To);
return(new List <object>()
{
command
}, new List <object>()
{
publication
});
}
return(null, null);
}
public (IList <object>, IList <object>) Execute(RecipientState state, AbstractTrigger message)
{
if (message is MockMessageTrigger msg)
{
var command = new MintTokenMessage(msg.Amount, msg.To.ChangeAgentId(state.SelfId));
var publication = new TokensMintedTriggerer(state.SelfId, msg.Amount, msg.To);
return(new List <object>()
{
command
}, new List <object>()
{
publication
});
}
return(null, null);
}
public (IList <object>, IList <object>) Execute(RecipientState state, AbstractTrigger message)
{
var messagesResult = new List <object>();
var publicationResult = new List <object>();
if (state is TokenBurnerState burnerState)
{
BigInteger amount = message.Amount;
while (amount > 0)
{
IAgentTokenKey recipient = state.Recipients.First();
TokensMintedTriggerer element = burnerState.MintedMessages.FirstOrDefault(x => x.To.Equals(recipient));
BigInteger debt = element.Amount;
IAgentTokenKey sender = element.To;
BurnTokenMessage command;
TokensBurnedTriggerer command2;
if (debt <= amount)
{
state.Recipients.Remove(recipient);
burnerState.MintedMessages.Remove(element);
amount -= debt;
command = new BurnTokenMessage(debt, sender);
command2 = new TokensBurnedTriggerer(state.SelfId, debt, recipient);
}
else
{
element.Amount -= amount;
command = new BurnTokenMessage(amount, sender);
command2 = new TokensBurnedTriggerer(state.SelfId, amount, recipient);
amount = 0;
}
messagesResult.Add(command);
publicationResult.Add(command2);
}
}
return(messagesResult, publicationResult);
}
public (IList <object>, IList <object>) Execute(RecipientState state, AbstractTrigger message)
{
var messagesResult = new List <object>();
if (message is TokensTransferedNotification msg && msg.To.GetAgentId().Equals(state.SelfId))
{
BigInteger amount = message.Amount;
int count = state.Recipients.Count;
if (count == 0)
{
throw new Exception();
}
BigInteger portion = amount / count;
// We are going to lose tokens because we are using integer
foreach (IAgentTokenKey recipient in state.Recipients)
{
//msg.To.ChangeAgentId(state.SelfId)
var command = new TransferTokenMessage(portion, new SingleAngentTokenKey(state.SelfId), recipient);
amount -= portion;
messagesResult.Add(command);
}
}
return(messagesResult, null);
}
public Task <AgentContext <RecipientState> > Run(object state, AgentCapability self, object message)
{
var agentState = state as RecipientState ?? new RecipientState();
var context = new AgentContext <RecipientState>(agentState, self);
if (message is AbstractTrigger msg)
{
var pair = new AgentTriggerPair(msg.Sender, message.GetType());
if (context.State.TriggerToAction.ContainsKey(pair))
{
(IList <object>, IList <object>)result = RecipientState.TriggerCheck(context.State, pair, msg);
foreach (var action in result.Item1)
{
context.SendMessage(context.State.TokenManagerAgent, action, null);
}
foreach (var publication in result.Item2)
{
context.MakePublication(publication);
}
return(Task.FromResult(context));
}
}
switch (message)
{
case TokenActionAgentInitMessage initMessage:
context.State.TokenManagerAgent = initMessage.TokenManagerAgentCapability;
context.State.TriggerToAction = initMessage.TriggererToAction ?? new Dictionary <AgentTriggerPair, ITriggeredAction>();
context.State.Recipients = initMessage.Recipients;// ?? new List<IAgentTokenKey>();
context.State.SelfId = self.Issuer;
var distributeCapabilityMessage = new DistributeCapabilitiesMessage
{
Id = self.Issuer,
AgentCapabilities = new Dictionary <string, AgentCapability>()
{
{ "AddRecipientMessage", context.IssueCapability(new[] { typeof(AddRecipientMessage) }) },
{ "RemoveRecipientMessage", context.IssueCapability(new[] { typeof(RemoveRecipientMessage) }) },
{ "AddTriggerToActionMessage", context.IssueCapability(new[] { typeof(AddTriggerToActionMessage) }) },
}
};
if (initMessage.Subscription != null)
{
foreach (var agent in initMessage.Subscription)
{
context.AddSubscription(agent);
}
}
context.SendMessage(initMessage.CreatorAgentCapability, distributeCapabilityMessage, null);
break;
case AddRecipientMessage addMessage:
if (context.State.AddRecipient(addMessage.Recipient))
{
context.MakePublication(new RecipientAddedPublication(addMessage.Recipient));
}
break;
case RemoveRecipientMessage removeMessage:
if (context.State.RemoveRecipient(removeMessage.Recipient))
{
context.MakePublication(new RecipientRemovedPublication(removeMessage.Recipient));
}
break;
case AddTriggerToActionMessage addTriggerMessage:
context.State.TriggerToAction.Add(addTriggerMessage.Trigger, addTriggerMessage.Action);
break;
}
return(Task.FromResult(context));
}
/// <summary>
/// Initializes a new instance of the <see cref="Recipient" /> class.
/// </summary>
/// <param name="requestedAmount">the amount that should be paid to the recipient. This can be in any currency, usually either the input or the output currency. If the value here is not the output currency we will calculate how much the recipient is going to get using the exchange rates active when the transaction was created. (required).</param>
/// <param name="requestedCurrency">the currency of the amount in 3-character alpha ISO 4217 currency format (required).</param>
/// <param name="payoutMethod">payoutMethod (required).</param>
/// <param name="metadata">Additional metadata that can be added to a recipient. These values will be returned on request.</param>
/// <param name="stateReasonDetails">stateReasonDetails.</param>
/// <param name="state">state.</param>
/// <param name="transactionExternalId">Optional ID that is supplied by partner linking it to the partner's own Transaction ID..</param>
/// <param name="transactionState">transactionState.</param>
public Recipient(decimal?requestedAmount = default(decimal?), string requestedCurrency = default(string), PayoutMethod payoutMethod = default(PayoutMethod), Object metadata = default(Object), RecipientStateReasonDetails stateReasonDetails = default(RecipientStateReasonDetails), RecipientState state = default(RecipientState), string transactionExternalId = default(string), TransactionState transactionState = default(TransactionState))
{
this.RequestedAmount = requestedAmount;
this.RequestedCurrency = requestedCurrency;
this.PayoutMethod = payoutMethod;
this.Metadata = metadata;
this.StateReasonDetails = stateReasonDetails;
this.State = state;
this.TransactionExternalId = transactionExternalId;
this.TransactionState = transactionState;
}
public Task <AgentContext <TokenBurnerState> > Run(object state, AgentCapability self, object message)
{
var agentState = state as TokenBurnerState ?? new TokenBurnerState();
var context = new AgentContext <TokenBurnerState>(agentState, self);
if (message is AbstractTrigger msg)
{
var pair = new AgentTriggerPair(msg.Sender, message.GetType());
if (context.State.TriggerToAction.ContainsKey(pair))
{
(IList <object>, IList <object>)result = RecipientState.TriggerCheck(context.State, pair, msg);
foreach (BurnTokenMessage action in result.Item1)
{
context.SendMessage(context.State.TokenManagerAgent, action, null);
}
foreach (var publication in result.Item2)
{
context.MakePublication(publication);
}
return(Task.FromResult(context));
}
}
switch (message)
{
case TokenActionAgentInitMessage initMessage:
context.State.TokenManagerAgent = initMessage.TokenManagerAgentCapability;
context.State.TriggerToAction = initMessage.TriggererToAction ?? new Dictionary <AgentTriggerPair, ITriggeredAction>();
context.State.SelfId = self.Issuer;
var distributeCapabilityMessage = new DistributeCapabilitiesMessage
{
Id = self.Issuer,
AgentCapabilities = new Dictionary <string, AgentCapability>()
{
{ "GetTokensMessage", context.IssueCapability(new[] { typeof(GetTokensMessage) }) },
{ "AddTriggerToActionMessage", context.IssueCapability(new[] { typeof(AddTriggerToActionMessage) }) },
}
};
if (initMessage.Subscription != null)
{
foreach (var agent in initMessage.Subscription)
{
context.AddSubscription(agent);
}
}
context.SendMessage(initMessage.CreatorAgentCapability, distributeCapabilityMessage, null);
break;
//Tokens are minted on burner's addres so that he can burn them,
//but they are actually for the user TokensMintedTriggerer.To
//He is added as recipient and he can take ownership of the tokens with GetTokensMessage
//This is done so that the system can work automaticly
case TokensMintedTriggerer transferedMessage:
if (context.State.AddRecipient(transferedMessage.To))
{
context.State.MintedMessages.Add(transferedMessage);
context.MakePublication(new RecipientAddedPublication(transferedMessage.To));
}
break;
case GetTokensMessage getTokensMessage:
IAgentTokenKey agentSender;
if (context.State.GetTokens(getTokensMessage.Recipient, getTokensMessage.Amount, out agentSender))
{
var transfer = new TransferTokenMessage(getTokensMessage.Amount, agentSender, getTokensMessage.Recipient);
context.SendMessage(null, transfer, null);
}
break;
case AddTriggerToActionMessage addTriggerMessage:
context.State.TriggerToAction.Add(addTriggerMessage.Trigger, addTriggerMessage.Action);
break;
}
return(Task.FromResult(context));
}
