/// <summary>
/// Constructor initializing a mining pool contract.
/// </summary>
/// <param name="state">Smart contract state.</param>
/// <param name="minedToken">The address of the token being mined.</param>
/// <param name="stakingToken">The address of the liquidity pool token used for mining.</param>
public OpdexMiningPool(ISmartContractState state, Address minedToken, Address stakingToken) : base(state)
{
MinedToken = minedToken;
StakingToken = stakingToken;
MiningGovernance = GetMiningGovernance();
MiningDuration = GetMiningDuration();
}
public Token(ISmartContractState state)
: base(state)
{
this.Owner = this.Message.Sender;
this.Balances = this.PersistentState.GetUInt64Mapping("Balances");
}
public ThermostatContract(ISmartContractState smartContractState, Address user, int targetTemperature)
: base(smartContractState)
{
this.Installer = Message.Sender;
this.User = user;
this.TargetTemperature = targetTemperature;
}
///<inheritdoc />
public ITransferResult Transfer(ISmartContractState smartContractState, Address addressTo, ulong amountToTransfer)
{
this.logger.LogTrace("({0}:{1},{2}:{3})", nameof(addressTo), addressTo, nameof(amountToTransfer), amountToTransfer);
// TODO: Spend BaseFee here
EnsureContractHasEnoughBalance(smartContractState, amountToTransfer);
// Discern whether this is a contract or an ordinary address.
byte[] contractCode = this.contractStateRepository.GetCode(addressTo.ToUint160(this.network));
if (contractCode == null || contractCode.Length == 0)
{
this.internalTransferList.Add(new TransferInfo
{
From = smartContractState.Message.ContractAddress.ToUint160(this.network),
To = addressTo.ToUint160(this.network),
Value = amountToTransfer
});
this.logger.LogTrace("(-)[TRANSFER_TO_SENDER]:Transfer {0} from {1} to {2}.", smartContractState.Message.ContractAddress, addressTo, amountToTransfer);
return(TransferResult.Empty());
}
this.logger.LogTrace("(-)[TRANSFER_TO_CONTRACT]");
// Calling a receive handler:
string methodName = MethodCall.ExternalReceiveHandlerName;
object[] parameters = new object[] { };
ulong gasBudget = DefaultGasLimit; // for Transfer always send limited gas to prevent re-entrance.
return(ExecuteTransferFundsToContract(contractCode, smartContractState, addressTo, amountToTransfer, methodName, parameters, gasBudget));
}
/// <summary>
/// Loads the contract bytecode and returns an <see cref="IContract"/> representing an uninitialized contract instance.
/// </summary>
private Result <IContract> Load(
ContractByteCode byteCode,
string typeName,
uint160 address,
ISmartContractState contractState)
{
Result <IContractAssembly> assemblyLoadResult = this.assemblyLoader.Load(byteCode);
if (!assemblyLoadResult.IsSuccess)
{
return(Result.Fail <IContract>(assemblyLoadResult.Error));
}
IContractAssembly contractAssembly = assemblyLoadResult.Value;
Type type = contractAssembly.GetType(typeName);
if (type == null)
{
return(Result.Fail <IContract>("Type not found!"));
}
IContract contract = Contract.CreateUninitialized(type, contractState, address);
return(Result.Ok(contract));
}
private StateTransitionResult ApplyCall(IState state, CallMessage message, byte[] contractCode)
{
var gasMeter = new GasMeter(message.GasLimit);
gasMeter.Spend((Gas)GasPriceList.BaseCost);
// This needs to happen after the base fee is charged, which is why it's in here.
// TODO - Remove this check. It isn't possible for the method name to be null.
if (message.Method.Name == null)
{
return(StateTransitionResult.Fail(gasMeter.GasConsumed, StateTransitionErrorKind.NoMethodName));
}
string type = state.ContractState.GetContractType(message.To);
ISmartContractState smartContractState = state.CreateSmartContractState(state, gasMeter, message.To, message, state.ContractState);
VmExecutionResult result = this.Vm.ExecuteMethod(smartContractState, message.Method, contractCode, type);
bool revert = !result.IsSuccess;
if (revert)
{
return(StateTransitionResult.Fail(
gasMeter.GasConsumed,
result.Error));
}
return(StateTransitionResult.Ok(
gasMeter.GasConsumed,
message.To,
result.Success.Result
));
}
private Contract(SmartContract instance, Type type, ISmartContractState state, uint160 address)
{
this.instance = instance;
this.State = state;
this.Type = type;
this.Address = address;
}
public PrivateYesNoVote(ISmartContractState smartContractState, ulong duration, byte[] addresses)
: base(smartContractState)
{
VotePeriodEndBlock = checked (Block.Number + duration);
Owner = Message.Sender;
SetVotersExecute(addresses);
}
/// <summary>
/// Invokes a smart contract's constructor with the provided parameters
/// </summary>
public static LifecycleResult Construct(Type type, ISmartContractState state, params object[] parameters)
{
object[] newParams;
if (parameters != null && parameters.Length > 0)
{
newParams = new object[parameters.Length + 1];
newParams[0] = state;
Array.Copy(parameters, 0, newParams, 1, parameters.Length);
}
else
{
newParams = new object[] { state };
}
try
{
var smartContract = (SmartContract)Activator.CreateInstance(type, newParams);
return(new LifecycleResult(smartContract));
}
catch (Exception e)
{
return(new LifecycleResult(e));
}
}
public Auction(ISmartContractState smartContractState, ulong durationBlocks)
: base(smartContractState)
{
this.Owner = this.Message.Sender;
this.EndBlock = this.Block.Number + durationBlocks;
this.HasEnded = false;
}
public DirectAid(ISmartContractState smartContractState, ulong startTime, ulong endTime)
: base(smartContractState)
{
Owner = Message.Sender;
StartTime = startTime;
EndTime = endTime;
}
public Cat(ISmartContractState smartContractState, int catNumber) : base(smartContractState)
{
CatNumber = catNumber;
Log(new CatCreated {
CatNumber = catNumber
});
}
public BasicParameters(ISmartContractState smartContractState, ulong number1, ulong number2) : base(smartContractState)
{
this.PersistentState.SetBool("Created", true);
this.Log(new Created {
From = this.Message.Sender
});
}
private StateTransitionResult ApplyCreate(IState state,
object[] parameters,
byte[] code,
BaseMessage message,
uint160 address,
RuntimeObserver.IGasMeter gasMeter,
string type = null)
{
state.ContractState.CreateAccount(address);
ISmartContractState smartContractState = state.CreateSmartContractState(state, gasMeter, address, message, state.ContractState);
VmExecutionResult result = this.Vm.Create(state.ContractState, smartContractState, gasMeter, code, parameters, type);
bool revert = !result.IsSuccess;
if (revert)
{
return(StateTransitionResult.Fail(
gasMeter.GasConsumed,
result.Error));
}
return(StateTransitionResult.Ok(
gasMeter.GasConsumed,
address,
result.Success.Result
));
}
private StateTransitionResult ApplyCall(IState state, CallMessage message, byte[] contractCode, ExecutionContext executionContext)
{
// This needs to happen after the base fee is charged, which is why it's in here.
if (message.Method.Name == null)
{
return(StateTransitionResult.Fail(executionContext.GasMeter.GasConsumed, StateTransitionErrorKind.NoMethodName));
}
string type = state.ContractState.GetContractType(message.To);
ISmartContractState smartContractState = state.CreateSmartContractState(state, executionContext.GasMeter, message.To, message, state.ContractState);
VmExecutionResult result = this.Vm.ExecuteMethod(smartContractState, executionContext, message.Method, contractCode, type);
bool revert = !result.IsSuccess;
if (revert)
{
return(StateTransitionResult.Fail(
executionContext.GasMeter.GasConsumed,
result.Error));
}
return(StateTransitionResult.Ok(
executionContext.GasMeter.GasConsumed,
message.To,
result.Success.Result
));
}
///<inheritdoc />
public ITransferResult TransferFunds(ISmartContractState smartContractState, Address addressTo, ulong amountToTransfer, TransferFundsToContract contractDetails)
{
this.logger.LogTrace("({0}:{1},{2}:{3})", nameof(addressTo), addressTo, nameof(amountToTransfer), amountToTransfer);
// TODO: Spend BaseFee here
var balance = smartContractState.GetBalance();
if (balance < amountToTransfer)
{
this.logger.LogTrace("(-)[INSUFFICIENT_BALANCE]:{0}={1}", nameof(balance), balance);
throw new InsufficientBalanceException();
}
// Discern whether this is a contract or an ordinary address.
byte[] contractCode = this.contractStateRepository.GetCode(addressTo.ToUint160(this.network));
if (contractCode == null || contractCode.Length == 0)
{
this.internalTransferList.Add(new TransferInfo
{
From = smartContractState.Message.ContractAddress.ToUint160(this.network),
To = addressTo.ToUint160(this.network),
Value = amountToTransfer
});
this.logger.LogTrace("(-)[TRANSFER_TO_SENDER]:Transfer {0} from {1} to {2}.", smartContractState.Message.ContractAddress, addressTo, amountToTransfer);
return(TransferResult.Empty());
}
this.logger.LogTrace("(-)[TRANSFER_TO_CONTRACT]");
return(ExecuteTransferFundsToContract(contractCode, smartContractState, addressTo, amountToTransfer, contractDetails));
}
public Moloch(
ISmartContractState state,
Address summoner,
Address _approvedToken,
ulong _periodDuration,
ulong _votingPeriodLength,
ulong _gracePeriodLength,
ulong _abortWindow,
ulong _proposalDeposit,
ulong _dilutionBound,
ulong _processingReward,
Address approvedTokenAddress,
IStandardToken approvedStandardToken
) : base(state)
{
Assert(summoner != Address.Zero, "Moloch::constructor - summoner cannot be 0");
Assert(_approvedToken != Address.Zero, "Moloch::constructor - _approvedToken cannot be 0");
Assert(_periodDuration > 0, "Moloch::constructor - _periodDuration cannot be 0");
Assert(_votingPeriodLength > 0, "Moloch::constructor - _votingPeriodLength cannot be 0");
Assert(_votingPeriodLength <= MAX_VOTING_PERIOD_LENGTH, "Moloch::constructor - _votingPeriodLength exceeds limit");
Assert(_gracePeriodLength <= MAX_GRACE_PERIOD_LENGTH, "Moloch::constructor - _gracePeriodLength exceeds limit");
Assert(_abortWindow > 0, "Moloch::constructor - _abortWindow cannot be 0");
Assert(_abortWindow <= _votingPeriodLength, "Moloch::constructor - _abortWindow must be smaller than or equal to _votingPeriodLength");
Assert(_dilutionBound > 0, "Moloch::constructor - _dilutionBound cannot be 0");
Assert(_dilutionBound <= MAX_DILUTION_BOUND, "Moloch::constructor - _dilutionBound exceeds limit");
Assert(_proposalDeposit >= _processingReward, "Moloch::constructor - _proposalDeposit cannot be smaller than _processingReward");
// todo: how to wrap calls from/to?
ApprovedTokenAddress = approvedTokenAddress;
ApprovedStandardToken = approvedStandardToken;
// todo: how to start a new guildbank contract as well?
GuildBank = new GuildBank(state, approvedTokenAddress, approvedStandardToken);
PeriodDuration = _periodDuration;
VotingPeriodLength = _votingPeriodLength;
GracePeriodLength = _gracePeriodLength;
AbortWindow = _abortWindow;
ProposalDeposit = _proposalDeposit;
DilutionBound = _dilutionBound;
ProcessingReward = _processingReward;
// todo: summoningTime = now; // now operator/call missing in stratis?
SummoningTime = DateTime.UtcNow.Ticks;
SetMember(summoner, new Member()
{
DelegateKey = summoner,
Shares = 1,
Exists = true,
HighestIndexYesVote = 0
});
SetMemberAddressByDelegateKey(summoner, summoner);
TotalShares = 1;
SetProposalQueue(new Proposal[0]);
LogSummonComplete(summoner, 1);
}
public HelloBlockchain(ISmartContractState state, string message)
: base(state)
{
Requestor = Message.Sender;
RequestMessage = message;
State = (uint)StateType.Request;
}
/// <summary>
/// Constructor initializing a standard pool contract.
/// </summary>
/// <param name="state">Smart contract state.</param>
/// <param name="token">The address of the SRC token in the pool.</param>
/// <param name="authProviders">Flag to authorize liquidity providers or not.</param>
/// <param name="authTraders">Flag to authorize traders or not.</param>
/// <param name="fee">The market transaction fee, 0-10 equal to 0-1%.</param>
public OpdexStandardPool(ISmartContractState state, Address token, bool authProviders, bool authTraders, uint fee)
: base(state, token, fee)
{
Market = Message.Sender;
AuthProviders = authProviders;
AuthTraders = authTraders;
}
private StateTransitionResult ApplyCreate(IState state, object[] parameters, byte[] code, BaseMessage message,
uint160 address,
string type = null)
{
var gasMeter = new GasMeter(message.GasLimit);
gasMeter.Spend((Gas)GasPriceList.BaseCost);
state.ContractState.CreateAccount(address);
ISmartContractState smartContractState = state.CreateSmartContractState(state, gasMeter, address, message, state.ContractState);
VmExecutionResult result = this.Vm.Create(state.ContractState, smartContractState, code, parameters, type);
bool revert = !result.IsSuccess;
if (revert)
{
return(StateTransitionResult.Fail(
gasMeter.GasConsumed,
result.Error));
}
return(StateTransitionResult.Ok(
gasMeter.GasConsumed,
address,
result.Success.Result
));
}
public TestContract(ISmartContractState smartContractState, int param)
: base(smartContractState)
{
this.ConstructorCalledCount++;
this.State = smartContractState;
this.Param = param;
}
public ForwardParameters(ISmartContractState state,
char aChar,
Address anAddress,
bool aBool,
int anInt,
long aLong,
uint aUint,
ulong aUlong,
string aString,
Address sendTo) : base(state)
{
ITransferResult result = this.Call(sendTo, this.Balance, "Call", new object[]
{
aChar,
anAddress,
aBool,
anInt,
aLong,
aUint,
aUlong,
aString
});
Assert(result.Success);
}
///<inheritdoc />
public ITransferResult Call(
ISmartContractState smartContractState,
Address addressTo,
ulong amountToTransfer,
string methodName,
object[] parameters,
ulong gasLimit = 0)
{
// For a method call, send all the gas unless an amount was selected.Should only call trusted methods so re - entrance is less problematic.
ulong gasBudget = (gasLimit != 0) ? gasLimit : smartContractState.GasMeter.GasAvailable;
var message = new InternalCallMessage(
addressTo.ToUint160(this.network),
smartContractState.Message.ContractAddress.ToUint160(this.network),
amountToTransfer,
(Gas)gasBudget,
new MethodCall(methodName, parameters)
);
var result = this.state.Apply(message);
return(result.IsSuccess
? TransferResult.Transferred(result.Success.ExecutionResult)
: TransferResult.Failed());
}
public Auction(ISmartContractState smartContractState, ulong durationBlocks)
: base(smartContractState)
{
Owner = Message.Sender;
EndBlock = Block.Number + durationBlocks;
HasEnded = false;
}
// Constructor takes two parameters - the 2 owners of the multisig. They must agree to make any outgoing transactions.
public MultiSig2of2(ISmartContractState smartContractState, Address owner1, Address owner2)
: base(smartContractState)
{
Owner1 = owner1;
Owner2 = owner2;
LogMessage("Constructor called. Owners: " + owner1 + ", " + owner2);
}
///<inheritdoc />
public ICreateResult Create <T>(ISmartContractState smartContractState,
ulong amountToTransfer,
object[] parameters,
ulong gasLimit = 0)
{
// TODO: Expend any neccessary costs.
ulong gasBudget = (gasLimit != 0) ? gasLimit : DefaultGasLimit;
// Ensure we have enough gas left to be able to fund the new GasMeter.
if (smartContractState.GasMeter.GasAvailable < gasBudget)
{
throw new InsufficientGasException();
}
var nestedGasMeter = new GasMeter((Gas)gasBudget);
// Check balance.
EnsureContractHasEnoughBalance(smartContractState, amountToTransfer);
// Build objects for VM
byte[] contractCode = this.contractStateRepository.GetCode(smartContractState.Message.ContractAddress.ToUint160(this.network)); // TODO: Fix this when calling from constructor.
var context = new TransactionContext(
this.transactionContext.TransactionHash,
this.transactionContext.BlockHeight,
this.transactionContext.Coinbase,
smartContractState.Message.ContractAddress.ToUint160(this.network),
amountToTransfer,
this.transactionContext.GetNonceAndIncrement());
IContractStateRepository track = this.contractStateRepository.StartTracking();
var createData = new CreateData(nestedGasMeter.GasLimit, contractCode, parameters);
// Do create in vm
VmExecutionResult result = this.vm.Create(nestedGasMeter, track, createData, context, typeof(T).Name);
// Update parent gas meter.
smartContractState.GasMeter.Spend(nestedGasMeter.GasConsumed);
var revert = result.ExecutionException != null;
if (revert)
{
this.logger.LogTrace("(-)[CONTRACT_EXECUTION_FAILED]");
track.Rollback();
return(CreateResult.Failed());
}
this.logger.LogTrace("(-)[CONTRACT_EXECUTION_SUCCEEDED]");
track.Commit();
// TODO: Add internaltransfer update here
this.contractLogHolder.AddRawLogs(result.RawLogs);
return(CreateResult.Succeeded(result.NewContractAddress.ToAddress(this.network)));
}
/// <summary>
/// Constructor initializing the router contract.
/// </summary>
/// <param name="state">Smart contract state.</param>
/// <param name="market">The address of the market associated.</param>
/// <param name="transactionFee">0-10 transaction fee equal to 0-1%.</param>
/// <param name="authProviders">Flag indicating if liquidity providers should be authorized.</param>
/// <param name="authTraders">Flag indicating if traders should be authorized.</param>
public OpdexRouter(ISmartContractState state, Address market, uint transactionFee, bool authProviders, bool authTraders) : base(state)
{
Assert(transactionFee <= 10, "OPDEX: INVALID_TRANSACTION_FEE");
Market = market;
TransactionFee = transactionFee;
AuthProviders = authProviders;
AuthTraders = authTraders;
}
/// <summary>
/// Constructor used to create a new instance of the token. Assigns the total token supply to the creator of the contract.
/// </summary>
/// <param name="smartContractState">The execution state for the contract.</param>
/// <param name="totalSupply">The total token supply.</param>
/// <param name="name">The name of the token.</param>
/// <param name="symbol">The symbol used to identify the token.</param>
public StandardToken(ISmartContractState smartContractState, ulong totalSupply, string name, string symbol)
: base(smartContractState)
{
this.TotalSupply = totalSupply;
this.Name = name;
this.Symbol = symbol;
this.SetBalance(Message.Sender, totalSupply);
}
private const ulong ProposalDeposit = 50000000000ul; // 500 CRS
/// <summary>
/// Constructor initializing an empty vault smart contract.
/// </summary>
/// <param name="state">Smart contract state.</param>
/// <param name="token">The locked SRC token.</param>
/// <param name="vestingDuration">The length in blocks of the vesting period.</param>
/// <param name="totalPledgeMinimum">The minimum total number of tokens pledged to a proposal to move to a vote.</param>
/// <param name="totalVoteMinimum">The minimum total number of tokens voted on a proposal to have a chance to be approved.</param>
public OpdexVault(ISmartContractState state, Address token, ulong vestingDuration, ulong totalPledgeMinimum, ulong totalVoteMinimum) : base(state)
{
Token = token;
VestingDuration = vestingDuration;
TotalPledgeMinimum = totalPledgeMinimum;
TotalVoteMinimum = totalVoteMinimum;
NextProposalId = 1;
}
public TimeLock(ISmartContractState smartContractState, ulong duration, Address owner)
: base(smartContractState)
{
EndBlock = Block.Number + duration;
LogMessage("End Block: " + EndBlock);
Owner = owner;
LogMessage("Owner: " + Owner);
}
