/// <summary>
/// Sign a transaction payload
/// </summary>
/// <param name="rawTxn">The transaction to sign</param>
/// <returns>The signed transaction</returns>
public override async Task <string> Sign(RawPayload rawTxn)
{
if (!await RequestConfirmation(rawTxn))
{
throw new SubmitTransactionException("Signing rejected");
}
return(await Task.FromResult(TransactionManager.SignTransaction(rawTxn).EnsureHexPrefix()));
}
private static Payload ProcessChunk(BinaryReader reader)
{
Payload payload = null;
reader.ReadByte(); // START_BYTE
var chunkType = (SeStringChunkType)reader.ReadByte();
var chunkLen = GetInteger(reader);
var packetStart = reader.BaseStream.Position;
switch (chunkType)
{
case SeStringChunkType.Interactable:
{
var subType = (EmbeddedInfoType)reader.ReadByte();
switch (subType)
{
case EmbeddedInfoType.PlayerName:
payload = new PlayerPayload();
break;
case EmbeddedInfoType.ItemLink:
payload = new ItemPayload();
break;
case EmbeddedInfoType.Status:
payload = new StatusPayload();
break;
case EmbeddedInfoType.LinkTerminator:
// this has no custom handling and so needs to fallthrough to ensure it is captured
default:
Log.Verbose("Unhandled EmbeddedInfoType: {0}", subType);
// rewind so we capture the Interactable byte in the raw data
reader.BaseStream.Seek(-1, SeekOrigin.Current);
payload = new RawPayload((byte)chunkType);
break;
}
}
break;
default:
Log.Verbose("Unhandled SeStringChunkType: {0}", chunkType);
payload = new RawPayload((byte)chunkType);
break;
}
payload?.ProcessChunkImpl(reader, reader.BaseStream.Position + chunkLen - 1);
// read through the rest of the packet
var readBytes = (int)(reader.BaseStream.Position - packetStart);
reader.ReadBytes(chunkLen - readBytes + 1); // +1 for the END_BYTE marker
return(payload);
}
public void StartReceive(object inputindex)
{
ServicePointManager.ServerCertificateValidationCallback = MyRemoteCertificateValidationCallback;
while (true)
{
Thread.Sleep(1000);
try
{
string message = Post(URL, data);
RawPayload?.Invoke(message);
}
catch (Exception e)
{
ClientErrored?.Invoke("Error occured trying to read stream: " + e);
}
}
}
public void StartReceive()
{
while (true)
{
try
{
if (!_client.Connected)
{
Dispose();
ConnectAndAuthenticate(_config);
}
string message = _output.ReadLine();
RawPayload?.Invoke(message);
}
catch (Exception e)
{
ClientErrored?.Invoke("Error occured trying to read stream: " + e);
Reconnect(5000);
}
}
// ReSharper disable once FunctionNeverReturns
}
public virtual Response Post(string uri, RawPayload payload)
{
return(Request("POST", uri, payload));
}
public static Response Post(string uri, RawPayload payload)
{
return(_builder.POST(uri, payload));
}
public object Deserialize <T>(ILinkMessage <byte[]> message, IReadOnlyCollection <ITypeSchema> knownTypes)
{
var payload = new RawPayload(message.Properties.ContentType, message.Properties.Type, message.Body);
return(_payloadManager.FromRaw <T>(payload, knownTypes));
}
/// <summary>
/// This acts as a callback to porentially ask user permission before signing a transaction.
/// Must implement/match the WalletBase.SigningConfirmationDelegate delegate.
/// </summary>
/// <param name="txnToSign">The transaction that will be signed</param>
/// <returns>A boolean indicating whether or not to proceed with signing</returns>
public Task <bool> RequestSigningConfirmation(RawPayload txnToSign)
{
Console.WriteLine($"Signing transaction from {txnToSign.From} to {txnToSign.To}");
return(Task.FromResult(true));
}
/// <summary> /// Sign a transaction payload /// </summary> /// <param name="rawTxn">The transaction to sign</param> public abstract Task <string> Sign(RawPayload rawTxn);
protected async Task <bool> RequestConfirmation(RawPayload p)
{
return(SigningConfirmation == null || await SigningConfirmation.RequestSigningConfirmation(p));
}
