一、啰嗦两句
昨天讲了智能合约的一生，那丫长啥样啊？今儿我就跟各位唠叨唠叨。
二、一个简单的智能合约
下面这段就是NEO实例源码里的一个，干撒用的？聪明的你一眼儿就看出来了吧，就是一个所谓域名合约的增删改查。有几点我唠叨两句
using Neo.SmartContract.Framework.Services.Neo; namespace Neo.SmartContract
{
public class Domain : Framework.SmartContract
{
public static object Main(string operation, params object[] args)
{
switch (operation)
{
case "query":
return Query((string)args[]);
case "register":
return Register((string)args[], (byte[])args[]);
case "transfer":
return Transfer((string)args[], (byte[])args[]);
case "delete":
return Delete((string)args[]);
default:
return false;
}
} private static byte[] Query(string domain)
{
return Storage.Get(Storage.CurrentContext, domain);
} private static bool Register(string domain, byte[] owner)
{
if (!Runtime.CheckWitness(owner)) return false;
byte[] value = Storage.Get(Storage.CurrentContext, domain);
if (value != null) return false;
Storage.Put(Storage.CurrentContext, domain, owner);
return true;
} private static bool Transfer(string domain, byte[] to)
{
if (!Runtime.CheckWitness(to)) return false;
byte[] from = Storage.Get(Storage.CurrentContext, domain);
if (from == null) return false;
if (!Runtime.CheckWitness(from)) return false;
Storage.Put(Storage.CurrentContext, domain, to);
return true;
} private static bool Delete(string domain)
{
byte[] owner = Storage.Get(Storage.CurrentContext, domain);
if (owner == null) return false;
if (!Runtime.CheckWitness(owner)) return false;
Storage.Delete(Storage.CurrentContext, domain);
return true;
}
}
}
1. 上一节讲了，一个智能合约就是继承自SmartContract的类，Main函数啊，方法啊，全得是静态的，因为NEO的编译器就认静态的。
2. Main就是智能合约的入口，调用的时候会穿些参数，第一个就是opeartion，根据这个来判断是啥操作，这点和Fabric很像，就一个init一个invoke，Etherenum不是这样的。
3. 逻辑都能看明白，这个Storage是个啥玩意，看上去像个存储，在哪存储？这不就是serverless吗？ok，咱就以此为突破，重点关注一下这个Storage。
源码说话。这个Storage是NEO工具包（SmartContract那个类一个项目下的）里的一个类，我们看下源码。
using System.Numerics; namespace Neo.SmartContract.Framework.Services.Neo
{
public static class Storage
{
public static extern StorageContext CurrentContext
{
[Syscall("Neo.Storage.GetContext")]
get;
} [Syscall("Neo.Storage.Get")]
public static extern byte[] Get(StorageContext context, byte[] key);
}
}
我把其他方法都删了，留一个Get方法，示意一下。看到这，是不是有点懵逼，SysCall什么鬼，这种写法是不是似曾相识？是不是和dllimport差不多？其实我琢磨着作者写的时候也有这么个意图，就说啊，这是一系统调用啊，调用咱系统的东西。那到底这玩意儿咋个原理，咱们就得看NEO的编译器源码了。上一节咱提了，NEO的编译器就是根据规则把对应的代码翻译成指令码，编译器这部分咱后面也要说，找源码的过程比较琐碎，不贴代码了，这里先理解成编译器把他编译成OpCode.SYSCALL Neo.Storage.Get，就是系统调用Neo.Storage.Get。下面的问题就是NEO的虚拟机该怎么解释这个指令了，我们再去NEO.VM项目里找结果。
private readonly InteropService service; case OpCode.SYSCALL:
if (!service.Invoke(Encoding.ASCII.GetString(context.OpReader.ReadVarBytes()), this))
State |= VMState.FAULT;
break;
再来看看Interopservice里Invoke都干了些啥，也是删除了部分代码。
using System;
using System.Collections.Generic; namespace Neo.VM
{
public class InteropService
{
private Dictionary<string, Func<ExecutionEngine, bool>> dictionary = new Dictionary<string, Func<ExecutionEngine, bool>>(); public InteropService()
{
Register("System.ExecutionEngine.GetScriptContainer", GetScriptContainer);
Register("System.ExecutionEngine.GetExecutingScriptHash", GetExecutingScriptHash);
Register("System.ExecutionEngine.GetCallingScriptHash", GetCallingScriptHash);
Register("System.ExecutionEngine.GetEntryScriptHash", GetEntryScriptHash);
} protected void Register(string method, Func<ExecutionEngine, bool> handler)
{
dictionary[method] = handler;
} internal bool Invoke(string method, ExecutionEngine engine)
{
if (!dictionary.ContainsKey(method)) return false;
return dictionary[method](engine);
}
}
}
看起来InteropService里保留了一个字段，根据不同的方法名，注册不同的执行方法，我们要找的Neo.Storage.Get这个方法key是在那里注册的呢？搜。
namespace Neo.SmartContract
{
public class StateReader : InteropService
{
public event EventHandler<NotifyEventArgs> Notify;
public event EventHandler<LogEventArgs> Log; public static readonly StateReader Default = new StateReader(); public StateReader()
{
Register("Neo.Storage.Get", Storage_Get);
} protected virtual bool Storage_Get(ExecutionEngine engine)
{
StorageContext context = engine.EvaluationStack.Pop().GetInterface<StorageContext>();
ContractState contract = Blockchain.Default.GetContract(context.ScriptHash);
if (contract == null) return false;
if (!contract.HasStorage) return false;
byte[] key = engine.EvaluationStack.Pop().GetByteArray();
StorageItem item = Blockchain.Default.GetStorageItem(new StorageKey
{
ScriptHash = context.ScriptHash,
Key = key
});
engine.EvaluationStack.Push(item?.Value ?? new byte[]);
return true;
}
}
}
注意到Blockchain.Default.GetstorageItem()这个方法了吧，虚拟机执行器把链上的数据取出来了，这个Blockchain的实现是leveldb这个咱也后面再讲。
好啦，到现在这一圈可以理解智能合约的执行过程了吧。聪明的你也一定发现了，你看的懂的那些逻辑，也会被NEO的编译器编译成指令码，这部分就复杂咯，后面咱们讲编译器的时候详细的说，编译器这块还是挺复杂的，面向代码作者拜一拜。。。
三、小结
智能合约好写，很容易理解，但是从头撸到底才能透彻的知道了解它的运行原理，撸的过程略过了很多东西，聪明的你一定很好奇吧，别着急，咱们下回书，再说。