public virtual void ShouldPackFixedArrayUint8()
{
var list = new List <int>(new int[] { 1, 2 });
var soliditySha3 = new ABIEncode();
Assert.Equal("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", soliditySha3.GetABIEncodedPacked(new ABIValue("uint8[2]", list)).ToHex());
}
public virtual void ShouldPackFixedArrayBytes16()
{
var list = new List <byte[]>(new byte[][] { Encoding.UTF8.GetBytes("Hello, world!"), Encoding.UTF8.GetBytes("Hello, world!") });
var soliditySha3 = new ABIEncode();
Assert.Equal("48656c6c6f2c20776f726c64210000000000000000000000000000000000000048656c6c6f2c20776f726c642100000000000000000000000000000000000000", soliditySha3.GetABIEncodedPacked(new ABIValue("bytes13[2]", list)).ToHex());
}
public static string EncodeSetup(string[] owners, BigInteger threshold, string to = "0x0000000000000000000000000000000000000000", byte[] data = null, string fallbackHandler = "0x0000000000000000000000000000000000000000", string paymentToken = "0x0000000000000000000000000000000000000000", BigInteger payment = new BigInteger(), string paymentReceiver = "0x0000000000000000000000000000000000000000")
{
if (data == null)
{
data = new byte[] { }
}
;
var abiEncode = new ABIEncode();
// @dev Setup function sets initial storage of contract.
// @param _owners List of Safe owners.
// @param _threshold Number of required confirmations for a Safe transaction.
// @param to Contract address for optional delegate call.
// @param data Data payload for optional delegate call.
// @param fallbackHandler Handler for fallback calls to this contract
// @param paymentToken Token that should be used for the payment (0 is ETH)
// @param payment Value that should be paid
// @param paymentReceiver Address that should receive the payment (or 0 if tx.origin)
return(abiEncode.GetABIEncoded(
new ABIValue("address[]", owners),
new ABIValue("uint256", threshold),
new ABIValue("address", to),
new ABIValue("bytes", data),
new ABIValue("address", fallbackHandler),
new ABIValue("address", paymentToken),
new ABIValue("uint256", payment),
new ABIValue("address", paymentReceiver)
).ToHex());
}
public virtual void ShouldPackStaticArrayAddresses()
{
var list = new List <string>(new string[] { "0x7Dd31bc2ffA37Ab492a8d60F9C7170B78f12E1c5", "0x0Efa8015FCEC7039Feb656a4830Aa6518BF46010" });
var soliditySha3 = new ABIEncode();
Assert.Equal("0000000000000000000000007dd31bc2ffa37ab492a8d60f9c7170b78f12e1c50000000000000000000000000efa8015fcec7039feb656a4830aa6518bf46010", soliditySha3.GetABIEncodedPacked(new ABIValue("address[2]", list)).ToHex());
}
/// <summary>
/// Sign a prroof that a free service provider provided free content to a Witness. Should be signed by wallet owner as Witness
/// </summary>
/// <param name="offchainTransaction"></param>
/// <returns></returns>
public SignedOffchainFreeServiceTransaction signFreeServiceProviderMbs(SignedOffchainFreeServiceTransaction offchainTransaction)
{
var signer = new MessageSigner();
var encoder = new ABIEncode();
ABIValue[] ABIValues = new ABIValue[] {
new ABIValue("uint", offchainTransaction.epoch),
new ABIValue("address", offchainTransaction.freeServiceProvider),
new ABIValue("address", offchainTransaction.validator),
new ABIValue("uint256", offchainTransaction.freeMb)
};
var payloadEncoded = encoder.GetABIEncodedPacked(ABIValues);
var proof = Sha3Keccack.Current.CalculateHash(payloadEncoded);
offchainTransaction.h = proof;
var signedTx = signer.Sign(offchainTransaction.h, _wallet.PK);
var signature = MessageSigner.ExtractEcdsaSignature(signedTx);
offchainTransaction.v = signature.V.FirstOrDefault();
offchainTransaction.r = signature.R;
offchainTransaction.s = signature.S;
if (offchainTransaction.s.Length < 32)
{
var tmpS = offchainTransaction.s.ToList();
tmpS.Insert(0, 0);
offchainTransaction.s = tmpS.ToArray();
}
offchainTransaction.signer = _wallet.address;
return(offchainTransaction);
}
public virtual void ShouldPackBool()
{
var soliditySha3 = new ABIEncode();
Assert.Equal("01", soliditySha3.GetABIEncodedPacked(true).ToHex());
Assert.Equal("00", soliditySha3.GetABIEncodedPacked(false).ToHex());
}
/// <summary>
/// Sign an Offchain payment as a Peer
/// </summary>
/// <param name="offchainTransaction">The transaction to be signed</param>
/// <returns>The Transaction signed by wallet owner as Peer </returns>
public SignedOffchainTransaction signOffchainPayment(SignedOffchainTransaction offchainTransaction)
{
var signer = new MessageSigner();
var encoder = new ABIEncode();
ABIValue[] ABIValues = new ABIValue[] {
new ABIValue("address", offchainTransaction.beneficiary),
new ABIValue("bytes32", offchainTransaction.nonce),
new ABIValue("uint256", offchainTransaction.amount),
new ABIValue("uint", offchainTransaction.fee)
};
var payloadEncoded = encoder.GetABIEncodedPacked(ABIValues);
var proof = Sha3Keccack.Current.CalculateHash(payloadEncoded);
offchainTransaction.h = proof;
var signedTx = signer.Sign(offchainTransaction.h, _wallet.PK);
var signature = MessageSigner.ExtractEcdsaSignature(signedTx);
offchainTransaction.v = signature.V.FirstOrDefault();
offchainTransaction.r = signature.R;
offchainTransaction.s = signature.S;
if (offchainTransaction.s.Length < 32)
{
var tmpS = offchainTransaction.s.ToList();
tmpS.Insert(0, 0);
offchainTransaction.s = tmpS.ToArray();
}
offchainTransaction.signer = _wallet.address;
return(offchainTransaction);
}
public virtual void ShouldEncodeSha3UsingTypes()
{
//0x407D73d8a49eeb85D32Cf465507dd71d507100c1
var abiEncode = new ABIEncode();
Assert.Equal("4e8ebbefa452077428f93c9520d3edd60594ff452a29ac7d2ccc11d47f3ab95b",
abiEncode.GetSha3ABIEncodedPacked(new ABIValue("address", "0x407D73d8a49eeb85D32Cf465507dd71d507100c1"))
.ToHex());
Assert.Equal("4e8ebbefa452077428f93c9520d3edd60594ff452a29ac7d2ccc11d47f3ab95b",
abiEncode.GetSha3ABIEncodedPacked(new ABIValue("bytes",
"0x407D73d8a49eeb85D32Cf465507dd71d507100c1".HexToByteArray())).ToHex());
//bytes32 it is a 32 bytes array so it will be padded with 00 values
Assert.Equal("3c69a194aaf415ba5d6afca734660d0a3d45acdc05d54cd1ca89a8988e7625b4",
abiEncode.GetSha3ABIEncodedPacked(new ABIValue("bytes32",
"0x407D73d8a49eeb85D32Cf465507dd71d507100c1".HexToByteArray())).ToHex());
//web3.utils.soliditySha3({t: 'string', v: 'Hello!%'}, {t: 'int8', v:-23}, {t: 'address', v: '0x85F43D8a49eeB85d32Cf465507DD71d507100C1d'});
var result =
abiEncode.GetSha3ABIEncodedPacked(
new ABIValue("string", "Hello!%"), new ABIValue("int8", -23),
new ABIValue("address", "0x85F43D8a49eeB85d32Cf465507DD71d507100C1d"));
Assert.Equal("0xa13b31627c1ed7aaded5aecec71baf02fe123797fffd45e662eac8e06fbe4955", result.ToHex(true));
}
public static string GetSignatureHexString(this Buyer.Po po, string privateKeyHex)
{
privateKeyHex = privateKeyHex.EnsureHexPrefix();
var hashEncoded = new ABIEncode().GetSha3ABIEncoded(new ABIValue(new TupleType(), po));
var signature = new EthereumMessageSigner().Sign(hashEncoded, privateKeyHex);
return(signature);
}
public virtual void ShouldPackAddress()
{
var soliditySha3 = new ABIEncode();
Assert.Equal("0x12890D2cce102216644c59daE5baed380d84830c",
soliditySha3.GetABIEncodedPacked(new ABIValue("address", "0x12890D2cce102216644c59daE5baed380d84830c"))
.ToHex(true).ConvertToEthereumChecksumAddress());
}
public virtual void ShouldEncodeMultipleValuesUsingDefaultConvertors()
{
var paramsEncoded =
"000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000131000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013300000000000000000000000000000000000000000000000000000000000000";
var abiEncode = new ABIEncode();
var encoded = abiEncode.GetABIEncoded("1", "2", "3").ToHex();
Assert.Equal(paramsEncoded, encoded);
}
public virtual void ShouldEncodeMultipleTypesIncludingDynamicString()
{
var paramsEncoded =
"0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000568656c6c6f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005776f726c64000000000000000000000000000000000000000000000000000000";
var abiEncode = new ABIEncode();
var result = abiEncode.GetABIEncoded(new ABIValue("string", "hello"), new ABIValue("int", 69),
new ABIValue("string", "world"));
Assert.Equal("0x" + paramsEncoded, result.ToHex(true));
}
/// <inheritdoc />
public string EncodeChangeRequirementParams(BigInteger requirement)
{
// TODO: Extract this directly from the ABI
const string ChangeRequirementMethod = "ba51a6df";
var abiEncode = new ABIEncode();
string result = ChangeRequirementMethod + abiEncode.GetABIEncoded(new ABIValue("uint256", requirement)).ToHex();
return(result);
}
/// <inheritdoc />
public string EncodeRemoveOwnerParams(string existingOwnerAddress)
{
// TODO: Extract this directly from the ABI
const string RemoveOwnerMethod = "173825d9";
var abiEncode = new ABIEncode();
string result = RemoveOwnerMethod + abiEncode.GetABIEncoded(new ABIValue("address", existingOwnerAddress)).ToHex();
return(result);
}
public virtual void ShouldEncodeParams()
{
var abiEncode = new ABIEncode();
var result = abiEncode.GetSha3ABIParamsEncodedPacked(new TestParamsInput
{
First = "Hello!%", Second = -23, Third = "0x85F43D8a49eeB85d32Cf465507DD71d507100C1d"
});
Assert.Equal("0xa13b31627c1ed7aaded5aecec71baf02fe123797fffd45e662eac8e06fbe4955", result.ToHex(true));
}
/// <inheritdoc />
public string EncodeAddOwnerParams(string newOwnerAddress)
{
// TODO: Extract this directly from the ABI
const string AddOwnerMethod = "7065cb48";
var abiEncode = new ABIEncode();
string result = AddOwnerMethod + abiEncode.GetABIEncoded(new ABIValue("address", newOwnerAddress)).ToHex();
return(result);
}
/// <inheritdoc />
public string EncodeBurnParams(BigInteger amount, string straxAddress)
{
// TODO: Extract this directly from the ABI
const string BurnMethod = "7641e6f3";
var abiEncode = new ABIEncode();
string result = BurnMethod + abiEncode.GetABIEncoded(new ABIValue("uint256", amount), new ABIValue("string", straxAddress)).ToHex();
return(result);
}
/// <inheritdoc />
public string EncodeMintParams(string address, BigInteger amount)
{
// TODO: Extract this directly from the ABI
const string MintMethod = "40c10f19";
var abiEncode = new ABIEncode();
string result = MintMethod + abiEncode.GetABIEncoded(new ABIValue("address", address), new ABIValue("uint256", amount)).ToHex();
return(result);
}
/// <inheritdoc />
public string EncodeTransferParams(string address, BigInteger amount)
{
// TODO: Extract this directly from the ABI
const string TransferMethod = "a9059cbb";
var abiEncode = new ABIEncode();
string result = TransferMethod + abiEncode.GetABIEncoded(new ABIValue("address", address), new ABIValue("uint256", amount)).ToHex();
return(result);
}
public virtual void ShouldEncodeParams()
{
var paramsEncoded =
"0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000568656c6c6f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005776f726c64000000000000000000000000000000000000000000000000000000";
var abiEncode = new ABIEncode();
var result = abiEncode.GetABIParamsEncoded(new TestParamsInput()
{
First = "hello", Second = 69, Third = "world"
});
Assert.Equal("0x" + paramsEncoded, result.ToHex(true));
}
public static byte[] EncodeMultiSend(IMultiSendInput multiSendInput)
{
var callData = multiSendInput.GetCallData();
var abiEncoder = new ABIEncode();
return(abiEncoder.GetABIEncodedPacked(
new ABIValue("uint8", (int)ContractOperationType.Call),
new ABIValue("address", multiSendInput.Target),
new ABIValue("uint256", multiSendInput.Value),
new ABIValue("uint256", callData.Length),
new ABIValue("bytes", callData)));
}
public virtual void ShouldEncodeSha3UsingDefaultValuesIntAsBigInt()
{
var abiEncode = new ABIEncode();
var result = abiEncode.GetSha3ABIEncodedPacked(new BigInteger(234564535),
"0xfff23243".HexToByteArray(), true, new BigInteger(-10));
Assert.Equal("3e27a893dc40ef8a7f0841d96639de2f58a132be5ae466d40087a2cfa83b7179", result.ToHex());
var result2 = abiEncode.GetSha3ABIEncodedPacked("Hello!%");
Assert.Equal("661136a4267dba9ccdf6bfddb7c00e714de936674c4bdb065a531cf1cb15c7fc", result2.ToHex());
var result3 = abiEncode.GetSha3ABIEncodedPacked(new BigInteger(234));
Assert.Equal("61c831beab28d67d1bb40b5ae1a11e2757fa842f031a2d0bc94a7867bc5d26c2", result3.ToHex());
}
private string getGluwacoinReserveTxnSignature(
ECurrency currency,
string address,
string amount,
string fee,
string target,
string executor,
BigInteger nonce,
BigInteger expiryBlockNumber,
string privateKey)
{
BigInteger convertAmount = BigInteger.Zero;
BigInteger convertFee = BigInteger.Zero;
if (currency.IsGluwacoinSideChainCurrency())
{
convertAmount = GluwacoinConverter.ConvertToGluwacoinSideChainBigInteger(amount, currency);
convertFee = GluwacoinConverter.ConvertToGluwacoinSideChainBigInteger(fee, currency);
}
else
{
convertAmount = GluwacoinConverter.ConvertToGluwacoinBigInteger(amount);
convertFee = GluwacoinConverter.ConvertToGluwacoinBigInteger(fee);
}
ABIEncode abiEncode = new ABIEncode();
byte[] messageHash = abiEncode.GetSha3ABIEncodedPacked(
new ABIValue("address", GluwaService.getGluwacoinContractAddress(currency, mEnv)),
new ABIValue("address", address),
new ABIValue("address", target),
new ABIValue("address", executor),
new ABIValue("uint256", convertAmount),
new ABIValue("uint256", convertFee),
new ABIValue("uint256", nonce),
new ABIValue("uint256", expiryBlockNumber)
);
EthereumMessageSigner signer = new EthereumMessageSigner();
string signature = signer.Sign(messageHash, privateKey);
return(signature);
}
/// <summary>
/// Sign an Offchain Payemnt as Relayer using Wallet private key
/// </summary>
/// <param name="offchainTransaction">The already signed by Peer Offchain Payment payload</param>
/// <returns>The transaction signed by Wallet owner as Relayer</returns>
public async Task <SignedOffchainTransaction> relayerSignOffchainPayment(SignedOffchainTransaction offchainTransaction)
{
//Check that already signed payload is valid
var validSignature = await checkOffchainSignature(offchainTransaction);
if (!validSignature)
{
throw new Exception("Invalid signature");
}
var signer = new MessageSigner();
var encoder = new ABIEncode();
ABIValue[] ABIValues = new ABIValue[] {
new ABIValue("bytes32", offchainTransaction.h),
new ABIValue("uint", offchainTransaction.txUntilBlock)
};
var payloadEncoded = encoder.GetABIEncodedPacked(ABIValues);
var proof = Sha3Keccack.Current.CalculateHash(payloadEncoded);
offchainTransaction.rh = proof;
var signedTx = signer.Sign(offchainTransaction.rh, _wallet.PK);
var signature = MessageSigner.ExtractEcdsaSignature(signedTx);
offchainTransaction.rv = signature.V.FirstOrDefault();
offchainTransaction.rr = signature.R;
offchainTransaction.rs = signature.S;
if (offchainTransaction.rs.Length < 32)
{
var tmpS = offchainTransaction.rs.ToList();
tmpS.Insert(0, 0);
offchainTransaction.rs = tmpS.ToArray();
}
offchainTransaction.relayerId = _wallet.address;
return(offchainTransaction);
}
private string getGluwacoinTransactionSignature(ECurrency currency, string amount, string fee, string nonce, string address, string target, string privateKey)
{
BigInteger convertAmount = BigInteger.Zero;
BigInteger convertFee = BigInteger.Zero;
if (currency.IsGluwacoinSideChainCurrency())
{
if (currency == ECurrency.sNGNG)
{
convertAmount = GluwacoinConverter.ConvertToGluwacoinSideChainBigInteger(amount, currency);
convertFee = GluwacoinConverter.ConvertToGluwacoinSideChainBigInteger(fee.ToString(), currency);
}
else if (currency == ECurrency.sUSDCG)
{
convertAmount = GluwacoinConverter.ConvertToGluwacoinSideChainBigInteger(amount, currency);
convertFee = GluwacoinConverter.ConvertToGluwacoinSideChainBigInteger(fee.ToString(), currency);
}
}
else
{
convertAmount = GluwacoinConverter.ConvertToGluwacoinBigInteger(amount);
convertFee = GluwacoinConverter.ConvertToGluwacoinBigInteger(fee.ToString());
}
ABIEncode abiEncode = new ABIEncode();
byte[] messageHash = abiEncode.GetSha3ABIEncodedPacked(
new ABIValue("address", GluwaService.getGluwacoinContractAddress(currency, mEnv)),
new ABIValue("address", address),
new ABIValue("address", target),
new ABIValue("uint256", convertAmount),
new ABIValue("uint256", convertFee),
new ABIValue("uint256", BigInteger.Parse(nonce))
);
EthereumMessageSigner signer = new EthereumMessageSigner();
string signature = signer.Sign(messageHash, privateKey);
return(signature);
}
private byte[] GetApprovalData(
TransactionInput transaction,
BigInteger txFee,
BigInteger gasPrice,
BigInteger gasLimit,
BigInteger nonce,
string relayHubAddress,
string relayAddress)
{
var abiEncode = new ABIEncode();
return(abiEncode.GetSha3ABIEncodedPacked(
new ABIValue("address", relayAddress),
new ABIValue("address", transaction.From),
new ABIValue("bytes", transaction.Data.HexToByteArray()),
new ABIValue("uint256", txFee),
new ABIValue("uint256", gasPrice),
new ABIValue("uint256", gasLimit),
new ABIValue("uint256", nonce),
new ABIValue("address", relayHubAddress),
new ABIValue("address", transaction.To)));
}
public PaymentsService(IPaymentTransfersRepository paymentTransfersRepository,
ITransactionScopeHandler transactionScopeHandler,
IPrivateBlockchainFacadeClient pbfClient,
IMAVNPropertyIntegrationClient realEstateIntegrationClient,
IEligibilityEngineClient eligibilityEngineClient,
ISettingsService settingsService,
IWalletManagementClient wmClient,
ICustomerProfileClient cpClient,
ICampaignClient campaignClient,
ILogFactory logFactory)
{
_functionCallEncoder = new FunctionCallEncoder();
_abiEncode = new ABIEncode();
_paymentTransfersRepository = paymentTransfersRepository;
_transactionScopeHandler = transactionScopeHandler;
_pbfClient = pbfClient;
_realEstateIntegrationClient = realEstateIntegrationClient;
_eligibilityEngineClient = eligibilityEngineClient;
_settingsService = settingsService;
_wmClient = wmClient;
_cpClient = cpClient;
_campaignClient = campaignClient;
_log = logFactory.CreateLog(this);
}
public EncoderService()
{
_abiEncode = new ABIEncode();
_functionCallEncoder = new FunctionCallEncoder();
}
public static byte[] GetParamsEncoded <TContractMessage>(this TContractMessage contractMessage) where TContractMessage : ContractMessageBase
{
var encoder = new ABIEncode();
return(encoder.GetABIParamsEncoded(contractMessage));
}
public BlockchainEncodingService()
{
_functionCallEncoder = new FunctionCallEncoder();
_abiEncode = new ABIEncode();
}