Example #1
0
func testInit(t *testing.T) (self *testFrontend) {
	// initialise and start minimal expanse stack
	expanse, err := testEth(t)
	if err != nil {
		t.Errorf("error creating expanse: %v", err)
		return
	}
	err = expanse.Start()
	if err != nil {
		t.Errorf("error starting expanse: %v", err)
		return
	}

	// mock frontend
	self = &testFrontend{t: t, expanse: expanse}
	self.xeth = xe.New(expanse, self)
	self.wait = self.xeth.UpdateState()
	addr, _ := self.expanse.Etherbase()

	// initialise the registry contracts
	reg := registrar.New(self.xeth)
	var registrarTxhash, hashRegTxhash, urlHintTxhash string
	registrarTxhash, err = reg.SetGlobalRegistrar("", addr)
	if err != nil {
		t.Errorf("error creating GlobalRegistrar: %v", err)
	}

	hashRegTxhash, err = reg.SetHashReg("", addr)
	if err != nil {
		t.Errorf("error creating HashReg: %v", err)
	}
	urlHintTxhash, err = reg.SetUrlHint("", addr)
	if err != nil {
		t.Errorf("error creating UrlHint: %v", err)
	}
	if !processTxs(self, t, 3) {
		t.Errorf("error mining txs")
	}
	_ = registrarTxhash
	_ = hashRegTxhash
	_ = urlHintTxhash

	/* TODO:
	* lookup receipt and contract addresses by tx hash
	* name registration for HashReg and UrlHint addresses
	* mine those transactions
	* then set once more SetHashReg SetUrlHint
	 */

	return

}
Example #2
0
func StartRPC(exp *exp.Expanse, ctx *cli.Context) error {
	config := comms.HttpConfig{
		ListenAddress: ctx.GlobalString(RPCListenAddrFlag.Name),
		ListenPort:    uint(ctx.GlobalInt(RPCPortFlag.Name)),
		CorsDomain:    ctx.GlobalString(RPCCORSDomainFlag.Name),
	}

	xeth := xeth.New(exp, nil)
	codec := codec.JSON

	apis, err := api.ParseApiString(ctx.GlobalString(RpcApiFlag.Name), codec, xeth, exp)
	if err != nil {
		return err
	}

	return comms.StartHttp(config, codec, api.Merge(apis...))
}
Example #3
0
func StartIPC(exp *exp.Expanse, ctx *cli.Context) error {
	config := comms.IpcConfig{
		Endpoint: IpcSocketPath(ctx),
	}

	initializer := func(conn net.Conn) (comms.Stopper, shared.ExpanseApi, error) {
		fe := useragent.NewRemoteFrontend(conn, exp.AccountManager())
		xeth := xeth.New(exp, fe)
		apis, err := api.ParseApiString(ctx.GlobalString(IPCApiFlag.Name), codec.JSON, xeth, exp)
		if err != nil {
			return nil, nil, err
		}
		return xeth, api.Merge(apis...), nil
	}

	return comms.StartIpc(config, codec.JSON, initializer)
}
Example #4
0
func newJSRE(expanse *exp.Expanse, docRoot, corsDomain string, client comms.ExpanseClient, interactive bool, f xeth.Frontend) *jsre {
	js := &jsre{expanse: expanse, ps1: "> "}

	// set default cors domain used by startRpc from CLI flag
	js.corsDomain = corsDomain
	if f == nil {
		f = js
	}

	js.xeth = xeth.New(expanse, f)

	js.wait = js.xeth.UpdateState()
	js.client = client
	if clt, ok := js.client.(*comms.InProcClient); ok {
		if offeredApis, err := api.ParseApiString(shared.AllApis, codec.JSON, js.xeth, expanse); err == nil {
			clt.Initialize(api.Merge(offeredApis...))
		}
	}

	// update state in separare forever blocks
	js.re = re.New(docRoot)
	if err := js.apiBindings(f); err != nil {
		utils.Fatalf("Unable to connect - %v", err)
	}

	if !liner.TerminalSupported() || !interactive {
		js.prompter = dumbterm{bufio.NewReader(os.Stdin)}
	} else {
		lr := liner.NewLiner()
		js.withHistory(expanse.DataDir, func(hist *os.File) { lr.ReadHistory(hist) })
		lr.SetCtrlCAborts(true)
		js.loadAutoCompletion()
		lr.SetWordCompleter(apiWordCompleter)
		lr.SetTabCompletionStyle(liner.TabPrints)
		js.prompter = lr
		js.atexit = func() {
			js.withHistory(expanse.DataDir, func(hist *os.File) { hist.Truncate(0); lr.WriteHistory(hist) })
			lr.Close()
			close(js.wait)
		}
	}
	return js
}
func testInit(t *testing.T) (self *testFrontend) {
	// initialise and start minimal expanse stack
	expanse, err := testExp(t)
	if err != nil {
		t.Errorf("error creating expanse: %v", err)
		return
	}
	err = expanse.Start(nil)
	if err != nil {
		t.Errorf("error starting expanse: %v", err)
		return
	}

	// mock frontend
	self = &testFrontend{t: t, ethereum: ethereum}
	self.xeth = xe.New(nil, self)
	self.wait = self.xexp.UpdateState()
	addr, _ := self.expanse.Etherbase()

	// initialise the registry contracts
	reg := registrar.New(self.xeth)
	registrar.GlobalRegistrarAddr = "0x0"

	var txG, txH, txU string
	txG, err = reg.SetGlobalRegistrar("", addr)
	if err != nil {
		t.Fatalf("error creating GlobalRegistrar: %v", err)
	}
	if !processTxs(self, t, 1) {
		t.Fatalf("error mining txs")
	}
	recG := self.xexp.GetTxReceipt(common.HexToHash(txG))
	if recG == nil {
		t.Fatalf("blockchain error creating GlobalRegistrar")
	}
	registrar.GlobalRegistrarAddr = recG.ContractAddress.Hex()

	txH, err = reg.SetHashReg("", addr)
	if err != nil {
		t.Errorf("error creating HashReg: %v", err)
	}
	if !processTxs(self, t, 1) {
		t.Errorf("error mining txs")
	}
	recH := self.xexp.GetTxReceipt(common.HexToHash(txH))
	if recH == nil {
		t.Fatalf("blockchain error creating HashReg")
	}
	registrar.HashRegAddr = recH.ContractAddress.Hex()

	txU, err = reg.SetUrlHint("", addr)
	if err != nil {
		t.Errorf("error creating UrlHint: %v", err)
	}
	if !processTxs(self, t, 1) {
		t.Errorf("error mining txs")
	}
	recU := self.xexp.GetTxReceipt(common.HexToHash(txU))
	if recU == nil {
		t.Fatalf("blockchain error creating UrlHint")
	}
	registrar.UrlHintAddr = recU.ContractAddress.Hex()

	return
}