id
stringlengths 7
14
| text
stringlengths 1
106k
|
|---|---|
206414745_1642 | public static TransactionValidationParams processingBlock() {
return processingBlockParams;
} |
206414745_1643 | public static TransactionValidationParams transactionPool() {
return transactionPoolParams;
} |
206414745_1644 | public static TransactionValidationParams mining() {
return miningParams;
} |
206414745_1645 | public static TransactionValidationParams blockReplay() {
return blockReplayParams;
} |
206414745_1646 | @Override
public ValidationResult<TransactionInvalidReason> validate(
final Transaction transaction, final Optional<Long> baseFee) {
final ValidationResult<TransactionInvalidReason> signatureResult =
validateTransactionSignature(transaction);
if (!signatureResult.isValid()) {
return signatureResult;
}
if (ExperimentalEIPs.eip1559Enabled && maybeEip1559.isPresent()) {
final EIP1559 eip1559 = maybeEip1559.get();
if (!eip1559.isValidFormat(transaction, acceptedTransactionTypes)) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format(
"transaction format is invalid, accepted transaction types are %s",
acceptedTransactionTypes.toString()));
}
if (transaction.isEIP1559Transaction()) {
final Wei price = transactionPriceCalculator.orElseThrow().price(transaction, baseFee);
if (price.compareTo(Wei.of(baseFee.orElseThrow())) < 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format("gasPrice is less than the current BaseFee"));
}
}
}
final Gas intrinsicGasCost = gasCalculator.transactionIntrinsicGasCost(transaction);
if (intrinsicGasCost.compareTo(Gas.of(transaction.getGasLimit())) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INTRINSIC_GAS_EXCEEDS_GAS_LIMIT,
String.format(
"intrinsic gas cost %s exceeds gas limit %s",
intrinsicGasCost, transaction.getGasLimit()));
}
return ValidationResult.valid();
} |
206414745_1647 | @Override
public ValidationResult<TransactionInvalidReason> validate(
final Transaction transaction, final Optional<Long> baseFee) {
final ValidationResult<TransactionInvalidReason> signatureResult =
validateTransactionSignature(transaction);
if (!signatureResult.isValid()) {
return signatureResult;
}
if (ExperimentalEIPs.eip1559Enabled && maybeEip1559.isPresent()) {
final EIP1559 eip1559 = maybeEip1559.get();
if (!eip1559.isValidFormat(transaction, acceptedTransactionTypes)) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format(
"transaction format is invalid, accepted transaction types are %s",
acceptedTransactionTypes.toString()));
}
if (transaction.isEIP1559Transaction()) {
final Wei price = transactionPriceCalculator.orElseThrow().price(transaction, baseFee);
if (price.compareTo(Wei.of(baseFee.orElseThrow())) < 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format("gasPrice is less than the current BaseFee"));
}
}
}
final Gas intrinsicGasCost = gasCalculator.transactionIntrinsicGasCost(transaction);
if (intrinsicGasCost.compareTo(Gas.of(transaction.getGasLimit())) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INTRINSIC_GAS_EXCEEDS_GAS_LIMIT,
String.format(
"intrinsic gas cost %s exceeds gas limit %s",
intrinsicGasCost, transaction.getGasLimit()));
}
return ValidationResult.valid();
} |
206414745_1648 | @Override
public ValidationResult<TransactionInvalidReason> validate(
final Transaction transaction, final Optional<Long> baseFee) {
final ValidationResult<TransactionInvalidReason> signatureResult =
validateTransactionSignature(transaction);
if (!signatureResult.isValid()) {
return signatureResult;
}
if (ExperimentalEIPs.eip1559Enabled && maybeEip1559.isPresent()) {
final EIP1559 eip1559 = maybeEip1559.get();
if (!eip1559.isValidFormat(transaction, acceptedTransactionTypes)) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format(
"transaction format is invalid, accepted transaction types are %s",
acceptedTransactionTypes.toString()));
}
if (transaction.isEIP1559Transaction()) {
final Wei price = transactionPriceCalculator.orElseThrow().price(transaction, baseFee);
if (price.compareTo(Wei.of(baseFee.orElseThrow())) < 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format("gasPrice is less than the current BaseFee"));
}
}
}
final Gas intrinsicGasCost = gasCalculator.transactionIntrinsicGasCost(transaction);
if (intrinsicGasCost.compareTo(Gas.of(transaction.getGasLimit())) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INTRINSIC_GAS_EXCEEDS_GAS_LIMIT,
String.format(
"intrinsic gas cost %s exceeds gas limit %s",
intrinsicGasCost, transaction.getGasLimit()));
}
return ValidationResult.valid();
} |
206414745_1649 | @Override
public ValidationResult<TransactionInvalidReason> validateForSender(
final Transaction transaction,
final Account sender,
final TransactionValidationParams validationParams) {
Wei senderBalance = Account.DEFAULT_BALANCE;
long senderNonce = Account.DEFAULT_NONCE;
if (sender != null) {
senderBalance = sender.getBalance();
senderNonce = sender.getNonce();
}
if (transaction.getUpfrontCost().compareTo(senderBalance) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.UPFRONT_COST_EXCEEDS_BALANCE,
String.format(
"transaction up-front cost %s exceeds transaction sender account balance %s",
transaction.getUpfrontCost(), senderBalance));
}
if (transaction.getNonce() < senderNonce) {
return ValidationResult.invalid(
TransactionInvalidReason.NONCE_TOO_LOW,
String.format(
"transaction nonce %s below sender account nonce %s",
transaction.getNonce(), senderNonce));
}
if (!validationParams.isAllowFutureNonce() && senderNonce != transaction.getNonce()) {
return ValidationResult.invalid(
TransactionInvalidReason.INCORRECT_NONCE,
String.format(
"transaction nonce %s does not match sender account nonce %s.",
transaction.getNonce(), senderNonce));
}
if (!isSenderAllowed(transaction, validationParams)) {
return ValidationResult.invalid(
TransactionInvalidReason.TX_SENDER_NOT_AUTHORIZED,
String.format("Sender %s is not on the Account Allowlist", transaction.getSender()));
}
return ValidationResult.valid();
} |
206414745_1650 | @Override
public ValidationResult<TransactionInvalidReason> validateForSender(
final Transaction transaction,
final Account sender,
final TransactionValidationParams validationParams) {
Wei senderBalance = Account.DEFAULT_BALANCE;
long senderNonce = Account.DEFAULT_NONCE;
if (sender != null) {
senderBalance = sender.getBalance();
senderNonce = sender.getNonce();
}
if (transaction.getUpfrontCost().compareTo(senderBalance) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.UPFRONT_COST_EXCEEDS_BALANCE,
String.format(
"transaction up-front cost %s exceeds transaction sender account balance %s",
transaction.getUpfrontCost(), senderBalance));
}
if (transaction.getNonce() < senderNonce) {
return ValidationResult.invalid(
TransactionInvalidReason.NONCE_TOO_LOW,
String.format(
"transaction nonce %s below sender account nonce %s",
transaction.getNonce(), senderNonce));
}
if (!validationParams.isAllowFutureNonce() && senderNonce != transaction.getNonce()) {
return ValidationResult.invalid(
TransactionInvalidReason.INCORRECT_NONCE,
String.format(
"transaction nonce %s does not match sender account nonce %s.",
transaction.getNonce(), senderNonce));
}
if (!isSenderAllowed(transaction, validationParams)) {
return ValidationResult.invalid(
TransactionInvalidReason.TX_SENDER_NOT_AUTHORIZED,
String.format("Sender %s is not on the Account Allowlist", transaction.getSender()));
}
return ValidationResult.valid();
} |
206414745_1651 | @Override
public ValidationResult<TransactionInvalidReason> validateForSender(
final Transaction transaction,
final Account sender,
final TransactionValidationParams validationParams) {
Wei senderBalance = Account.DEFAULT_BALANCE;
long senderNonce = Account.DEFAULT_NONCE;
if (sender != null) {
senderBalance = sender.getBalance();
senderNonce = sender.getNonce();
}
if (transaction.getUpfrontCost().compareTo(senderBalance) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.UPFRONT_COST_EXCEEDS_BALANCE,
String.format(
"transaction up-front cost %s exceeds transaction sender account balance %s",
transaction.getUpfrontCost(), senderBalance));
}
if (transaction.getNonce() < senderNonce) {
return ValidationResult.invalid(
TransactionInvalidReason.NONCE_TOO_LOW,
String.format(
"transaction nonce %s below sender account nonce %s",
transaction.getNonce(), senderNonce));
}
if (!validationParams.isAllowFutureNonce() && senderNonce != transaction.getNonce()) {
return ValidationResult.invalid(
TransactionInvalidReason.INCORRECT_NONCE,
String.format(
"transaction nonce %s does not match sender account nonce %s.",
transaction.getNonce(), senderNonce));
}
if (!isSenderAllowed(transaction, validationParams)) {
return ValidationResult.invalid(
TransactionInvalidReason.TX_SENDER_NOT_AUTHORIZED,
String.format("Sender %s is not on the Account Allowlist", transaction.getSender()));
}
return ValidationResult.valid();
} |
206414745_1652 | @Override
public ValidationResult<TransactionInvalidReason> validateForSender(
final Transaction transaction,
final Account sender,
final TransactionValidationParams validationParams) {
Wei senderBalance = Account.DEFAULT_BALANCE;
long senderNonce = Account.DEFAULT_NONCE;
if (sender != null) {
senderBalance = sender.getBalance();
senderNonce = sender.getNonce();
}
if (transaction.getUpfrontCost().compareTo(senderBalance) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.UPFRONT_COST_EXCEEDS_BALANCE,
String.format(
"transaction up-front cost %s exceeds transaction sender account balance %s",
transaction.getUpfrontCost(), senderBalance));
}
if (transaction.getNonce() < senderNonce) {
return ValidationResult.invalid(
TransactionInvalidReason.NONCE_TOO_LOW,
String.format(
"transaction nonce %s below sender account nonce %s",
transaction.getNonce(), senderNonce));
}
if (!validationParams.isAllowFutureNonce() && senderNonce != transaction.getNonce()) {
return ValidationResult.invalid(
TransactionInvalidReason.INCORRECT_NONCE,
String.format(
"transaction nonce %s does not match sender account nonce %s.",
transaction.getNonce(), senderNonce));
}
if (!isSenderAllowed(transaction, validationParams)) {
return ValidationResult.invalid(
TransactionInvalidReason.TX_SENDER_NOT_AUTHORIZED,
String.format("Sender %s is not on the Account Allowlist", transaction.getSender()));
}
return ValidationResult.valid();
} |
206414745_1653 | @Override
public ValidationResult<TransactionInvalidReason> validateForSender(
final Transaction transaction,
final Account sender,
final TransactionValidationParams validationParams) {
Wei senderBalance = Account.DEFAULT_BALANCE;
long senderNonce = Account.DEFAULT_NONCE;
if (sender != null) {
senderBalance = sender.getBalance();
senderNonce = sender.getNonce();
}
if (transaction.getUpfrontCost().compareTo(senderBalance) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.UPFRONT_COST_EXCEEDS_BALANCE,
String.format(
"transaction up-front cost %s exceeds transaction sender account balance %s",
transaction.getUpfrontCost(), senderBalance));
}
if (transaction.getNonce() < senderNonce) {
return ValidationResult.invalid(
TransactionInvalidReason.NONCE_TOO_LOW,
String.format(
"transaction nonce %s below sender account nonce %s",
transaction.getNonce(), senderNonce));
}
if (!validationParams.isAllowFutureNonce() && senderNonce != transaction.getNonce()) {
return ValidationResult.invalid(
TransactionInvalidReason.INCORRECT_NONCE,
String.format(
"transaction nonce %s does not match sender account nonce %s.",
transaction.getNonce(), senderNonce));
}
if (!isSenderAllowed(transaction, validationParams)) {
return ValidationResult.invalid(
TransactionInvalidReason.TX_SENDER_NOT_AUTHORIZED,
String.format("Sender %s is not on the Account Allowlist", transaction.getSender()));
}
return ValidationResult.valid();
} |
206414745_1654 | @Override
public ValidationResult<TransactionInvalidReason> validateForSender(
final Transaction transaction,
final Account sender,
final TransactionValidationParams validationParams) {
Wei senderBalance = Account.DEFAULT_BALANCE;
long senderNonce = Account.DEFAULT_NONCE;
if (sender != null) {
senderBalance = sender.getBalance();
senderNonce = sender.getNonce();
}
if (transaction.getUpfrontCost().compareTo(senderBalance) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.UPFRONT_COST_EXCEEDS_BALANCE,
String.format(
"transaction up-front cost %s exceeds transaction sender account balance %s",
transaction.getUpfrontCost(), senderBalance));
}
if (transaction.getNonce() < senderNonce) {
return ValidationResult.invalid(
TransactionInvalidReason.NONCE_TOO_LOW,
String.format(
"transaction nonce %s below sender account nonce %s",
transaction.getNonce(), senderNonce));
}
if (!validationParams.isAllowFutureNonce() && senderNonce != transaction.getNonce()) {
return ValidationResult.invalid(
TransactionInvalidReason.INCORRECT_NONCE,
String.format(
"transaction nonce %s does not match sender account nonce %s.",
transaction.getNonce(), senderNonce));
}
if (!isSenderAllowed(transaction, validationParams)) {
return ValidationResult.invalid(
TransactionInvalidReason.TX_SENDER_NOT_AUTHORIZED,
String.format("Sender %s is not on the Account Allowlist", transaction.getSender()));
}
return ValidationResult.valid();
} |
206414745_1655 | @Override
public ValidationResult<TransactionInvalidReason> validate(
final Transaction transaction, final Optional<Long> baseFee) {
final ValidationResult<TransactionInvalidReason> signatureResult =
validateTransactionSignature(transaction);
if (!signatureResult.isValid()) {
return signatureResult;
}
if (ExperimentalEIPs.eip1559Enabled && maybeEip1559.isPresent()) {
final EIP1559 eip1559 = maybeEip1559.get();
if (!eip1559.isValidFormat(transaction, acceptedTransactionTypes)) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format(
"transaction format is invalid, accepted transaction types are %s",
acceptedTransactionTypes.toString()));
}
if (transaction.isEIP1559Transaction()) {
final Wei price = transactionPriceCalculator.orElseThrow().price(transaction, baseFee);
if (price.compareTo(Wei.of(baseFee.orElseThrow())) < 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format("gasPrice is less than the current BaseFee"));
}
}
}
final Gas intrinsicGasCost = gasCalculator.transactionIntrinsicGasCost(transaction);
if (intrinsicGasCost.compareTo(Gas.of(transaction.getGasLimit())) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INTRINSIC_GAS_EXCEEDS_GAS_LIMIT,
String.format(
"intrinsic gas cost %s exceeds gas limit %s",
intrinsicGasCost, transaction.getGasLimit()));
}
return ValidationResult.valid();
} |
206414745_1656 | @Override
public ValidationResult<TransactionInvalidReason> validate(
final Transaction transaction, final Optional<Long> baseFee) {
final ValidationResult<TransactionInvalidReason> signatureResult =
validateTransactionSignature(transaction);
if (!signatureResult.isValid()) {
return signatureResult;
}
if (ExperimentalEIPs.eip1559Enabled && maybeEip1559.isPresent()) {
final EIP1559 eip1559 = maybeEip1559.get();
if (!eip1559.isValidFormat(transaction, acceptedTransactionTypes)) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format(
"transaction format is invalid, accepted transaction types are %s",
acceptedTransactionTypes.toString()));
}
if (transaction.isEIP1559Transaction()) {
final Wei price = transactionPriceCalculator.orElseThrow().price(transaction, baseFee);
if (price.compareTo(Wei.of(baseFee.orElseThrow())) < 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format("gasPrice is less than the current BaseFee"));
}
}
}
final Gas intrinsicGasCost = gasCalculator.transactionIntrinsicGasCost(transaction);
if (intrinsicGasCost.compareTo(Gas.of(transaction.getGasLimit())) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INTRINSIC_GAS_EXCEEDS_GAS_LIMIT,
String.format(
"intrinsic gas cost %s exceeds gas limit %s",
intrinsicGasCost, transaction.getGasLimit()));
}
return ValidationResult.valid();
} |
206414745_1657 | @Override
public ValidationResult<TransactionInvalidReason> validate(
final Transaction transaction, final Optional<Long> baseFee) {
final ValidationResult<TransactionInvalidReason> signatureResult =
validateTransactionSignature(transaction);
if (!signatureResult.isValid()) {
return signatureResult;
}
if (ExperimentalEIPs.eip1559Enabled && maybeEip1559.isPresent()) {
final EIP1559 eip1559 = maybeEip1559.get();
if (!eip1559.isValidFormat(transaction, acceptedTransactionTypes)) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format(
"transaction format is invalid, accepted transaction types are %s",
acceptedTransactionTypes.toString()));
}
if (transaction.isEIP1559Transaction()) {
final Wei price = transactionPriceCalculator.orElseThrow().price(transaction, baseFee);
if (price.compareTo(Wei.of(baseFee.orElseThrow())) < 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INVALID_TRANSACTION_FORMAT,
String.format("gasPrice is less than the current BaseFee"));
}
}
}
final Gas intrinsicGasCost = gasCalculator.transactionIntrinsicGasCost(transaction);
if (intrinsicGasCost.compareTo(Gas.of(transaction.getGasLimit())) > 0) {
return ValidationResult.invalid(
TransactionInvalidReason.INTRINSIC_GAS_EXCEEDS_GAS_LIMIT,
String.format(
"intrinsic gas cost %s exceeds gas limit %s",
intrinsicGasCost, transaction.getGasLimit()));
}
return ValidationResult.valid();
} |
206414745_1658 | static void appendPrivacy(
final PrecompileContractRegistry registry,
final PrecompiledContractConfiguration precompiledContractConfiguration,
final int accountVersion) {
if (!precompiledContractConfiguration.getPrivacyParameters().isEnabled()) {
return;
}
if (precompiledContractConfiguration.getPrivacyParameters().isOnchainPrivacyGroupsEnabled()) {
registry.put(
Address.ONCHAIN_PRIVACY,
accountVersion,
new OnChainPrivacyPrecompiledContract(
precompiledContractConfiguration.getGasCalculator(),
precompiledContractConfiguration.getPrivacyParameters()));
} else {
registry.put(
Address.DEFAULT_PRIVACY,
accountVersion,
new PrivacyPrecompiledContract(
precompiledContractConfiguration.getGasCalculator(),
precompiledContractConfiguration.getPrivacyParameters(),
"Privacy"));
}
} |
206414745_1659 | static void appendPrivacy(
final PrecompileContractRegistry registry,
final PrecompiledContractConfiguration precompiledContractConfiguration,
final int accountVersion) {
if (!precompiledContractConfiguration.getPrivacyParameters().isEnabled()) {
return;
}
if (precompiledContractConfiguration.getPrivacyParameters().isOnchainPrivacyGroupsEnabled()) {
registry.put(
Address.ONCHAIN_PRIVACY,
accountVersion,
new OnChainPrivacyPrecompiledContract(
precompiledContractConfiguration.getGasCalculator(),
precompiledContractConfiguration.getPrivacyParameters()));
} else {
registry.put(
Address.DEFAULT_PRIVACY,
accountVersion,
new PrivacyPrecompiledContract(
precompiledContractConfiguration.getGasCalculator(),
precompiledContractConfiguration.getPrivacyParameters(),
"Privacy"));
}
} |
206414745_1660 | static void appendPrivacy(
final PrecompileContractRegistry registry,
final PrecompiledContractConfiguration precompiledContractConfiguration,
final int accountVersion) {
if (!precompiledContractConfiguration.getPrivacyParameters().isEnabled()) {
return;
}
if (precompiledContractConfiguration.getPrivacyParameters().isOnchainPrivacyGroupsEnabled()) {
registry.put(
Address.ONCHAIN_PRIVACY,
accountVersion,
new OnChainPrivacyPrecompiledContract(
precompiledContractConfiguration.getGasCalculator(),
precompiledContractConfiguration.getPrivacyParameters()));
} else {
registry.put(
Address.DEFAULT_PRIVACY,
accountVersion,
new PrivacyPrecompiledContract(
precompiledContractConfiguration.getGasCalculator(),
precompiledContractConfiguration.getPrivacyParameters(),
"Privacy"));
}
} |
206414745_1661 | public static byte[] hashimotoLight(
final long size, final int[] cache, final byte[] header, final long nonce) {
return hashimoto(header, size, nonce, (target, ind) -> calcDatasetItem(target, cache, ind));
} |
206414745_1662 | public static int[] mkCache(final int cacheSize, final long block) {
final MessageDigest keccak512 = KECCAK_512.get();
keccak512.update(DirectAcyclicGraphSeed.dagSeed(block));
final int rows = cacheSize / HASH_BYTES;
final byte[] cache = new byte[rows * HASH_BYTES];
try {
keccak512.digest(cache, 0, HASH_BYTES);
} catch (final DigestException ex) {
throw new IllegalStateException(ex);
}
for (int i = 1; i < rows; ++i) {
keccak512.update(cache, (i - 1) * HASH_BYTES, HASH_BYTES);
try {
keccak512.digest(cache, i * HASH_BYTES, HASH_BYTES);
} catch (final DigestException ex) {
throw new IllegalStateException(ex);
}
}
final byte[] temp = new byte[HASH_BYTES];
for (int i = 0; i < CACHE_ROUNDS; ++i) {
for (int j = 0; j < rows; ++j) {
final int offset = j * HASH_BYTES;
for (int k = 0; k < HASH_BYTES; ++k) {
temp[k] =
(byte)
(cache[(j - 1 + rows) % rows * HASH_BYTES + k]
^ cache[
Integer.remainderUnsigned(readLittleEndianInt(cache, offset), rows)
* HASH_BYTES
+ k]);
}
keccak512.update(temp);
try {
keccak512.digest(temp, 0, HASH_BYTES);
} catch (final DigestException ex) {
throw new IllegalStateException(ex);
}
System.arraycopy(temp, 0, cache, offset, HASH_BYTES);
}
}
final int[] result = new int[cache.length / 4];
ByteBuffer.wrap(cache).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().get(result);
return result;
} |
206414745_1663 | @Override
public Result processBlock(
final Blockchain blockchain,
final MutableWorldState worldState,
final BlockHeader blockHeader,
final List<Transaction> transactions,
final List<BlockHeader> ommers,
final PrivateMetadataUpdater privateMetadataUpdater) {
if (privateMetadataUpdater != null) {
throw new IllegalArgumentException("PrivateMetadataUpdater passed in is not null.");
}
maybeRehydrate(blockchain, blockHeader, transactions);
final PrivateMetadataUpdater metadataUpdater =
new PrivateMetadataUpdater(blockHeader, privateStateStorage);
final Result result =
blockProcessor.processBlock(
blockchain, worldState, blockHeader, transactions, ommers, metadataUpdater);
metadataUpdater.commit();
return result;
} |
206414745_1664 | @Override
public Result processBlock(
final Blockchain blockchain,
final MutableWorldState worldState,
final BlockHeader blockHeader,
final List<Transaction> transactions,
final List<BlockHeader> ommers,
final PrivateMetadataUpdater privateMetadataUpdater) {
if (privateMetadataUpdater != null) {
throw new IllegalArgumentException("PrivateMetadataUpdater passed in is not null.");
}
maybeRehydrate(blockchain, blockHeader, transactions);
final PrivateMetadataUpdater metadataUpdater =
new PrivateMetadataUpdater(blockHeader, privateStateStorage);
final Result result =
blockProcessor.processBlock(
blockchain, worldState, blockHeader, transactions, ommers, metadataUpdater);
metadataUpdater.commit();
return result;
} |
206414745_1665 | public EthHashSolution solveFor(final EthHashSolverJob job)
throws InterruptedException, ExecutionException {
currentJob = Optional.of(job);
if (stratumMiningEnabled) {
ethHashObservers.forEach(observer -> observer.newJob(job.inputs));
} else {
findValidNonce();
}
return currentJob.get().getSolution();
} |
206414745_1666 | public static ProtocolSchedule create() {
return fromConfig(
GenesisConfigFile.mainnet().getConfigOptions(), PrivacyParameters.DEFAULT, false);
} |
206414745_1667 | public static ProtocolSchedule fromConfig(
final GenesisConfigOptions config,
final PrivacyParameters privacyParameters,
final boolean isRevertReasonEnabled) {
if (FixedDifficultyCalculators.isFixedDifficultyInConfig(config)) {
return FixedDifficultyProtocolSchedule.create(
config, privacyParameters, isRevertReasonEnabled);
}
return new ProtocolScheduleBuilder(
config, DEFAULT_CHAIN_ID, Function.identity(), privacyParameters, isRevertReasonEnabled)
.createProtocolSchedule();
} |
206414745_1668 | public static ProtocolSchedule fromConfig(
final GenesisConfigOptions config,
final PrivacyParameters privacyParameters,
final boolean isRevertReasonEnabled) {
if (FixedDifficultyCalculators.isFixedDifficultyInConfig(config)) {
return FixedDifficultyProtocolSchedule.create(
config, privacyParameters, isRevertReasonEnabled);
}
return new ProtocolScheduleBuilder(
config, DEFAULT_CHAIN_ID, Function.identity(), privacyParameters, isRevertReasonEnabled)
.createProtocolSchedule();
} |
206414745_1669 | public static ProtocolSchedule fromConfig(
final GenesisConfigOptions config,
final PrivacyParameters privacyParameters,
final boolean isRevertReasonEnabled) {
if (FixedDifficultyCalculators.isFixedDifficultyInConfig(config)) {
return FixedDifficultyProtocolSchedule.create(
config, privacyParameters, isRevertReasonEnabled);
}
return new ProtocolScheduleBuilder(
config, DEFAULT_CHAIN_ID, Function.identity(), privacyParameters, isRevertReasonEnabled)
.createProtocolSchedule();
} |
206414745_1670 | public static ProtocolSchedule fromConfig(
final GenesisConfigOptions config,
final PrivacyParameters privacyParameters,
final boolean isRevertReasonEnabled) {
if (FixedDifficultyCalculators.isFixedDifficultyInConfig(config)) {
return FixedDifficultyProtocolSchedule.create(
config, privacyParameters, isRevertReasonEnabled);
}
return new ProtocolScheduleBuilder(
config, DEFAULT_CHAIN_ID, Function.identity(), privacyParameters, isRevertReasonEnabled)
.createProtocolSchedule();
} |
206414745_1671 | public static ProtocolSchedule fromConfig(
final GenesisConfigOptions config,
final PrivacyParameters privacyParameters,
final boolean isRevertReasonEnabled) {
if (FixedDifficultyCalculators.isFixedDifficultyInConfig(config)) {
return FixedDifficultyProtocolSchedule.create(
config, privacyParameters, isRevertReasonEnabled);
}
return new ProtocolScheduleBuilder(
config, DEFAULT_CHAIN_ID, Function.identity(), privacyParameters, isRevertReasonEnabled)
.createProtocolSchedule();
} |
206414745_1672 | public static ProtocolSchedule fromConfig(
final GenesisConfigOptions config,
final PrivacyParameters privacyParameters,
final boolean isRevertReasonEnabled) {
if (FixedDifficultyCalculators.isFixedDifficultyInConfig(config)) {
return FixedDifficultyProtocolSchedule.create(
config, privacyParameters, isRevertReasonEnabled);
}
return new ProtocolScheduleBuilder(
config, DEFAULT_CHAIN_ID, Function.identity(), privacyParameters, isRevertReasonEnabled)
.createProtocolSchedule();
} |
206414745_1673 | @Override
public Gas gasRequirement(final Bytes input) {
final int k = input.size() / 384;
return Gas.of(23_000L * k + 115_000);
} |
206414745_1674 | @Override
public Gas gasRequirement(final Bytes input) {
return Gas.of(600);
} |
206414745_1675 | @Override
public Gas gasRequirement(final Bytes input) {
return Gas.of(110_000);
} |
206414745_1676 | @Override
public Gas gasRequirement(final Bytes input) {
final int k = input.size() / 288;
return Gas.of(55L * k * getDiscount(k));
} |
206414745_1677 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.slice(0, 32).toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final VersionedPrivateTransaction versionedPrivateTransaction =
VersionedPrivateTransaction.readFrom(bytesValueRLPInput);
final PrivateTransaction privateTransaction =
versionedPrivateTransaction.getPrivateTransaction();
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Optional<Bytes> maybeGroupId = privateTransaction.getPrivacyGroupId();
if (maybeGroupId.isEmpty()) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId = Bytes32.wrap(maybeGroupId.get());
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final ProcessableBlockHeader currentBlockHeader = messageFrame.getBlockHeader();
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final WorldUpdater publicWorldState = messageFrame.getWorldState();
final Blockchain blockchain = messageFrame.getBlockchain();
maybeInjectDefaultManagementAndProxy(
lastRootHash, disposablePrivateState, privateWorldStateUpdater);
if (!canExecute(
messageFrame,
currentBlockHeader,
privateTransaction,
versionedPrivateTransaction.getVersion(),
publicWorldState,
privacyGroupId,
blockchain,
disposablePrivateState,
privateWorldStateUpdater,
privateFrom)) {
return Bytes.EMPTY;
}
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
sendParticipantRemovedEvent(privateTransaction);
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1678 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.slice(0, 32).toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final VersionedPrivateTransaction versionedPrivateTransaction =
VersionedPrivateTransaction.readFrom(bytesValueRLPInput);
final PrivateTransaction privateTransaction =
versionedPrivateTransaction.getPrivateTransaction();
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Optional<Bytes> maybeGroupId = privateTransaction.getPrivacyGroupId();
if (maybeGroupId.isEmpty()) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId = Bytes32.wrap(maybeGroupId.get());
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final ProcessableBlockHeader currentBlockHeader = messageFrame.getBlockHeader();
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final WorldUpdater publicWorldState = messageFrame.getWorldState();
final Blockchain blockchain = messageFrame.getBlockchain();
maybeInjectDefaultManagementAndProxy(
lastRootHash, disposablePrivateState, privateWorldStateUpdater);
if (!canExecute(
messageFrame,
currentBlockHeader,
privateTransaction,
versionedPrivateTransaction.getVersion(),
publicWorldState,
privacyGroupId,
blockchain,
disposablePrivateState,
privateWorldStateUpdater,
privateFrom)) {
return Bytes.EMPTY;
}
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
sendParticipantRemovedEvent(privateTransaction);
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1679 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.slice(0, 32).toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final VersionedPrivateTransaction versionedPrivateTransaction =
VersionedPrivateTransaction.readFrom(bytesValueRLPInput);
final PrivateTransaction privateTransaction =
versionedPrivateTransaction.getPrivateTransaction();
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Optional<Bytes> maybeGroupId = privateTransaction.getPrivacyGroupId();
if (maybeGroupId.isEmpty()) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId = Bytes32.wrap(maybeGroupId.get());
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final ProcessableBlockHeader currentBlockHeader = messageFrame.getBlockHeader();
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final WorldUpdater publicWorldState = messageFrame.getWorldState();
final Blockchain blockchain = messageFrame.getBlockchain();
maybeInjectDefaultManagementAndProxy(
lastRootHash, disposablePrivateState, privateWorldStateUpdater);
if (!canExecute(
messageFrame,
currentBlockHeader,
privateTransaction,
versionedPrivateTransaction.getVersion(),
publicWorldState,
privacyGroupId,
blockchain,
disposablePrivateState,
privateWorldStateUpdater,
privateFrom)) {
return Bytes.EMPTY;
}
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
sendParticipantRemovedEvent(privateTransaction);
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1680 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.slice(0, 32).toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final VersionedPrivateTransaction versionedPrivateTransaction =
VersionedPrivateTransaction.readFrom(bytesValueRLPInput);
final PrivateTransaction privateTransaction =
versionedPrivateTransaction.getPrivateTransaction();
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Optional<Bytes> maybeGroupId = privateTransaction.getPrivacyGroupId();
if (maybeGroupId.isEmpty()) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId = Bytes32.wrap(maybeGroupId.get());
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final ProcessableBlockHeader currentBlockHeader = messageFrame.getBlockHeader();
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final WorldUpdater publicWorldState = messageFrame.getWorldState();
final Blockchain blockchain = messageFrame.getBlockchain();
maybeInjectDefaultManagementAndProxy(
lastRootHash, disposablePrivateState, privateWorldStateUpdater);
if (!canExecute(
messageFrame,
currentBlockHeader,
privateTransaction,
versionedPrivateTransaction.getVersion(),
publicWorldState,
privacyGroupId,
blockchain,
disposablePrivateState,
privateWorldStateUpdater,
privateFrom)) {
return Bytes.EMPTY;
}
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
sendParticipantRemovedEvent(privateTransaction);
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1681 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final PrivateTransaction privateTransaction =
PrivateTransaction.readFrom(bytesValueRLPInput.readAsRlp());
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId =
Bytes32.wrap(Bytes.fromBase64String(receiveResponse.getPrivacyGroupId()));
try {
if (privateTransaction.getPrivateFor().isEmpty()
&& !enclave
.retrievePrivacyGroup(privacyGroupId.toBase64String())
.getMembers()
.contains(privateFrom.toBase64String())) {
return Bytes.EMPTY;
}
} catch (final EnclaveClientException e) {
// This exception is thrown when the privacy group can not be found
return Bytes.EMPTY;
} catch (final EnclaveServerException e) {
LOG.error("Enclave is responding with an error, perhaps it has a misconfiguration?", e);
throw e;
} catch (final EnclaveIOException e) {
LOG.error("Can not communicate with enclave, is it up?", e);
throw e;
}
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1682 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final PrivateTransaction privateTransaction =
PrivateTransaction.readFrom(bytesValueRLPInput.readAsRlp());
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId =
Bytes32.wrap(Bytes.fromBase64String(receiveResponse.getPrivacyGroupId()));
try {
if (privateTransaction.getPrivateFor().isEmpty()
&& !enclave
.retrievePrivacyGroup(privacyGroupId.toBase64String())
.getMembers()
.contains(privateFrom.toBase64String())) {
return Bytes.EMPTY;
}
} catch (final EnclaveClientException e) {
// This exception is thrown when the privacy group can not be found
return Bytes.EMPTY;
} catch (final EnclaveServerException e) {
LOG.error("Enclave is responding with an error, perhaps it has a misconfiguration?", e);
throw e;
} catch (final EnclaveIOException e) {
LOG.error("Can not communicate with enclave, is it up?", e);
throw e;
}
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1683 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final PrivateTransaction privateTransaction =
PrivateTransaction.readFrom(bytesValueRLPInput.readAsRlp());
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId =
Bytes32.wrap(Bytes.fromBase64String(receiveResponse.getPrivacyGroupId()));
try {
if (privateTransaction.getPrivateFor().isEmpty()
&& !enclave
.retrievePrivacyGroup(privacyGroupId.toBase64String())
.getMembers()
.contains(privateFrom.toBase64String())) {
return Bytes.EMPTY;
}
} catch (final EnclaveClientException e) {
// This exception is thrown when the privacy group can not be found
return Bytes.EMPTY;
} catch (final EnclaveServerException e) {
LOG.error("Enclave is responding with an error, perhaps it has a misconfiguration?", e);
throw e;
} catch (final EnclaveIOException e) {
LOG.error("Can not communicate with enclave, is it up?", e);
throw e;
}
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1684 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final PrivateTransaction privateTransaction =
PrivateTransaction.readFrom(bytesValueRLPInput.readAsRlp());
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId =
Bytes32.wrap(Bytes.fromBase64String(receiveResponse.getPrivacyGroupId()));
try {
if (privateTransaction.getPrivateFor().isEmpty()
&& !enclave
.retrievePrivacyGroup(privacyGroupId.toBase64String())
.getMembers()
.contains(privateFrom.toBase64String())) {
return Bytes.EMPTY;
}
} catch (final EnclaveClientException e) {
// This exception is thrown when the privacy group can not be found
return Bytes.EMPTY;
} catch (final EnclaveServerException e) {
LOG.error("Enclave is responding with an error, perhaps it has a misconfiguration?", e);
throw e;
} catch (final EnclaveIOException e) {
LOG.error("Can not communicate with enclave, is it up?", e);
throw e;
}
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1685 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final PrivateTransaction privateTransaction =
PrivateTransaction.readFrom(bytesValueRLPInput.readAsRlp());
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId =
Bytes32.wrap(Bytes.fromBase64String(receiveResponse.getPrivacyGroupId()));
try {
if (privateTransaction.getPrivateFor().isEmpty()
&& !enclave
.retrievePrivacyGroup(privacyGroupId.toBase64String())
.getMembers()
.contains(privateFrom.toBase64String())) {
return Bytes.EMPTY;
}
} catch (final EnclaveClientException e) {
// This exception is thrown when the privacy group can not be found
return Bytes.EMPTY;
} catch (final EnclaveServerException e) {
LOG.error("Enclave is responding with an error, perhaps it has a misconfiguration?", e);
throw e;
} catch (final EnclaveIOException e) {
LOG.error("Can not communicate with enclave, is it up?", e);
throw e;
}
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1686 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (skipContractExecution(messageFrame)) {
return Bytes.EMPTY;
}
final Hash pmtHash = messageFrame.getTransactionHash();
final String key = input.toBase64String();
final ReceiveResponse receiveResponse;
try {
receiveResponse = getReceiveResponse(key);
} catch (final EnclaveClientException e) {
LOG.debug("Can not fetch private transaction payload with key {}", key, e);
return Bytes.EMPTY;
}
final BytesValueRLPInput bytesValueRLPInput =
new BytesValueRLPInput(
Bytes.wrap(Base64.getDecoder().decode(receiveResponse.getPayload())), false);
final PrivateTransaction privateTransaction =
PrivateTransaction.readFrom(bytesValueRLPInput.readAsRlp());
final Bytes privateFrom = privateTransaction.getPrivateFrom();
if (!privateFromMatchesSenderKey(privateFrom, receiveResponse.getSenderKey())) {
return Bytes.EMPTY;
}
final Bytes32 privacyGroupId =
Bytes32.wrap(Bytes.fromBase64String(receiveResponse.getPrivacyGroupId()));
try {
if (privateTransaction.getPrivateFor().isEmpty()
&& !enclave
.retrievePrivacyGroup(privacyGroupId.toBase64String())
.getMembers()
.contains(privateFrom.toBase64String())) {
return Bytes.EMPTY;
}
} catch (final EnclaveClientException e) {
// This exception is thrown when the privacy group can not be found
return Bytes.EMPTY;
} catch (final EnclaveServerException e) {
LOG.error("Enclave is responding with an error, perhaps it has a misconfiguration?", e);
throw e;
} catch (final EnclaveIOException e) {
LOG.error("Can not communicate with enclave, is it up?", e);
throw e;
}
LOG.debug("Processing private transaction {} in privacy group {}", pmtHash, privacyGroupId);
final PrivateMetadataUpdater privateMetadataUpdater = messageFrame.getPrivateMetadataUpdater();
final Hash lastRootHash =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, privateMetadataUpdater);
final MutableWorldState disposablePrivateState =
privateWorldStateArchive.getMutable(lastRootHash).get();
final WorldUpdater privateWorldStateUpdater = disposablePrivateState.updater();
final PrivateTransactionProcessor.Result result =
processPrivateTransaction(
messageFrame, privateTransaction, privacyGroupId, privateWorldStateUpdater);
if (result.isInvalid() || !result.isSuccessful()) {
LOG.error(
"Failed to process private transaction {}: {}",
pmtHash,
result.getValidationResult().getErrorMessage());
privateMetadataUpdater.putTransactionReceipt(pmtHash, new PrivateTransactionReceipt(result));
return Bytes.EMPTY;
}
if (messageFrame.isPersistingPrivateState()) {
privateWorldStateUpdater.commit();
disposablePrivateState.persist();
storePrivateMetadata(
pmtHash, privacyGroupId, disposablePrivateState, privateMetadataUpdater, result);
}
return result.getOutput();
} |
206414745_1687 | @Override
public Gas gasRequirement(final Bytes input) {
return Gas.of(5_500);
} |
206414745_1688 | @Override
public Gas gasRequirement(final Bytes input) {
final int k = input.size() / 160;
return Gas.of(12L * k * getDiscount(k));
} |
206414745_1689 | @Override
public Gas gasRequirement(final Bytes input) {
return Gas.of(4_500);
} |
206414745_1690 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
final int size = input.size();
final Bytes d = size >= 128 ? input : Bytes.wrap(input, MutableBytes.create(128 - size));
final Bytes32 h = Bytes32.wrap(d, 0);
// Note that the Yellow Paper defines v as the next 32 bytes (so 32..63). Yet, v is a simple
// byte in ECDSARECOVER and the Yellow Paper is not very clear on this mismatch but it appears
// it is simply the last byte of those 32 bytes that needs to be used. It does appear we need
// to check the rest of the bytes are zero though.
if (!d.slice(32, 31).isZero()) {
return Bytes.EMPTY;
}
final int recId = d.get(63) - V_BASE;
final BigInteger r = d.slice(64, 32).toUnsignedBigInteger();
final BigInteger s = d.slice(96, 32).toUnsignedBigInteger();
final Signature signature;
try {
signature = Signature.create(r, s, (byte) recId);
} catch (final IllegalArgumentException e) {
return Bytes.EMPTY;
}
// SECP256K1#PublicKey#recoverFromSignature throws an Illegal argument exception
// when it is unable to recover the key. There is not a straightforward way to
// check the arguments ahead of time to determine if the fail will happen and
// the library needs to be updated.
try {
final Optional<PublicKey> recovered = PublicKey.recoverFromSignature(h, signature);
if (!recovered.isPresent()) {
return Bytes.EMPTY;
}
final Bytes32 hashed = Hash.hash(recovered.get().getEncodedBytes());
final MutableBytes32 result = MutableBytes32.create();
hashed.slice(12).copyTo(result, 12);
return result;
} catch (final IllegalArgumentException e) {
return Bytes.EMPTY;
}
} |
206414745_1691 | @Override
public Gas gasRequirement(final Bytes input) {
return Gas.of(55_000);
} |
206414745_1692 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (input.isEmpty()) {
return TRUE;
}
if (input.size() % PARAMETER_LENGTH != 0) {
return null;
}
if (AltBN128PairingPrecompiledContract.useNative) {
return computeNative(input);
} else {
return computeDefault(input);
}
} |
206414745_1693 | @Override
public Bytes compute(final Bytes input, final MessageFrame messageFrame) {
if (input.isEmpty()) {
return TRUE;
}
if (input.size() % PARAMETER_LENGTH != 0) {
return null;
}
if (AltBN128PairingPrecompiledContract.useNative) {
return computeNative(input);
} else {
return computeDefault(input);
}
} |
206414745_1694 | @Override
public Gas gasRequirement(final Bytes input) {
final int parameters = input.size() / PARAMETER_LENGTH;
return pairingGasCost.times(parameters).plus(baseGasCost);
} |
206414745_1695 | @Override
public Gas gasRequirement(final Bytes input) {
final int parameters = input.size() / PARAMETER_LENGTH;
return pairingGasCost.times(parameters).plus(baseGasCost);
} |
206414745_1696 | @Override
public Gas gasRequirement(final Bytes input) {
return Gas.of(12_000);
} |
206414745_1697 | public static Hash transactionsRoot(final List<Transaction> transactions) {
final MerklePatriciaTrie<Bytes, Bytes> trie = trie();
for (int i = 0; i < transactions.size(); ++i) {
trie.put(indexKey(i), RLP.encode(transactions.get(i)::writeTo));
}
return Hash.wrap(trie.getRootHash());
} |
206414745_1698 | public static Hash ommersHash(final List<BlockHeader> ommers) {
return Hash.wrap(keccak256(RLP.encode(out -> out.writeList(ommers, BlockHeader::writeTo))));
} |
206414745_1699 | public static BlockHeaderValidator.Builder create() {
return createValidator();
} |
206414745_1700 | public static BlockHeaderValidator.Builder create() {
return createValidator();
} |
206414745_1701 | public static BlockHeaderValidator.Builder create() {
return createValidator();
} |
206414745_1702 | public static BlockHeaderValidator.Builder create() {
return createValidator();
} |
206414745_1703 | @Override
public Result processTransaction(
final Blockchain blockchain,
final WorldUpdater worldState,
final ProcessableBlockHeader blockHeader,
final Transaction transaction,
final Address miningBeneficiary,
final OperationTracer operationTracer,
final BlockHashLookup blockHashLookup,
final Boolean isPersistingPrivateState,
final TransactionValidationParams transactionValidationParams,
final PrivateMetadataUpdater privateMetadataUpdater) {
try {
LOG.trace("Starting execution of {}", transaction);
ValidationResult<TransactionValidator.TransactionInvalidReason> validationResult =
transactionValidator.validate(transaction, blockHeader.getBaseFee());
// Make sure the transaction is intrinsically valid before trying to
// compare against a sender account (because the transaction may not
// be signed correctly to extract the sender).
if (!validationResult.isValid()) {
LOG.warn("Invalid transaction: {}", validationResult.getErrorMessage());
return Result.invalid(validationResult);
}
final Address senderAddress = transaction.getSender();
final EvmAccount sender = worldState.getOrCreate(senderAddress);
validationResult =
transactionValidator.validateForSender(transaction, sender, transactionValidationParams);
if (!validationResult.isValid()) {
LOG.debug("Invalid transaction: {}", validationResult.getErrorMessage());
return Result.invalid(validationResult);
}
final MutableAccount senderMutableAccount = sender.getMutable();
final long previousNonce = senderMutableAccount.incrementNonce();
final Wei transactionGasPrice =
transactionPriceCalculator.price(transaction, blockHeader.getBaseFee());
LOG.trace(
"Incremented sender {} nonce ({} -> {})",
senderAddress,
previousNonce,
sender.getNonce());
final Wei upfrontGasCost = transaction.getUpfrontGasCost(transactionGasPrice);
final Wei previousBalance = senderMutableAccount.decrementBalance(upfrontGasCost);
LOG.trace(
"Deducted sender {} upfront gas cost {} ({} -> {})",
senderAddress,
upfrontGasCost,
previousBalance,
sender.getBalance());
final Gas intrinsicGas = gasCalculator.transactionIntrinsicGasCost(transaction);
final Gas gasAvailable = Gas.of(transaction.getGasLimit()).minus(intrinsicGas);
LOG.trace(
"Gas available for execution {} = {} - {} (limit - intrinsic)",
gasAvailable,
transaction.getGasLimit(),
intrinsicGas);
final WorldUpdater worldUpdater = worldState.updater();
final MessageFrame initialFrame;
final Deque<MessageFrame> messageFrameStack = new ArrayDeque<>();
final ReturnStack returnStack = new ReturnStack();
if (transaction.isContractCreation()) {
final Address contractAddress =
Address.contractAddress(senderAddress, sender.getNonce() - 1L);
initialFrame =
MessageFrame.builder()
.type(MessageFrame.Type.CONTRACT_CREATION)
.messageFrameStack(messageFrameStack)
.returnStack(returnStack)
.blockchain(blockchain)
.worldState(worldUpdater.updater())
.initialGas(gasAvailable)
.address(contractAddress)
.originator(senderAddress)
.contract(contractAddress)
.contractAccountVersion(createContractAccountVersion)
.gasPrice(transactionGasPrice)
.inputData(Bytes.EMPTY)
.sender(senderAddress)
.value(transaction.getValue())
.apparentValue(transaction.getValue())
.code(new Code(transaction.getPayload()))
.blockHeader(blockHeader)
.depth(0)
.completer(c -> {})
.miningBeneficiary(miningBeneficiary)
.blockHashLookup(blockHashLookup)
.isPersistingPrivateState(isPersistingPrivateState)
.maxStackSize(maxStackSize)
.transactionHash(transaction.getHash())
.privateMetadataUpdater(privateMetadataUpdater)
.build();
} else {
final Address to = transaction.getTo().get();
final Account contract = worldState.get(to);
initialFrame =
MessageFrame.builder()
.type(MessageFrame.Type.MESSAGE_CALL)
.messageFrameStack(messageFrameStack)
.returnStack(returnStack)
.blockchain(blockchain)
.worldState(worldUpdater.updater())
.initialGas(gasAvailable)
.address(to)
.originator(senderAddress)
.contract(to)
.contractAccountVersion(
contract != null ? contract.getVersion() : Account.DEFAULT_VERSION)
.gasPrice(transactionGasPrice)
.inputData(transaction.getPayload())
.sender(senderAddress)
.value(transaction.getValue())
.apparentValue(transaction.getValue())
.code(new Code(contract != null ? contract.getCode() : Bytes.EMPTY))
.blockHeader(blockHeader)
.depth(0)
.completer(c -> {})
.miningBeneficiary(miningBeneficiary)
.blockHashLookup(blockHashLookup)
.maxStackSize(maxStackSize)
.isPersistingPrivateState(isPersistingPrivateState)
.transactionHash(transaction.getHash())
.privateMetadataUpdater(privateMetadataUpdater)
.build();
}
messageFrameStack.addFirst(initialFrame);
while (!messageFrameStack.isEmpty()) {
process(messageFrameStack.peekFirst(), operationTracer);
}
if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) {
worldUpdater.commit();
}
if (LOG.isTraceEnabled()) {
LOG.trace(
"Gas used by transaction: {}, by message call/contract creation: {}",
() -> Gas.of(transaction.getGasLimit()).minus(initialFrame.getRemainingGas()),
() -> gasAvailable.minus(initialFrame.getRemainingGas()));
}
// Refund the sender by what we should and pay the miner fee (note that we're doing them one
// after the other so that if it is the same account somehow, we end up with the right result)
final Gas selfDestructRefund =
gasCalculator.getSelfDestructRefundAmount().times(initialFrame.getSelfDestructs().size());
final Gas refundGas = initialFrame.getGasRefund().plus(selfDestructRefund);
final Gas refunded = refunded(transaction, initialFrame.getRemainingGas(), refundGas);
final Wei refundedWei = refunded.priceFor(transactionGasPrice);
senderMutableAccount.incrementBalance(refundedWei);
final Gas gasUsedByTransaction =
Gas.of(transaction.getGasLimit()).minus(initialFrame.getRemainingGas());
final MutableAccount coinbase = worldState.getOrCreate(miningBeneficiary).getMutable();
final Gas coinbaseFee = Gas.of(transaction.getGasLimit()).minus(refunded);
if (blockHeader.getBaseFee().isPresent() && transaction.isEIP1559Transaction()) {
final Wei baseFee = Wei.of(blockHeader.getBaseFee().get());
if (transactionGasPrice.compareTo(baseFee) < 0) {
return Result.failed(
gasUsedByTransaction.toLong(),
refunded.toLong(),
ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.TRANSACTION_PRICE_TOO_LOW,
"transaction price must be greater than base fee"),
Optional.empty());
}
}
final CoinbaseFeePriceCalculator coinbaseCreditService =
transaction.isFrontierTransaction()
? CoinbaseFeePriceCalculator.frontier()
: coinbaseFeePriceCalculator;
final Wei coinbaseWeiDelta =
coinbaseCreditService.price(coinbaseFee, transactionGasPrice, blockHeader.getBaseFee());
coinbase.incrementBalance(coinbaseWeiDelta);
initialFrame.getSelfDestructs().forEach(worldState::deleteAccount);
if (clearEmptyAccounts) {
clearEmptyAccounts(worldState);
}
if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) {
return Result.successful(
initialFrame.getLogs(),
gasUsedByTransaction.toLong(),
refunded.toLong(),
initialFrame.getOutputData(),
validationResult);
} else {
return Result.failed(
gasUsedByTransaction.toLong(),
refunded.toLong(),
validationResult,
initialFrame.getRevertReason());
}
} catch (final RuntimeException re) {
LOG.error("Critical Exception Processing Transaction", re);
return Result.invalid(
ValidationResult.invalid(
TransactionInvalidReason.INTERNAL_ERROR,
"Internal Error in Besu - " + re.toString()));
}
} |
206414745_1704 | public Optional<Bytes> getContractCode(
final String privacyGroupId, final Hash blockHash, final Address contractAddress) {
final Hash latestStateRoot =
privateStateRootResolver.resolveLastStateRoot(
Bytes32.wrap(Bytes.fromBase64String(privacyGroupId)), blockHash);
return privateWorldStateArchive
.get(latestStateRoot)
.flatMap(worldState -> Optional.ofNullable(worldState.get(contractAddress)))
.flatMap(account -> Optional.ofNullable(account.getCode()));
} |
206414745_1705 | public Optional<Bytes> getContractCode(
final String privacyGroupId, final Hash blockHash, final Address contractAddress) {
final Hash latestStateRoot =
privateStateRootResolver.resolveLastStateRoot(
Bytes32.wrap(Bytes.fromBase64String(privacyGroupId)), blockHash);
return privateWorldStateArchive
.get(latestStateRoot)
.flatMap(worldState -> Optional.ofNullable(worldState.get(contractAddress)))
.flatMap(account -> Optional.ofNullable(account.getCode()));
} |
206414745_1706 | public Optional<Bytes> getContractCode(
final String privacyGroupId, final Hash blockHash, final Address contractAddress) {
final Hash latestStateRoot =
privateStateRootResolver.resolveLastStateRoot(
Bytes32.wrap(Bytes.fromBase64String(privacyGroupId)), blockHash);
return privateWorldStateArchive
.get(latestStateRoot)
.flatMap(worldState -> Optional.ofNullable(worldState.get(contractAddress)))
.flatMap(account -> Optional.ofNullable(account.getCode()));
} |
206414745_1707 | public Optional<Bytes> getContractCode(
final String privacyGroupId, final Hash blockHash, final Address contractAddress) {
final Hash latestStateRoot =
privateStateRootResolver.resolveLastStateRoot(
Bytes32.wrap(Bytes.fromBase64String(privacyGroupId)), blockHash);
return privateWorldStateArchive
.get(latestStateRoot)
.flatMap(worldState -> Optional.ofNullable(worldState.get(contractAddress)))
.flatMap(account -> Optional.ofNullable(account.getCode()));
} |
206414745_1708 | public List<PrivateTransactionMetadata> getPrivateTransactionMetadataList(
final String privacyGroupId, final Hash blockHash) {
final Bytes32 privacyGroupIdBytes = Bytes32.wrap(Bytes.fromBase64String(privacyGroupId));
final Optional<PrivateBlockMetadata> privateBlockMetadata =
privateStateStorage.getPrivateBlockMetadata(blockHash, privacyGroupIdBytes);
return privateBlockMetadata
.map(PrivateBlockMetadata::getPrivateTransactionMetadataList)
.orElse(Collections.emptyList());
} |
206414745_1709 | public List<PrivateTransactionMetadata> getPrivateTransactionMetadataList(
final String privacyGroupId, final Hash blockHash) {
final Bytes32 privacyGroupIdBytes = Bytes32.wrap(Bytes.fromBase64String(privacyGroupId));
final Optional<PrivateBlockMetadata> privateBlockMetadata =
privateStateStorage.getPrivateBlockMetadata(blockHash, privacyGroupIdBytes);
return privateBlockMetadata
.map(PrivateBlockMetadata::getPrivateTransactionMetadataList)
.orElse(Collections.emptyList());
} |
206414745_1710 | public Optional<PrivateTransactionReceipt> getPrivateTransactionReceipt(
final Hash blockHash, final Hash transactionHash) {
return privateStateStorage.getTransactionReceipt(blockHash, transactionHash);
} |
206414745_1711 | public Optional<PrivateTransactionReceipt> getPrivateTransactionReceipt(
final Hash blockHash, final Hash transactionHash) {
return privateStateStorage.getTransactionReceipt(blockHash, transactionHash);
} |
206414745_1712 | @Override
public long getNonce(final Address sender, final Bytes32 privacyGroupId) {
final BlockHeader chainHeadHeader = blockchain.getChainHeadHeader();
final Hash stateRoot =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, chainHeadHeader.getHash());
return privateWorldStateArchive
.get(stateRoot)
.map(
privateWorldState -> {
final Account account = privateWorldState.get(sender);
return account == null ? 0L : account.getNonce();
})
.orElse(Account.DEFAULT_NONCE);
} |
206414745_1713 | @Override
public long getNonce(final Address sender, final Bytes32 privacyGroupId) {
final BlockHeader chainHeadHeader = blockchain.getChainHeadHeader();
final Hash stateRoot =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, chainHeadHeader.getHash());
return privateWorldStateArchive
.get(stateRoot)
.map(
privateWorldState -> {
final Account account = privateWorldState.get(sender);
return account == null ? 0L : account.getNonce();
})
.orElse(Account.DEFAULT_NONCE);
} |
206414745_1714 | @Override
public long getNonce(final Address sender, final Bytes32 privacyGroupId) {
final BlockHeader chainHeadHeader = blockchain.getChainHeadHeader();
final Hash stateRoot =
privateStateRootResolver.resolveLastStateRoot(privacyGroupId, chainHeadHeader.getHash());
return privateWorldStateArchive
.get(stateRoot)
.map(
privateWorldState -> {
final Account account = privateWorldState.get(sender);
return account == null ? 0L : account.getNonce();
})
.orElse(Account.DEFAULT_NONCE);
} |
206414745_1715 | @Override
public Transaction create(
final String transactionEnclaveKey,
final PrivateTransaction privateTransaction,
final Address precompileAddress) {
final KeyPair signingKey = KeyPair.generate();
return create(transactionEnclaveKey, privateTransaction, 0, signingKey, precompileAddress);
} |
206414745_1716 | @Override
public Transaction create(
final String transactionEnclaveKey,
final PrivateTransaction privateTransaction,
final Address precompileAddress) {
return create(
transactionEnclaveKey,
privateTransaction,
nonceProvider.getNonce(sender),
signingKey,
precompileAddress);
} |
206414745_1717 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1718 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1719 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1720 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1721 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1722 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1723 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1724 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1725 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1726 | public ValidationResult<TransactionValidator.TransactionInvalidReason> validate(
final PrivateTransaction transaction,
final Long accountNonce,
final boolean allowFutureNonces) {
LOG.debug("Validating private transaction {}", transaction);
final ValidationResult<TransactionInvalidReason> privateFieldsValidationResult =
validatePrivateTransactionFields(transaction);
if (!privateFieldsValidationResult.isValid()) {
LOG.debug(
"Private Transaction fields are invalid {}",
privateFieldsValidationResult.getErrorMessage());
return privateFieldsValidationResult;
}
final ValidationResult<TransactionValidator.TransactionInvalidReason>
signatureValidationResult = validateTransactionSignature(transaction);
if (!signatureValidationResult.isValid()) {
LOG.debug(
"Private Transaction failed signature validation {}, {}",
signatureValidationResult.getInvalidReason(),
signatureValidationResult.getErrorMessage());
return signatureValidationResult;
}
final long transactionNonce = transaction.getNonce();
LOG.debug("Validating actual nonce {}, with expected nonce {}", transactionNonce, accountNonce);
if (accountNonce > transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, is lower than sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.PRIVATE_NONCE_TOO_LOW, errorMessage);
}
if (!allowFutureNonces && accountNonce != transactionNonce) {
final String errorMessage =
String.format(
"Private Transaction nonce %s, does not match sender account nonce %s.",
transactionNonce, accountNonce);
LOG.debug(errorMessage);
return ValidationResult.invalid(
TransactionValidator.TransactionInvalidReason.INCORRECT_PRIVATE_NONCE, errorMessage);
}
return ValidationResult.valid();
} |
206414745_1727 | public void writeTo(final RLPOutput out) {
out.startList();
out.writeLongScalar(getNonce());
out.writeUInt256Scalar(getGasPrice());
out.writeLongScalar(getGasLimit());
out.writeBytes(getTo().isPresent() ? getTo().get() : Bytes.EMPTY);
out.writeUInt256Scalar(getValue());
out.writeBytes(getPayload());
writeSignature(out);
out.writeBytes(getPrivateFrom());
getPrivateFor()
.ifPresent(privateFor -> out.writeList(privateFor, (bv, rlpO) -> rlpO.writeBytes(bv)));
getPrivacyGroupId().ifPresent(out::writeBytes);
out.writeBytes(getRestriction().getBytes());
out.endList();
} |
206414745_1728 | @SuppressWarnings({"unchecked"})
public static PrivateTransaction readFrom(final RLPInput input) throws RLPException {
input.enterList();
final Builder builder =
builder()
.nonce(input.readLongScalar())
.gasPrice(Wei.of(input.readUInt256Scalar()))
.gasLimit(input.readLongScalar())
.to(input.readBytes(v -> v.size() == 0 ? null : Address.wrap(v)))
.value(Wei.of(input.readUInt256Scalar()))
.payload(input.readBytes());
final BigInteger v = input.readBigIntegerScalar();
final byte recId;
Optional<BigInteger> chainId = Optional.empty();
if (v.equals(REPLAY_UNPROTECTED_V_BASE) || v.equals(REPLAY_UNPROTECTED_V_BASE_PLUS_1)) {
recId = v.subtract(REPLAY_UNPROTECTED_V_BASE).byteValueExact();
} else if (v.compareTo(REPLAY_PROTECTED_V_MIN) > 0) {
chainId = Optional.of(v.subtract(REPLAY_PROTECTED_V_BASE).divide(TWO));
recId = v.subtract(TWO.multiply(chainId.get()).add(REPLAY_PROTECTED_V_BASE)).byteValueExact();
} else {
throw new RuntimeException(
String.format("An unsupported encoded `v` value of %s was found", v));
}
final BigInteger r = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final BigInteger s = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final SECP256K1.Signature signature = SECP256K1.Signature.create(r, s, recId);
final Bytes privateFrom = input.readBytes();
final Object privateForOrPrivacyGroupId = resolvePrivateForOrPrivacyGroupId(input.readAsRlp());
final Restriction restriction = convertToEnum(input.readBytes());
input.leaveList();
chainId.ifPresent(builder::chainId);
if (privateForOrPrivacyGroupId instanceof List) {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privateFor((List<Bytes>) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
} else {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privacyGroupId((Bytes) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
}
} |
206414745_1729 | @SuppressWarnings({"unchecked"})
public static PrivateTransaction readFrom(final RLPInput input) throws RLPException {
input.enterList();
final Builder builder =
builder()
.nonce(input.readLongScalar())
.gasPrice(Wei.of(input.readUInt256Scalar()))
.gasLimit(input.readLongScalar())
.to(input.readBytes(v -> v.size() == 0 ? null : Address.wrap(v)))
.value(Wei.of(input.readUInt256Scalar()))
.payload(input.readBytes());
final BigInteger v = input.readBigIntegerScalar();
final byte recId;
Optional<BigInteger> chainId = Optional.empty();
if (v.equals(REPLAY_UNPROTECTED_V_BASE) || v.equals(REPLAY_UNPROTECTED_V_BASE_PLUS_1)) {
recId = v.subtract(REPLAY_UNPROTECTED_V_BASE).byteValueExact();
} else if (v.compareTo(REPLAY_PROTECTED_V_MIN) > 0) {
chainId = Optional.of(v.subtract(REPLAY_PROTECTED_V_BASE).divide(TWO));
recId = v.subtract(TWO.multiply(chainId.get()).add(REPLAY_PROTECTED_V_BASE)).byteValueExact();
} else {
throw new RuntimeException(
String.format("An unsupported encoded `v` value of %s was found", v));
}
final BigInteger r = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final BigInteger s = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final SECP256K1.Signature signature = SECP256K1.Signature.create(r, s, recId);
final Bytes privateFrom = input.readBytes();
final Object privateForOrPrivacyGroupId = resolvePrivateForOrPrivacyGroupId(input.readAsRlp());
final Restriction restriction = convertToEnum(input.readBytes());
input.leaveList();
chainId.ifPresent(builder::chainId);
if (privateForOrPrivacyGroupId instanceof List) {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privateFor((List<Bytes>) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
} else {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privacyGroupId((Bytes) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
}
} |
206414745_1730 | @SuppressWarnings({"unchecked"})
public static PrivateTransaction readFrom(final RLPInput input) throws RLPException {
input.enterList();
final Builder builder =
builder()
.nonce(input.readLongScalar())
.gasPrice(Wei.of(input.readUInt256Scalar()))
.gasLimit(input.readLongScalar())
.to(input.readBytes(v -> v.size() == 0 ? null : Address.wrap(v)))
.value(Wei.of(input.readUInt256Scalar()))
.payload(input.readBytes());
final BigInteger v = input.readBigIntegerScalar();
final byte recId;
Optional<BigInteger> chainId = Optional.empty();
if (v.equals(REPLAY_UNPROTECTED_V_BASE) || v.equals(REPLAY_UNPROTECTED_V_BASE_PLUS_1)) {
recId = v.subtract(REPLAY_UNPROTECTED_V_BASE).byteValueExact();
} else if (v.compareTo(REPLAY_PROTECTED_V_MIN) > 0) {
chainId = Optional.of(v.subtract(REPLAY_PROTECTED_V_BASE).divide(TWO));
recId = v.subtract(TWO.multiply(chainId.get()).add(REPLAY_PROTECTED_V_BASE)).byteValueExact();
} else {
throw new RuntimeException(
String.format("An unsupported encoded `v` value of %s was found", v));
}
final BigInteger r = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final BigInteger s = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final SECP256K1.Signature signature = SECP256K1.Signature.create(r, s, recId);
final Bytes privateFrom = input.readBytes();
final Object privateForOrPrivacyGroupId = resolvePrivateForOrPrivacyGroupId(input.readAsRlp());
final Restriction restriction = convertToEnum(input.readBytes());
input.leaveList();
chainId.ifPresent(builder::chainId);
if (privateForOrPrivacyGroupId instanceof List) {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privateFor((List<Bytes>) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
} else {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privacyGroupId((Bytes) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
}
} |
206414745_1731 | @SuppressWarnings({"unchecked"})
public static PrivateTransaction readFrom(final RLPInput input) throws RLPException {
input.enterList();
final Builder builder =
builder()
.nonce(input.readLongScalar())
.gasPrice(Wei.of(input.readUInt256Scalar()))
.gasLimit(input.readLongScalar())
.to(input.readBytes(v -> v.size() == 0 ? null : Address.wrap(v)))
.value(Wei.of(input.readUInt256Scalar()))
.payload(input.readBytes());
final BigInteger v = input.readBigIntegerScalar();
final byte recId;
Optional<BigInteger> chainId = Optional.empty();
if (v.equals(REPLAY_UNPROTECTED_V_BASE) || v.equals(REPLAY_UNPROTECTED_V_BASE_PLUS_1)) {
recId = v.subtract(REPLAY_UNPROTECTED_V_BASE).byteValueExact();
} else if (v.compareTo(REPLAY_PROTECTED_V_MIN) > 0) {
chainId = Optional.of(v.subtract(REPLAY_PROTECTED_V_BASE).divide(TWO));
recId = v.subtract(TWO.multiply(chainId.get()).add(REPLAY_PROTECTED_V_BASE)).byteValueExact();
} else {
throw new RuntimeException(
String.format("An unsupported encoded `v` value of %s was found", v));
}
final BigInteger r = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final BigInteger s = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final SECP256K1.Signature signature = SECP256K1.Signature.create(r, s, recId);
final Bytes privateFrom = input.readBytes();
final Object privateForOrPrivacyGroupId = resolvePrivateForOrPrivacyGroupId(input.readAsRlp());
final Restriction restriction = convertToEnum(input.readBytes());
input.leaveList();
chainId.ifPresent(builder::chainId);
if (privateForOrPrivacyGroupId instanceof List) {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privateFor((List<Bytes>) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
} else {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privacyGroupId((Bytes) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
}
} |
206414745_1732 | @SuppressWarnings({"unchecked"})
public static PrivateTransaction readFrom(final RLPInput input) throws RLPException {
input.enterList();
final Builder builder =
builder()
.nonce(input.readLongScalar())
.gasPrice(Wei.of(input.readUInt256Scalar()))
.gasLimit(input.readLongScalar())
.to(input.readBytes(v -> v.size() == 0 ? null : Address.wrap(v)))
.value(Wei.of(input.readUInt256Scalar()))
.payload(input.readBytes());
final BigInteger v = input.readBigIntegerScalar();
final byte recId;
Optional<BigInteger> chainId = Optional.empty();
if (v.equals(REPLAY_UNPROTECTED_V_BASE) || v.equals(REPLAY_UNPROTECTED_V_BASE_PLUS_1)) {
recId = v.subtract(REPLAY_UNPROTECTED_V_BASE).byteValueExact();
} else if (v.compareTo(REPLAY_PROTECTED_V_MIN) > 0) {
chainId = Optional.of(v.subtract(REPLAY_PROTECTED_V_BASE).divide(TWO));
recId = v.subtract(TWO.multiply(chainId.get()).add(REPLAY_PROTECTED_V_BASE)).byteValueExact();
} else {
throw new RuntimeException(
String.format("An unsupported encoded `v` value of %s was found", v));
}
final BigInteger r = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final BigInteger s = input.readUInt256Scalar().toBytes().toUnsignedBigInteger();
final SECP256K1.Signature signature = SECP256K1.Signature.create(r, s, recId);
final Bytes privateFrom = input.readBytes();
final Object privateForOrPrivacyGroupId = resolvePrivateForOrPrivacyGroupId(input.readAsRlp());
final Restriction restriction = convertToEnum(input.readBytes());
input.leaveList();
chainId.ifPresent(builder::chainId);
if (privateForOrPrivacyGroupId instanceof List) {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privateFor((List<Bytes>) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
} else {
return builder
.signature(signature)
.privateFrom(privateFrom)
.privacyGroupId((Bytes) privateForOrPrivacyGroupId)
.restriction(restriction)
.build();
}
} |
206414745_1733 | public static Builder builder() {
return new Builder();
} |
206414745_1734 | @Override
public List<PrivacyGroup> findOnChainPrivacyGroup(
final List<String> addresses, final String enclavePublicKey) {
final ArrayList<PrivacyGroup> privacyGroups = new ArrayList<>();
final PrivacyGroupHeadBlockMap privacyGroupHeadBlockMap =
privateStateStorage
.getPrivacyGroupHeadBlockMap(blockchain.getChainHeadHash())
.orElse(PrivacyGroupHeadBlockMap.empty());
privacyGroupHeadBlockMap
.keySet()
.forEach(
c -> {
final Optional<PrivacyGroup> maybePrivacyGroup = retrieveOnChainPrivacyGroup(c);
if (maybePrivacyGroup.isPresent()
&& maybePrivacyGroup.get().getMembers().containsAll(addresses)) {
privacyGroups.add(maybePrivacyGroup.get());
}
});
return privacyGroups;
} |
206414745_1735 | @Override
public String sendTransaction(
final PrivateTransaction privateTransaction,
final String enclavePublicKey,
final Optional<PrivacyGroup> maybePrivacyGroup) {
try {
LOG.trace("Storing private transaction in enclave");
final SendResponse sendResponse =
sendRequest(privateTransaction, enclavePublicKey, maybePrivacyGroup);
return sendResponse.getKey();
} catch (final Exception e) {
LOG.error("Failed to store private transaction in enclave", e);
throw e;
}
} |
206414745_1736 | @Override
public ValidationResult<TransactionValidator.TransactionInvalidReason> validatePrivateTransaction(
final PrivateTransaction privateTransaction, final String enclavePublicKey) {
final String privacyGroupId = privateTransaction.determinePrivacyGroupId().toBase64String();
return privateTransactionValidator.validate(
privateTransaction,
determineBesuNonce(privateTransaction.getSender(), privacyGroupId, enclavePublicKey),
true);
} |
206414745_1737 | @Override
public ValidationResult<TransactionValidator.TransactionInvalidReason> validatePrivateTransaction(
final PrivateTransaction privateTransaction, final String enclavePublicKey) {
final String privacyGroupId = privateTransaction.determinePrivacyGroupId().toBase64String();
return privateTransactionValidator.validate(
privateTransaction,
determineBesuNonce(privateTransaction.getSender(), privacyGroupId, enclavePublicKey),
true);
} |
206414745_1738 | @Override
public ReceiveResponse retrieveTransaction(
final String enclaveKey, final String enclavePublicKey) {
return enclave.receive(enclaveKey, enclavePublicKey);
} |
206414745_1739 | @Override
public PrivacyGroup createPrivacyGroup(
final List<String> addresses,
final String name,
final String description,
final String enclavePublicKey) {
return enclave.createPrivacyGroup(addresses, enclavePublicKey, name, description);
} |
206414745_1740 | @Override
public String deletePrivacyGroup(final String privacyGroupId, final String enclavePublicKey) {
return enclave.deletePrivacyGroup(privacyGroupId, enclavePublicKey);
} |
206414745_1741 | @Override
public PrivacyGroup[] findPrivacyGroup(
final List<String> addresses, final String enclavePublicKey) {
return enclave.findPrivacyGroup(addresses);
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.