public async Task <string> SendTransactionModule(
byte[] senderPrivateKey, string sender, byte[] module)
{
var senderAccount = await GetAccountInfoAsync(sender);
RawTransactionLCS rawTr = new RawTransactionLCS()
{
ExpirationTime = (ulong)DateTimeOffset.UtcNow.AddSeconds(60)
.ToUnixTimeSeconds(),
GasUnitPrice = 0,
MaxGasAmount = 100000,
SequenceNumber = senderAccount.SequenceNumber
};
rawTr.TransactionPayload = new TransactionPayloadLCS();
rawTr.TransactionPayload.PayloadType = (uint)ETransactionPayloadLCS.Module;
rawTr.TransactionPayload.Module = new ModuleLCS()
{
Code = module
};
rawTr.Sender = new AddressLCS(sender);
var result = await _service.SendTransactionAsync(senderPrivateKey, rawTr);
return(result.ToString());
}
SendTransactionAsync(
byte[] privateKey, RawTransactionLCS rawTransaction)
{
var bytesTrx = LCSCore.LCSerialize(rawTransaction);
//Console.WriteLine();
//Console.WriteLine(bytesTrx.ByteArryToString());
//Console.WriteLine();
LibraHasher libraHasher = new LibraHasher(EHashType.RawTransaction);
var hash = libraHasher.GetHash(bytesTrx);
var key = Key.Import(SignatureAlgorithm.Ed25519, privateKey,
KeyBlobFormat.RawPrivateKey);
AdmissionControl.SubmitTransactionRequest req =
new AdmissionControl.SubmitTransactionRequest();
req.Transaction = new SignedTransaction();
List <byte> retArr = new List <byte>();
retArr = retArr.Concat(bytesTrx).ToList();
retArr = retArr.Concat(
LCSCore.LCSerialize(key.Export(KeyBlobFormat.RawPublicKey))).ToList();
var sig = SignatureAlgorithm.Ed25519.Sign(key, hash);
retArr = retArr.Concat(LCSCore.LCSerialize(sig)).ToList();
req.Transaction.TxnBytes = ByteString.CopyFrom(retArr.ToArray());
var result = await _client.SubmitTransactionAsync(
req, new Metadata());
return(result);
}
public byte[] RawTransactionToByte(RawTransactionLCS source)
{
List <byte> retArr = new List <byte>();
//TO-DO
var firstUint = U32ToByte(source.FirstUint);
retArr = retArr.Concat(firstUint).ToList();
var sender = LCSCore.LCSerialize(source.Sender);
retArr = retArr.Concat(sender).ToList();
var sn = U64ToByte(source.SequenceNumber);
retArr = retArr.Concat(sn).ToList();
var payload = LCSCore.LCSerialize(source.TransactionPayload);
retArr = retArr.Concat(payload).ToList();
var maxGasAmount = U64ToByte(source.MaxGasAmount);
retArr = retArr.Concat(maxGasAmount).ToList();
var gasUnitPrice = U64ToByte(source.GasUnitPrice);
retArr = retArr.Concat(gasUnitPrice).ToList();
var expirationTime = U64ToByte(source.ExpirationTime);
retArr = retArr.Concat(expirationTime).ToList();
return(retArr.ToArray());
}
public byte[] RawTransactionToByte(RawTransactionLCS source)
{
List <byte> retArr = new List <byte>();
var sender = AddressToByte(source.Sender);
retArr = retArr.Concat(sender).ToList();
var sn = U64ToByte(source.SequenceNumber);
retArr = retArr.Concat(sn).ToList();
var payload = TransactionPayloadToByte(source.TransactionPayload);
retArr = retArr.Concat(payload).ToList();
var maxGasAmount = U64ToByte(source.MaxGasAmount);
retArr = retArr.Concat(maxGasAmount).ToList();
var gasUnitPrice = U64ToByte(source.GasUnitPrice);
retArr = retArr.Concat(gasUnitPrice).ToList();
var expirationTime = U64ToByte(source.ExpirationTime);
retArr = retArr.Concat(expirationTime).ToList();
return(retArr.ToArray());
}
public void RawTransaction()
{
var writeSet = new WriteSetLCS();
writeSet.WriteSet = new Dictionary <AccessPathLCS, WriteOpLCS>();
writeSet.WriteSet.Add(new AccessPathLCS
{
Address = new AddressLCS
{
Value = "a71d76faa2d2d5c3224ec3d41deb293973564a791e55c6782ba76c2bf0495f9a"
},
Path = "01217da6c6b3e19f1825cfb2676daecce3bf3de03cf26647c78df00b371b25cc97".FromHexToBytes()
}, new WriteOpLCS
{
WriteOpType = WriteOpType.Deletion
});
writeSet.WriteSet.Add(new AccessPathLCS
{
Address = new AddressLCS
{
Value = "c4c63f80c74b11263e421ebf8486a4e398d0dbc09fa7d4f62ccdb309f3aea81f"
},
Path = "01217da6c6b3e19f18".FromHexToBytes()
}, new WriteOpLCS
{
WriteOpType = WriteOpType.Value,
Value = "cafed00d".FromHexToBytes()
});
var transaction = new RawTransactionLCS
{
Sender = new AddressLCS
{
Value = "c3398a599a6f3b9f30b635af29f2ba046d3a752c26e9d0647b9647d1f4c04ad4"
},
SequenceNumber = 32,
TransactionPayload = new TransactionPayloadLCS
{
PayloadType = TransactionPayloadType.WriteSet,
WriteSet = writeSet
},
MaxGasAmount = 0UL,
GasUnitPrice = 0UL,
ExpirationTime = 18446744073709551615UL
};
var actual = LCSCore.LCSDeserialization(transaction).ByteArrayToString();
var expected = "c3398a599a6f3b9f30b635af29f2ba046d3a752c26e9d0647b9647d1f4c04ad420000000000000000100000002000000a71d76faa2d2d5c3224ec3d41deb293973564a791e55c6782ba76c2bf0495f9a2100000001217da6c6b3e19f1825cfb2676daecce3bf3de03cf26647c78df00b371b25cc9700000000c4c63f80c74b11263e421ebf8486a4e398d0dbc09fa7d4f62ccdb309f3aea81f0900000001217da6c6b3e19f180100000004000000cafed00d00000000000000000000000000000000ffffffffffffffff".ToLower();
Assert.Equal(expected, actual);
}
public void RawTransaction()
{
var writeSet = new WriteSetLCS();
writeSet.WriteSet = new Dictionary <AccessPathLCS, WriteOpLCS>();
writeSet.WriteSet.Add(new AccessPathLCS
{
Address = new AddressLCS
{
Value = "a71d76faa2d2d5c3224ec3d41deb293973564a791e55c6782ba76c2bf0495f9a"
},
Path = "01217da6c6b3e19f1825cfb2676daecce3bf3de03cf26647c78df00b371b25cc97".FromHexToBytes()
}, new WriteOpLCS
{
WriteOpType = WriteOpType.Deletion
});
writeSet.WriteSet.Add(new AccessPathLCS
{
Address = new AddressLCS
{
Value = "c4c63f80c74b11263e421ebf8486a4e398d0dbc09fa7d4f62ccdb309f3aea81f"
},
Path = "01217da6c6b3e19f18".FromHexToBytes()
}, new WriteOpLCS
{
WriteOpType = WriteOpType.Value,
Value = "cafed00d".FromHexToBytes()
});
var transaction = new RawTransactionLCS
{
Sender = new AddressLCS
{
Value = "c3398a599a6f3b9f30b635af29f2ba046d3a752c26e9d0647b9647d1f4c04ad4"
},
SequenceNumber = 32,
TransactionPayload = new TransactionPayloadLCS
{
PayloadType = TransactionPayloadType.WriteSet,
WriteSet = writeSet
},
MaxGasAmount = 0UL,
GasUnitPrice = 0UL,
ExpirationTime = 18446744073709551615UL
};
var actual = LCSCore.LCSDeserialization(transaction).ByteArrayToString();
var expected = "20000000C3398A599A6F3B9F30B635AF29F2BA046D3A752C26E9D0647B9647D1F4C04AD42000000000000000010000000200000020000000A71D76FAA2D2D5C3224EC3D41DEB293973564A791E55C6782BA76C2BF0495F9A2100000001217DA6C6B3E19F1825CFB2676DAECCE3BF3DE03CF26647C78DF00B371B25CC970000000020000000C4C63F80C74B11263E421EBF8486A4E398D0DBC09FA7D4F62CCDB309F3AEA81F0900000001217DA6C6B3E19F180100000004000000CAFED00D00000000000000000000000000000000FFFFFFFFFFFFFFFF".ToLower();
Assert.Equal(expected, actual);
}
public RawTransactionLCS GetRawTransaction(byte[] source, ref int cursor)
{
var retVal = new RawTransactionLCS();
retVal.Sender = source.LCSerialization <AddressLCS>(ref cursor);
retVal.SequenceNumber = source.LCSerialization <ulong>(ref cursor);
retVal.TransactionPayload =
source.LCSerialization <TransactionPayloadLCS>(ref cursor);
retVal.MaxGasAmount = Read_u64(source, ref cursor);
retVal.GasUnitPrice = Read_u64(source, ref cursor);
retVal.ExpirationTime = Read_u64(source, ref cursor);
return(retVal);
}
public void RawTransactionWithProgram()
{
var program = new ProgramLCS();
program.Code = "move".ToBytes();
program.TransactionArguments = new List <TransactionArgumentLCS>();
program.TransactionArguments.Add(new TransactionArgumentLCS
{
ArgType = Types.TransactionArgument.Types.ArgType.String,
String = "CAFE D00D"
});
program.TransactionArguments.Add(new TransactionArgumentLCS
{
ArgType = Types.TransactionArgument.Types.ArgType.String,
String = "cafe d00d"
});
program.Modules = new List <byte[]>();
program.Modules.Add("CA".FromHexToBytes());
program.Modules.Add("FED0".FromHexToBytes());
program.Modules.Add("0D".FromHexToBytes());
var transaction = new RawTransactionLCS
{
Sender = new AddressLCS
{
Value = "3a24a61e05d129cace9e0efc8bc9e33831fec9a9be66f50fd352a2638a49b9ee"
},
SequenceNumber = 32,
TransactionPayload = new TransactionPayloadLCS
{
PayloadType = TransactionPayloadType.Program,
Program = program
},
MaxGasAmount = 10000UL,
GasUnitPrice = 20000UL,
ExpirationTime = 86400UL
};
var actual = LCSCore.LCSDeserialization(transaction).ByteArrayToString();
var expected = "3A24A61E05D129CACE9E0EFC8BC9E33831FEC9A9BE66F50FD352A2638A49B9EE200000000000000000000000040000006D6F766502000000020000000900000043414645204430304402000000090000006361666520643030640300000001000000CA02000000FED0010000000D1027000000000000204E0000000000008051010000000000".ToLower();
Assert.Equal(expected, actual);
}
public RawTransactionLCS GetRawTransaction(byte[] source, ref int cursor)
{
var retVal = new RawTransactionLCS();
// TODO Review what are these values
retVal.FirstUint = source.LCSDeserialization <uint>(ref cursor);
bool x = source.LCSDeserialization <bool>(ref cursor);
bool y = source.LCSDeserialization <bool>(ref cursor);
bool z = source.LCSDeserialization <bool>(ref cursor);
retVal.Sender = source.LCSDeserialization <AddressLCS>(ref cursor);
retVal.SequenceNumber = source.LCSDeserialization <ulong>(ref cursor);
retVal.TransactionPayload =
source.LCSDeserialization <TransactionPayloadLCS>(ref cursor);
retVal.MaxGasAmount = Read_u64(source, ref cursor);
retVal.GasUnitPrice = Read_u64(source, ref cursor);
retVal.ExpirationTime = Read_u64(source, ref cursor);
return(retVal);
}
//public async Task<string> SendTransaction(
// byte[] privateKey, byte[] rawTransaction)
//{
// var result = await _service.SendTransactionAsync(privateKey, rawTransaction);
// return result.ToString();
//}
public async Task <string> SendTransactionPtoP(
byte[] senderPrivateKey, string sender, string reciver, ulong amount)
{
var senderAccount = await GetAccountInfoAsync(sender);
RawTransactionLCS rawTr = new RawTransactionLCS()
{
ExpirationTime = (ulong)DateTimeOffset.UtcNow.AddSeconds(60)
.ToUnixTimeSeconds(),
GasUnitPrice = 0,
MaxGasAmount = 100000,
SequenceNumber = senderAccount.SequenceNumber
};
rawTr.TransactionPayload = new TransactionPayloadLCS();
rawTr.TransactionPayload.PayloadType = (uint)ETransactionPayloadLCS.Script;
rawTr.TransactionPayload.Script = new ScriptLCS()
{
Code = Utility.PtPTrxBytecode,
TransactionArguments = new List <TransactionArgumentLCS>()
{
new TransactionArgumentLCS()
{
ArgType = (uint)ETransactionArgumentLCS.Address,
Address = new AddressLCS(reciver)
},
new TransactionArgumentLCS()
{
ArgType = (uint)ETransactionArgumentLCS.U64,
U64 = amount
}
}
};
rawTr.Sender = new AddressLCS(sender);
var result = await _service.SendTransactionAsync(senderPrivateKey, rawTr);
return(result.ToString());
}
private void DeserializeRawTransaction(byte[] rawTxnBytes)
{
_rawTxnBytes = rawTxnBytes;
int cursor = 0;
RawTransactionLCS rawTr = _rawTxnBytes.LCDeserialize <RawTransactionLCS>(ref cursor);
///TODO
FirestUint = rawTr.FirstUint;
ExpirationTimeUnix = rawTr.ExpirationTime;
ExpirationTime = rawTr.ExpirationTime.UnixTimeStampToDateTime();
GasUnitPrice = rawTr.GasUnitPrice;
MaxGasAmount = rawTr.MaxGasAmount;
PayloadCase = rawTr.TransactionPayload.PayloadTypeEnum;
Sender = rawTr.Sender.Value;
var programCode = rawTr.TransactionPayload.PayloadTypeEnum;
//if (Utility.IsPtPOrMint(programCode))
if (rawTr.TransactionPayload.PayloadTypeEnum ==
ETransactionPayloadLCS.Program)
{
var args = rawTr.TransactionPayload.Program.TransactionArguments.ToArray();
if (args.Count() == 2 &&
args[0].ArgTypeEnum == ETransactionArgumentLCS.Address &&
args[1].ArgTypeEnum == ETransactionArgumentLCS.U64)
{
Receiver = args[0].Address.Value;
Amount = args[1].U64;
}
}
SequenceNumber = rawTr.SequenceNumber;
if (rawTr.TransactionPayload.PayloadTypeEnum ==
ETransactionPayloadLCS.Script &&
Utility.IsPtPOrMint(rawTr.TransactionPayload.Script.Code))
{
var args = rawTr.TransactionPayload.Script
.TransactionArguments.ToArray();
if (args.Count() == 2 &&
args[0].ArgTypeEnum == ETransactionArgumentLCS.Address &&
args[1].ArgTypeEnum == ETransactionArgumentLCS.U64)
{
Receiver = args[0].Address.Value;
Amount = args[1].U64;
}
}
if (rawTr.TransactionPayload.PayloadTypeEnum ==
ETransactionPayloadLCS.Program)
{
List <CustomTransactionArgument> arguments =
new List <CustomTransactionArgument>();
foreach (var item in rawTr.TransactionPayload.Program
.TransactionArguments)
{
GerArg(arguments, item);
}
List <byte[]> modules = new List <byte[]>();
foreach (var item in rawTr.TransactionPayload.Program.Modules)
{
modules.Add(item);
}
Program = new CustomProgram()
{
PayloadType = (ETransactionPayload)rawTr.TransactionPayload
.PayloadTypeEnum,
Arguments = arguments,
Code = rawTr.TransactionPayload.Program.Code,
Modules = modules
};
}
else if (rawTr.TransactionPayload.PayloadTypeEnum ==
ETransactionPayloadLCS.Script)
{
List <CustomTransactionArgument> arguments =
new List <CustomTransactionArgument>();
foreach (var item in rawTr.TransactionPayload.Script
.TransactionArguments)
{
GerArg(arguments, item);
}
Program = new CustomProgram()
{
PayloadType = (ETransactionPayload)rawTr.TransactionPayload
.PayloadTypeEnum,
Arguments = arguments,
Code = rawTr.TransactionPayload.Script.Code
};
}
else if (rawTr.TransactionPayload.PayloadTypeEnum ==
ETransactionPayloadLCS.Module)
{
List <byte[]> modules = new List <byte[]>();
modules.Add(rawTr.TransactionPayload.Module.Code);
Program = new CustomProgram()
{
PayloadType = (ETransactionPayload)rawTr.TransactionPayload
.PayloadTypeEnum,
Modules = modules
};
}
}
public async Task <bool> TransferCoins(Account sender, string receiverAddress, ulong amount, ulong gasUnitPrice = 0, ulong maxGasAmount = 1000000)
{
try
{
var accountState = await QueryBalance(sender.Address);
var program = new ProgramLCS();
program.Code = Convert.FromBase64String(Constant.ProgamBase64Codes.PeerToPeerTxn);
program.TransactionArguments = new List <TransactionArgumentLCS>();
program.TransactionArguments.Add(new TransactionArgumentLCS
{
ArgType = Types.TransactionArgument.Types.ArgType.Address,
Address = new AddressLCS {
Value = receiverAddress
}
});
program.TransactionArguments.Add(new TransactionArgumentLCS
{
ArgType = Types.TransactionArgument.Types.ArgType.U64,
U64 = amount
});
program.Modules = new List <byte[]>();
var transaction = new RawTransactionLCS
{
Sender = new AddressLCS {
Value = sender.Address
},
SequenceNumber = accountState.SequenceNumber,
TransactionPayload = new TransactionPayloadLCS
{
PayloadType = TransactionPayloadType.Program,
Program = program
},
MaxGasAmount = maxGasAmount,
GasUnitPrice = gasUnitPrice,
ExpirationTime = (ulong)Math.Floor((decimal)DateTimeOffset.Now.ToUnixTimeMilliseconds() / 1000) + 100
};
var transactionLCS = LCSCore.LCSDeserialization(transaction);
var digestSHA3 = new SHA3_256();
var saltDigest = digestSHA3.ComputeVariable(Constant.HashSaltValues.RawTransactionHashSalt.ToBytes());
var saltDigestAndTransaction = saltDigest.Concat(transactionLCS).ToArray();
var hash = digestSHA3.ComputeVariable(saltDigestAndTransaction);
var senderSignature = sender.KeyPair.Sign(hash);
var publicKeyLen = BitConverter.GetBytes((uint)sender.PublicKey.Length);
var signatureLen = BitConverter.GetBytes((uint)senderSignature.Length);
var txnBytes = transactionLCS.Concat(publicKeyLen).ToArray();
txnBytes = txnBytes.Concat(sender.PublicKey).ToArray();
txnBytes = txnBytes.Concat(signatureLen).ToArray();
txnBytes = txnBytes.Concat(senderSignature).ToArray();
var request = new SubmitTransactionRequest
{
SignedTxn = new SignedTransaction
{
TxnBytes = txnBytes.ToByteString()
}
};
var response = await acClient.SubmitTransactionAsync(request);
return(response.AcStatus.Code == AdmissionControlStatusCode.Accepted);
}
catch (Exception ex)
{
throw ex;
}
}
static void Main(string[] args)
{
Channel channel = new Channel("ac.testnet.libra.org:8000", ChannelCredentials.Insecure);
var client = new AdmissionControl.AdmissionControl.AdmissionControlClient(channel);
HexEncoder hex = new HexEncoder();
SharedSecret sharedSecret = SharedSecret.Import(Encoding.UTF8.GetBytes("newdummy"));
HkdfSha512 kdf = new HkdfSha512();
var key = kdf.DeriveKey(sharedSecret, null, null, Ed25519.Ed25519);
var sender = key.PublicKey.Export(KeyBlobFormat.RawPublicKey);
UInt64 seqNum = 11;
string senderHex = hex.EncodeData(Sha3.Sha3256().ComputeHash(sender));
uint amount = 10000000;
string reciver = "4ba2555fd146e79e37fda7a2f30dc1b4f3d9228aa48b230dbab0a18d407f2f9b";
RawTransactionLCS rawTr = new RawTransactionLCS()
{
ExpirationTime = (ulong)DateTimeOffset.UtcNow.AddSeconds(60)
.ToUnixTimeSeconds(),
GasUnitPrice = 0,
MaxGasAmount = 100000,
SequenceNumber = seqNum
};
rawTr.TransactionPayload = new TransactionPayloadLCS();
rawTr.TransactionPayload.PayloadType = (uint)TransactionPayloadLCSEnum.Script;
rawTr.TransactionPayload.Script = new ScriptLCS()
{
Code = Utilities.PtPTrxBytecode,
TransactionArguments = new List <TransactionArgumentLCS>()
{
new TransactionArgumentLCS()
{
ArgType = (uint)TransactionArgumentLCSEnum.Address,
Address = new AddressLCS(reciver)
},
new TransactionArgumentLCS()
{
ArgType = (uint)TransactionArgumentLCSEnum.U64,
U64 = amount
}
}
};
rawTr.Sender = new AddressLCS(senderHex);
var bytesTrx = LCSCore.LCSSerialization(rawTr);
Types.SignedTransaction signedTx = new Types.SignedTransaction();
var bytesTrxHash = Google.Protobuf.ByteString.CopyFrom(bytesTrx);
var seed = Encoding.ASCII.GetBytes(RAWTX_HASH_SALT + LIBRA_HASH_SUFFIX);
var seedHash = Sha3.Sha3256().ComputeHash(seed);
List <byte> hashInput = new List <byte>();
hashInput.AddRange(seedHash);
hashInput.AddRange(bytesTrxHash);
var hash = Sha3.Sha3256().ComputeHash(hashInput.ToArray());
SubmitTransactionRequest req = new SubmitTransactionRequest();
req.SignedTxn = new SignedTransaction();
List <byte> retArr = new List <byte>();
retArr = retArr.Concat(bytesTrx).ToList();
retArr = retArr.Concat(
LCSCore.LCSSerialization(key.Export(KeyBlobFormat.RawPublicKey))).ToList();
var sig = SignatureAlgorithm.Ed25519.Sign(key, hash);
retArr = retArr.Concat(LCSCore.LCSSerialization(sig)).ToList();
req.SignedTxn.SignedTxn = ByteString.CopyFrom(retArr.ToArray());
var result = client.SubmitTransaction(
req, new Metadata());
Task.Delay(5000).Wait();
GetTransaction(client, senderHex, seqNum);
}
