public async void ShouldBeAbleToEncodeTheSameAsTheSmartContract()
{
var web3 = _ethereumClientIntegrationFixture.GetInfuraWeb3(InfuraNetwork.Rinkeby);
var signer = new Eip712TypedDataSigner();
var gnosisSafeAddress = "0xa9C09412C1d93DAc6eE9254A51E97454588D3B88";
var chainId = (int)Chain.Rinkeby;
var service = new GnosisSafeService(web3, gnosisSafeAddress);
var param = new EncodeTransactionDataFunction
{
To = "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
Value = 0,
Data = "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D".HexToByteArray(),
Operation = (byte)ContractOperationType.Call,
SafeTxGas = 0,
BaseGas = 0,
GasPrice = 0,
GasToken = AddressUtil.AddressEmptyAsHex,
RefundReceiver = AddressUtil.AddressEmptyAsHex,
Nonce = 1
};
var encoded = await service.EncodeTransactionDataQueryAsync(param);
var domain = new Domain
{
VerifyingContract = gnosisSafeAddress,
ChainId = chainId
};
var encodedMessage = signer.EncodeTypedData(param, domain, "SafeTx");
Assert.Equal(encoded.ToHex(), encodedMessage.ToHex());
}
public async Task <ExecTransactionFunction> BuildTransactionAsync(
EncodeTransactionDataFunction transactionData,
BigInteger chainId,
bool estimateSafeTxGas = false, params string[] privateKeySigners)
{
var nonce = await NonceQueryAsync().ConfigureAwait(false);
transactionData.SafeNonce = nonce;
return(BuildTransaction(transactionData, chainId, privateKeySigners));
}
public Task <ExecTransactionFunction> BuildMultiSendTransactionAsync(
EncodeTransactionDataFunction transactionData,
BigInteger chainId,
string[] privateKeySigners,
bool estimateSafeTxGas = false, params IMultiSendInput[] multiSendInputs)
{
transactionData.Operation = (int)ContractOperationType.DelegateCall;
var multiSendFunction = new MultiSendFunction(multiSendInputs);
return(BuildTransactionAsync(transactionData, multiSendFunction, chainId, estimateSafeTxGas,
privateKeySigners));
}
public void FlatMessageObjectEncodingShouldBeCorrect()
{
var domain = new MyFlatDomain()
{
VerifyingContract = "0x0fced4cc7788ede6d93e23e0b54bb56a98114ce2"
};
var param = new EncodeTransactionDataFunction
{
To = "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa",
Value = 0,
Data = "0x095ea7b3000000000000000000000000e7bc397dbd069fc7d0109c0636d06888bb50668c00000000000000000000000000000000000000000000000000000000ffffffff".HexToByteArray(),
Operation = 0,
SafeTxGas = 0,
BaseGas = 0,
GasPrice = 0,
GasToken = AddressUtil.AddressEmptyAsHex,
RefundReceiver = AddressUtil.AddressEmptyAsHex,
Nonce = 1
};
var encodedMessage = _signer.EncodeTypedData(param, domain, "SafeTx");
Assert.Equal(
encodedMessage.ToHex(true),
"0x1901a15700103df744480601949aa3add5a0c0ebf6d258bf881eb6abac9736ead7f43a707a87afefa511211636c16608979d6ce2fc81e3c6979d4b80fb4bf3ff1080",
ignoreCase: true
);
var testPrivateKey = "8da4ef21b864d2cc526dbdb2a120bd2874c36c9d0a1fb7f8c63d7f7a8b41de8f";
var signature = _signer.SignTypedData(param, domain, "SafeTx", new EthECKey(testPrivateKey));
Assert.Equal(
signature,
"0x12bc2897d54cf62b8cc4864f02e6e154ddf416e51b5919a608e32978fa80422e369a3d6b24eeb2875e3fabc233b4ebbd8306c209a81958c440172780ad9a99841c",
ignoreCase: true
);
var recoveredAddress = new EthereumMessageSigner().EcRecover(Sha3Keccack.Current.CalculateHash(encodedMessage), signature);
Assert.Equal(
recoveredAddress,
"0x63FaC9201494f0bd17B9892B9fae4d52fe3BD377",
ignoreCase: true
);
}
public Task <byte[]> EncodeTransactionDataQueryAsync(string to, BigInteger value, byte[] data, byte operation, BigInteger safeTxGas, BigInteger baseGas, BigInteger gasPrice, string gasToken, string refundReceiver, BigInteger nonce, BlockParameter blockParameter = null)
{
var encodeTransactionDataFunction = new EncodeTransactionDataFunction();
encodeTransactionDataFunction.To = to;
encodeTransactionDataFunction.Value = value;
encodeTransactionDataFunction.Data = data;
encodeTransactionDataFunction.Operation = operation;
encodeTransactionDataFunction.SafeTxGas = safeTxGas;
encodeTransactionDataFunction.BaseGas = baseGas;
encodeTransactionDataFunction.GasPrice = gasPrice;
encodeTransactionDataFunction.GasToken = gasToken;
encodeTransactionDataFunction.RefundReceiver = refundReceiver;
encodeTransactionDataFunction.Nonce = nonce;
return(ContractHandler.QueryAsync <EncodeTransactionDataFunction, byte[]>(encodeTransactionDataFunction, blockParameter));
}
public ExecTransactionFunction BuildTransaction(
EncodeTransactionDataFunction transactionData,
BigInteger chainId,
params string[] privateKeySigners)
{
var signer = new Eip712TypedDataSigner();
var messageSigner = new MessageSigner();
var domain = new Domain
{
VerifyingContract = this.ContractHandler.ContractAddress,
ChainId = chainId
};
var encodedMessage = signer.EncodeTypedData(transactionData, domain, "SafeTx");
var hashEncoded = Util.Sha3Keccack.Current.CalculateHash(encodedMessage);
var signatures = new List <SafeSignature>();
foreach (var privateKey in privateKeySigners)
{
var publicAddress = EthECKey.GetPublicAddress(privateKey);
var signature = messageSigner.Sign(hashEncoded, privateKey);
signatures.Add(new SafeSignature()
{
Address = publicAddress, Signature = signature
});
}
var fullSignature = GetCombinedSignaturesInOrder(signatures);
return(new ExecTransactionFunction()
{
To = transactionData.To,
Value = transactionData.Value,
Data = transactionData.Data,
Operation = transactionData.Operation,
SafeTxGas = transactionData.SafeTxGas,
BaseGas = transactionData.BaseGas,
SafeGasPrice = transactionData.SafeGasPrice,
GasToken = transactionData.GasToken,
RefundReceiver = transactionData.RefundReceiver,
Signatures = fullSignature
});
}
public async Task <ExecTransactionFunction> BuildTransactionAsync <TFunctionMessage>(
EncodeTransactionDataFunction transactionData,
TFunctionMessage functionMessage,
BigInteger chainId,
bool estimateSafeTxGas = false, params string[] privateKeySigners) where TFunctionMessage : FunctionMessage, new()
{
var nonce = await NonceQueryAsync().ConfigureAwait(false);;
if (estimateSafeTxGas)
{
var toContract = transactionData.To;
var estimateHandler = Web3.Eth.GetContractTransactionHandler <TFunctionMessage>();
functionMessage.FromAddress = this.ContractHandler.ContractAddress;
var gasEstimateSafe = await estimateHandler.EstimateGasAsync(toContract, functionMessage).ConfigureAwait(false);;
transactionData.SafeTxGas = gasEstimateSafe;
}
transactionData.Data = functionMessage.GetCallData();
transactionData.SafeNonce = nonce;
return(BuildTransaction(transactionData, chainId, privateKeySigners));
}
public ExecTransactionFunction BuildTransaction(
EncodeTransactionDataFunction transactionData,
BigInteger chainId,
params string[] privateKeySigners)
{
var signer = new Eip712TypedDataSigner();
var messageSigner = new MessageSigner();
var typedDefinition = GetGnosisSafeTypedDefinition(chainId, this.ContractHandler.ContractAddress);
var hashEncoded = signer.EncodeAndHashTypedData(transactionData, typedDefinition);
var signatures = new List <SafeSignature>();
foreach (var privateKey in privateKeySigners)
{
var publicAddress = EthECKey.GetPublicAddress(privateKey);
var signature = messageSigner.Sign(hashEncoded, privateKey);
signatures.Add(new SafeSignature()
{
Address = publicAddress, Signature = signature
});
}
var fullSignature = GetCombinedSignaturesInOrder(signatures);
return(new ExecTransactionFunction()
{
To = transactionData.To,
Value = transactionData.Value,
Data = transactionData.Data,
Operation = transactionData.Operation,
SafeTxGas = transactionData.SafeTxGas,
BaseGas = transactionData.BaseGas,
SafeGasPrice = transactionData.SafeGasPrice,
GasToken = transactionData.GasToken,
RefundReceiver = transactionData.RefundReceiver,
Signatures = fullSignature
});
}
public Task <byte[]> EncodeTransactionDataQueryAsync(EncodeTransactionDataFunction encodeTransactionDataFunction, BlockParameter blockParameter = null)
{
return(ContractHandler.QueryAsync <EncodeTransactionDataFunction, byte[]>(encodeTransactionDataFunction, blockParameter));
}
