private void OnAddOutput(object sender, RoutedEventArgs e)
{
var cv = UIHelper.FindParent <CompositionView>(this);
var metaOutput = new MetaOutput(Guid.NewGuid(), "Output", BasicMetaTypes.GenericMeta);
var metaOp = cv.CompositionGraphView.CompositionOperator.Definition;
metaOp.AddOutput(metaOutput);
}
public static MetaOperator CreateSubMetaOp(float inputValue1, float inputValue2)
{
var input0 = new MetaInput(Guid.Parse("{AA522720-BB43-449F-9EAC-2FA2B13822C6}"), "Input0", BasicMetaTypes.FloatMeta, new Float(inputValue1), false);
var input1 = new MetaInput(Guid.Parse("{9FC79D4C-3639-4A44-9ED8-69E8C5FF3E05}"), "Input1", BasicMetaTypes.FloatMeta, new Float(inputValue2), false);
var output = new MetaOutput(Guid.Parse("{82B5272B-4884-4622-8891-2A9465550E18}"), "Output", BasicMetaTypes.FloatMeta);
var opPartID = Guid.Parse("{3A6EA1C9-F479-4D89-A117-286D4DA49BCF}");
var opPart = new MetaOperatorPart(Guid.Parse("{E6FA8A63-AAA5-4533-BC02-BD8E04157A2F}"))
{
IsMultiInput = true,
Name = "Func",
Type = FunctionType.Float
};
var metaOp = new MetaOperator(Guid.Parse("{5732DB8C-A1CC-48E7-85E3-3B3428957AF5}"))
{
Name = "SimpleOp",
Inputs = new[] { input0, input1 }.ToList(),
Outputs = new[] { output }.ToList(),
OperatorParts = new[] { new Tuple <Guid, MetaOperatorPart>(opPartID, opPart) }.ToList(),
Connections = new[]
{
new MetaConnection(Guid.Empty, input0.ID, Guid.Empty, opPartID),
new MetaConnection(Guid.Empty, input1.ID, Guid.Empty, opPartID),
new MetaConnection(Guid.Empty, opPartID, Guid.Empty, output.ID)
}.ToList()
};
var script = @"using System;
using System.Collections.Generic;
namespace Framefield.Core.IDca9a3a0e_c1c7_42b6_a0e5_cdb4c61d0b18
{
public class Class_Sub : OperatorPart.Function
{
public override OperatorPartContext Eval(OperatorPartContext context, List<OperatorPart> inputs, int outputIdx)
{
context.Value = input[0].Eval(context).Value - input[1].Eval(context).Value;
return context;
}
}
}";
opPart.Script = script;
opPart.Compile();
return(metaOp);
}
public void Replace_OperatorWith1InWithOperatorWith1In_ConnectionHasSameSourceAndNewOpAsTarget()
{
var internalSourceID = Guid.NewGuid();
var targetOpPartID = Guid.NewGuid();
var sourceOpPartID = Guid.NewGuid();
var connectionSourceOp = new MetaOperator(internalSourceID);
var metaOutput = new MetaOutput(sourceOpPartID, "targetOutput", new MetaOperatorPart(Guid.NewGuid()));
connectionSourceOp.AddOutput(metaOutput);
var internalOldID = Guid.NewGuid();
var floatMetaOld = OperatorTests.CreateMetaFloatWithoutConnections();
var floatInput = new MetaInput(targetOpPartID, "targetInputOld", new MetaOperatorPart(Guid.NewGuid()), new Float(5.0f), false);
floatMetaOld.AddInput(floatInput);
var floatMetaNew = OperatorTests.CreateMetaFloatWithoutConnections();
floatMetaNew.AddInput(new MetaInput(Guid.NewGuid(), "targetInputNew", new MetaOperatorPart(Guid.NewGuid()), new Float(5.0f), false));
var metacompositionOp = new MetaOperator(Guid.NewGuid());
metacompositionOp.AddOperator(connectionSourceOp);
metacompositionOp.AddOperator(floatMetaOld, internalOldID);
metacompositionOp.Connections = new[]
{
new MetaConnection(internalSourceID, sourceOpPartID, internalOldID, targetOpPartID)
}.ToList();
MetaManager.Instance.AddMetaOperator(floatMetaOld.ID, floatMetaOld);
MetaManager.Instance.AddMetaOperator(floatMetaNew.ID, floatMetaNew);
MetaManager.Instance.AddMetaOperator(metacompositionOp.ID, metacompositionOp);
var replaceCommand = new ReplaceOperatorCommand(metacompositionOp, floatMetaOld, floatMetaNew, internalOldID);
replaceCommand.Do();
var targetID = metacompositionOp.Connections.ElementAt(0).TargetOpID;
Assert.AreEqual(metacompositionOp.Connections.Count, 1);
Assert.AreEqual(metacompositionOp.Operators[targetID].Item1, floatMetaNew);
MetaManager.Instance.RemoveMetaOperator(metacompositionOp.ID);
MetaManager.Instance.RemoveMetaOperator(floatMetaNew.ID);
MetaManager.Instance.RemoveMetaOperator(floatMetaOld.ID);
}
public void Replace_OperatorWithMultiInputAnd3InComingConnections_SameOrderAtMultiInput()
{
var multiInputID1 = Guid.NewGuid();
var genericMultiInput1 = new MetaInput(multiInputID1, "multiInput", BasicMetaTypes.GenericMeta, new Generic(), true);
var multiInputID2 = Guid.NewGuid();
var genericMultiInput2 = new MetaInput(multiInputID2, "multiInput", BasicMetaTypes.GenericMeta, new Generic(), true);
var genericMultiInputOperatorOld = new MetaOperator(Guid.NewGuid());
genericMultiInputOperatorOld.AddInput(genericMultiInput1);
var genericMultiInputOperatorNew = new MetaOperator(Guid.NewGuid());
genericMultiInputOperatorNew.AddInput(genericMultiInput2);
var sourceOutputID1 = Guid.NewGuid();
var sourceOutput1 = new MetaOutput(sourceOutputID1, "sourceOutput1", BasicMetaTypes.GenericMeta);
var sourceOutputID2 = Guid.NewGuid();
var sourceOutput2 = new MetaOutput(sourceOutputID2, "sourceOutput2", BasicMetaTypes.GenericMeta);
var genericOutputOp1 = new MetaOperator(Guid.NewGuid());
genericOutputOp1.AddOutput(sourceOutput1);
var genericOutputOp2 = new MetaOperator(Guid.NewGuid());
genericOutputOp2.AddOutput(sourceOutput2);
var internalOldOperatorID = Guid.NewGuid();
var internalSourceID1 = Guid.NewGuid();
var internalSourceID2 = Guid.NewGuid();
var metacompositionOp = new MetaOperator(Guid.NewGuid());
metacompositionOp.AddOperator(genericMultiInputOperatorOld, internalOldOperatorID);
metacompositionOp.AddOperator(genericOutputOp1, internalSourceID1);
metacompositionOp.AddOperator(genericOutputOp2, internalSourceID2);
metacompositionOp.Connections = new List <MetaConnection>
{
new MetaConnection(internalSourceID1, sourceOutputID1, internalOldOperatorID, multiInputID1),
new MetaConnection(internalSourceID2, sourceOutputID2, internalOldOperatorID, multiInputID1),
new MetaConnection(internalSourceID1, sourceOutputID1, internalOldOperatorID, multiInputID1)
};
MetaManager.Instance.AddMetaOperator(genericMultiInputOperatorOld.ID, genericMultiInputOperatorOld);
MetaManager.Instance.AddMetaOperator(genericMultiInputOperatorNew.ID, genericMultiInputOperatorNew);
MetaManager.Instance.AddMetaOperator(metacompositionOp.ID, metacompositionOp);
var replaceCommand = new ReplaceOperatorCommand(metacompositionOp, genericMultiInputOperatorOld, genericMultiInputOperatorNew, internalOldOperatorID);
replaceCommand.Do();
var connectionsIntoNewMultiInput = metacompositionOp.Connections.Where(connection => connection.TargetOpPartID == multiInputID2).ToList();
Assert.IsTrue(connectionsIntoNewMultiInput.Count() == 3);
Assert.IsTrue(connectionsIntoNewMultiInput[0].SourceOpID == internalSourceID1);
Assert.IsTrue(connectionsIntoNewMultiInput[1].SourceOpID == internalSourceID2);
Assert.IsTrue(connectionsIntoNewMultiInput[2].SourceOpID == internalSourceID1);
MetaManager.Instance.RemoveMetaOperator(metacompositionOp.ID);
MetaManager.Instance.RemoveMetaOperator(genericMultiInputOperatorOld.ID);
MetaManager.Instance.RemoveMetaOperator(genericMultiInputOperatorNew.ID);
}
public void UndoReplace_OperatorWith1InAnd1OutWithOperatorWith1InAnd1Out_OldOperatorIsPartOfConnectionsAgain()
{
var internalSourceID = Guid.NewGuid();
var sourceOpPartID = Guid.NewGuid();
var connectionSourceOp = new MetaOperator(internalSourceID);
var metaOutput = new MetaOutput(sourceOpPartID, "targetOutput", new MetaOperatorPart(Guid.NewGuid()));
connectionSourceOp.AddOutput(metaOutput);
var internalTargetID = Guid.NewGuid();
var targetOpPartID = Guid.NewGuid();
var connectionTargetOp = new MetaOperator(internalTargetID);
var floatInput = new MetaInput(targetOpPartID, "targetInput", new MetaOperatorPart(Guid.NewGuid()), new Float(5.0f), false);
connectionTargetOp.AddInput(floatInput);
var internalOldID = Guid.NewGuid();
var sourceOpPartIDOld = Guid.NewGuid();
var targetOpPartIDOld = Guid.NewGuid();
var floatMetaOld = OperatorTests.CreateMetaFloatWithoutConnections();
var floatOutput = new MetaOutput(sourceOpPartIDOld, "sourceOutputOld", new MetaOperatorPart(Guid.NewGuid()));
floatMetaOld.AddOutput(floatOutput);
var floatInputOld = new MetaInput(targetOpPartIDOld, "targetInputOld", new MetaOperatorPart(Guid.NewGuid()), new Float(5.0f), false);
floatMetaOld.AddInput(floatInputOld);
var floatMetaNew = OperatorTests.CreateMetaFloatWithoutConnections();
floatMetaNew.AddInput(new MetaInput(Guid.NewGuid(), "targetInputNew", new MetaOperatorPart(Guid.NewGuid()), new Float(5.0f), false));
floatMetaNew.AddOutput(new MetaOutput(Guid.NewGuid(), "sourceOutputNew", new MetaOperatorPart(Guid.NewGuid())));
var metacompositionOp = new MetaOperator(Guid.NewGuid());
metacompositionOp.AddOperator(connectionTargetOp);
metacompositionOp.AddOperator(connectionSourceOp);
metacompositionOp.AddOperator(floatMetaOld, internalOldID);
metacompositionOp.Connections = new[]
{
new MetaConnection(internalSourceID, sourceOpPartID, internalOldID, targetOpPartIDOld),
new MetaConnection(internalOldID, sourceOpPartIDOld, internalTargetID, targetOpPartID)
}.ToList();
MetaManager.Instance.AddMetaOperator(floatMetaOld.ID, floatMetaOld);
MetaManager.Instance.AddMetaOperator(floatMetaNew.ID, floatMetaNew);
MetaManager.Instance.AddMetaOperator(metacompositionOp.ID, metacompositionOp);
var replaceCommand = new ReplaceOperatorCommand(metacompositionOp, floatMetaOld, floatMetaNew, internalOldID);
replaceCommand.Do();
replaceCommand.Undo();
var targetID = metacompositionOp.Connections.Single(connection => connection.SourceOpID == internalSourceID).TargetOpID;
var sourceID = metacompositionOp.Connections.Single(connection => connection.TargetOpID == internalTargetID).SourceOpID;
Assert.AreEqual(metacompositionOp.Connections.Count, 2);
Assert.AreEqual(metacompositionOp.Operators[targetID].Item1, floatMetaOld);
Assert.AreEqual(metacompositionOp.Operators[sourceID].Item1, floatMetaOld);
MetaManager.Instance.RemoveMetaOperator(metacompositionOp.ID);
MetaManager.Instance.RemoveMetaOperator(floatMetaNew.ID);
MetaManager.Instance.RemoveMetaOperator(floatMetaOld.ID);
}
private static bool IsNewValidOutput(MetaOutput matchingNameOutput, MetaOutput oldOutput)
{
return(matchingNameOutput != null &&
matchingNameOutput.OpPart.Type == oldOutput.OpPart.Type);
}
// todo: one big clunky method that could be split up
public void CreateTransaction(byte[] data)
{
int TotalKeySize = 96;
int TransactionRecipientSize = 49;
byte[] pubk = new byte[64];
byte[] seck = new byte[32];
Array.Copy(data, 0, pubk, 0, 64);
Array.Copy(data, 64, seck, 0, 32);
int TotalRecipients = (data.Length - TotalKeySize) / TransactionRecipientSize;
TransactionRecipient[] txrs = new TransactionRecipient[TotalRecipients];
for (int i = 0; i < TotalRecipients; i++)
{
byte[] rawamount = new byte[8];
byte[] rawrecipient = new byte[41];
Array.Copy(data, 96 + (i * TransactionRecipientSize), rawamount, 0, 8);
Array.Copy(data, 104 + (i * TransactionRecipientSize), rawrecipient, 0, 41);
txrs[i] = new TransactionRecipient
{
RawAmount = rawamount,
RawRecipient = rawrecipient
};
}
long TotalAmount = txrs.Map(rec => rec.Amount()).Reduce(R.Total, 0);
SharpKeyPair skp = new SharpKeyPair(pubk, seck);
Builder txb = new Builder(skp);
// All queued inputs as meta outputs, so that we can compare them against all the keypair's unspent outputs in the index... We don't want
// to use inputs that are already queued up in the blockchain.
MetaOutput[] QueuedInputsAsOutputs = Core.Blockchain.GetQueuedTransactions().FlatMap(tx => tx.Inputs).Map(input => input.AsMetaOutput()).ToArray();
IEnumerator <Output> utxos = ((IEnumerable <Output>)Core.Blockchain.GetUnspentOutputs(skp.GetAddress())).GetEnumerator();
while (txb.InputAmount() < TotalAmount && utxos.MoveNext())
{
// This expression somehow fails when put in the while test, so its an if here.
if (!QueuedInputsAsOutputs.Any(output => output.Equals((MetaOutput)utxos.Current)))
{
MetaOutput output = (MetaOutput)utxos.Current;
txb.AddInput(Core.Blockchain.GetTransaction(output.Transaction), output.Index);
}
}
foreach (TransactionRecipient txr in txrs)
{
txb.AddOutput(txr.Recipient(), txr.Amount());
}
try
{
Transaction newtx = txb.Make();
if (Core.Blockchain.QueueTransaction(newtx))
{
Send(Opcodes["CreateTransactionResponse"], OK());
}
else
{
Send(Opcodes["CreateTransactionResponse"], NOOP());
}
}
catch (Exception e)
{
Log.NewLine($"Failed to create a new transaction. {e.Message}");
Send(Opcodes["CreateTransactionResponse"], NOOP());
}
}
