public static async Task <TransactionResourceInfo> GetTransactionResourceInfoAsync(this IExecutive executive,
IChainContext chainContext, Transaction input)
{
var txId = input.GetHash();
var transactionContext = GetTransactionContext(chainContext, input.To, input.ToByteString(), out var trace);
await executive.ApplyAsync(transactionContext);
if (!trace.IsSuccessful())
{
return(NotParallelizable(txId, executive.ContractHash));
}
try
{
var resourceInfo = ResourceInfo.Parser.ParseFrom(trace.ReturnValue);
return(new TransactionResourceInfo
{
TransactionId = txId,
Paths =
{
resourceInfo.Paths
},
ParallelType = resourceInfo.NonParallelizable
? ParallelType.NonParallelizable
: ParallelType.Parallelizable,
ContractHash = executive.ContractHash
});
}
catch (Exception)
{
return(NotParallelizable(txId, executive.ContractHash));
}
}
private async Task <SmartContractRegistration> GetSmartContractRegistrationFromZeroAsync(
IExecutive executiveZero, IChainContext chainContext, Address address)
{
var transaction = new Transaction()
{
From = _defaultContractZeroCodeProvider.ContractZeroAddress,
To = _defaultContractZeroCodeProvider.ContractZeroAddress,
MethodName = "GetSmartContractRegistrationByAddress",
Params = address.ToByteString()
};
var txContext = _transactionContextFactory.Create(transaction, chainContext);
await executiveZero.ApplyAsync(txContext);
var returnBytes = txContext.Trace?.ReturnValue;
if (returnBytes != null && returnBytes != ByteString.Empty)
{
return(SmartContractRegistration.Parser.ParseFrom(returnBytes));
}
throw new SmartContractFindRegistrationException(
$"failed to find registration from zero contract {txContext.Trace.Error}");
}
public static async Task <TransactionResourceInfo> GetTransactionResourceInfoAsync(this IExecutive executive,
ITransactionContext transactionContext, Hash txId)
{
await executive.ApplyAsync(transactionContext);
if (!transactionContext.Trace.IsSuccessful())
{
return(NotParallelizable(txId, executive.ContractHash));
}
try
{
var resourceInfo = ResourceInfo.Parser.ParseFrom(transactionContext.Trace.ReturnValue);
return(new TransactionResourceInfo
{
TransactionId = txId,
WritePaths =
{
resourceInfo.WritePaths
},
ReadPaths = { resourceInfo.ReadPaths },
ParallelType = resourceInfo.NonParallelizable
? ParallelType.NonParallelizable
: ParallelType.Parallelizable,
ContractHash = executive.ContractHash
});
}
catch (Exception)
{
return(NotParallelizable(txId, executive.ContractHash));
}
}
public static async Task <TransactionResourceInfo> GetTransactionResourceInfoAsync(this IExecutive executive,
IChainContext chainContext, Transaction input)
{
var generatedTxn = new Transaction
{
From = FromAddress,
To = input.To,
MethodName = nameof(ACS2BaseContainer.ACS2BaseStub.GetResourceInfo),
Params = input.ToByteString(),
Signature = ByteString.CopyFromUtf8("SignaturePlaceholder")
};
var txId = input.GetHash();
var trace = new TransactionTrace
{
TransactionId = generatedTxn.GetHash()
};
var transactionContext = new TransactionContext
{
PreviousBlockHash = chainContext.BlockHash,
CurrentBlockTime = TimestampHelper.GetUtcNow(),
Transaction = generatedTxn,
BlockHeight = chainContext.BlockHeight + 1,
Trace = trace,
CallDepth = 0,
StateCache = chainContext.StateCache
};
await executive.ApplyAsync(transactionContext);
if (!trace.IsSuccessful())
{
return(NotParallelizable(txId, executive.ContractHash));
}
try
{
var resourceInfo = ResourceInfo.Parser.ParseFrom(trace.ReturnValue);
return(new TransactionResourceInfo
{
TransactionId = txId,
Paths =
{
resourceInfo.Paths
},
ParallelType = resourceInfo.NonParallelizable
? ParallelType.NonParallelizable
: ParallelType.Parallelizable,
ContractHash = executive.ContractHash
});
}
catch (Exception)
{
return(NotParallelizable(txId, executive.ContractHash));
}
}
private async Task <SmartContractRegistration> GetSmartContractRegistrationFromZeroAsync(
IExecutive executiveZero, IChainContext chainContext, Hash codeHash)
{
var transaction = new Transaction()
{
From = FromAddress,
To = _defaultContractZeroCodeProvider.ContractZeroAddress,
MethodName = "GetSmartContractRegistration",
Params = codeHash.ToByteString()
};
var trace = new TransactionTrace
{
TransactionId = transaction.GetHash()
};
var txCtxt = new TransactionContext
{
PreviousBlockHash = chainContext.BlockHash,
CurrentBlockTime = TimestampHelper.GetUtcNow(),
Transaction = transaction,
BlockHeight = chainContext.BlockHeight + 1,
Trace = trace,
CallDepth = 0,
StateCache = chainContext.StateCache
};
await executiveZero.ApplyAsync(txCtxt);
var returnBytes = txCtxt.Trace?.ReturnValue;
if (returnBytes != null && returnBytes != ByteString.Empty)
{
return(SmartContractRegistration.Parser.ParseFrom(returnBytes));
}
if (!txCtxt.Trace.IsSuccessful())
{
throw new SmartContractFindRegistrationException(
$"failed to find registration from zero contract {txCtxt.Trace.Error}");
}
return(null);
}
private async Task <SmartContractRegistration> GetSmartContractRegistrationFromZeroAsync(
IExecutive executiveZero, IChainContext chainContext, Address address)
{
var transaction = new Transaction()
{
From = Address.Zero,
To = _defaultContractZeroCodeProvider.ContractZeroAddress,
MethodName = "GetSmartContractRegistrationByAddress",
Params = address.ToByteString()
};
var trace = new TransactionTrace
{
TransactionId = transaction.GetHash()
};
var txCtxt = new TransactionContext
{
PreviousBlockHash = chainContext.BlockHash,
CurrentBlockTime = DateTime.UtcNow,
Transaction = transaction,
BlockHeight = chainContext.BlockHeight + 1,
Trace = trace,
CallDepth = 0,
StateCache = chainContext.StateCache
};
await executiveZero.ApplyAsync(txCtxt);
var returnBytes = txCtxt.Trace?.ReturnValue;
if (returnBytes != null && returnBytes != ByteString.Empty)
{
return(SmartContractRegistration.Parser.ParseFrom(returnBytes));
}
throw new InvalidOperationException(
$"failed to find registration from zero contract {txCtxt.Trace.StdErr}");
}
