![](https://steemitimages.com/DQmRp8QNfqNb2c7M7p5D8vMqk1qxn6BDWrc5coYdBs6DTA3/image.png)

Today we have some exciting news to share: AppBase is ready, and we would like everyone to help with testing. Although, please note that third-party developers may need to make some minor changes to adapt to the new platform.

# AppBase release candidate is now ready

Back in August we shared with you news of some of the [exciting updates](https://steemit.com/steemitdev/@steemitdev/steem-blockchain-update-august-2017) being made to the Steem blockchain. One of those updates is AppBase, which will create distinct “modules” that will dramatically improve Steem’s ability to scale. 

AppBase is the first step in creating a multi-chain FABRIC. AppBase enables many components of the Steem blockchain to become modular by creating additional non-consensus blockchains as dedicated plugins. These plugins can be updated much more rapidly because they do not require replaying the entire blockchain.

# We are finally ready to test AppBase on a large scale! 

If you’re just a regular steemit.com user, you can help too. Head on over to [steemitstage.com](https://steemitstage.com) and use the site like you normally would.

Our staging environment includes the same security measures taken for steemit.com, and is considered pre-production. It's designed to be as close to the 'real' steemit.com as possible, in order to fully vet new code before it makes it to steemit.com. If you're still worried about using your keys, you're welcome to just use your posting key. Even if you don't login at all, just browsing the site and providing feedback to us is still useful.

# For Developers

If you run or maintain a Steem service, there are a couple of steps you will need to take to ensure your service will continue to operate as expected. Details are in the sections below.

## steemd node changes

If you run a steemd node, you can check out the tag `v0.19.4rc1` from GitHub or Docker Hub.


## API changes

We restructured our APIs to allow greater flexibility for future upgrading and maintaining. The APIs now take in a single object as an argument and return a single object as a return type. All the existing APIs have been updated to match this standard.

Because we no longer need to stick to C++ style parameter semantics, we can use more varied default argument types as well as variadic parameters. We can also extend the functionality of a call without impacting the existing apps by extending the returned object.

The `database_api` has undergone significant changes to allow the querying of all consensus objects with any ordering that steemd uses already. This will provide more flexibility for services to find the objects they need.


**New `condenser_api`**

To help with this transition, we created `condenser_api`, which contains all of the API methods that currently exist and uses the existing argument formatting. The easiest way to get your app to work with Appbase is to change the api to `condenser_api`.

**APIs must be called by name**

If you are used to calling an API using the API id, that method of invocation is no longer supported. All the APIs must now be called by name.

**Removed `login_api`**
 
The `login_api` was designed as a way to map the API names to numeric ids. Because the APIs are no longer called via id, there is now no need for the `login_api`, and so it has been removed.

**API methods list**

If you call `jsonrpc.get_methods`, a list of all available API methods will be returned.

**Argument and return object prototypes**

If you call `jsonrpc.get_signature` passing an API method name, it will return the argument and return the object prototypes.

For example,

`{"jsonrpc":"2.0", "method":"jsonrpc.get_signature", "params":{"method":"database_api.get_active_witnessess"}, "id":1}`

returns 
`{"jsonrpc":"2.0","result":{"args":{},"ret":{"witnesses":[]}},"id":1}`

`{}` is the void type argument and it returns a list in the `witnesses` field.

**Using `condenser_api`**

All calls in `condenser_api` will return `[]` as the argument, as the array argument passing is opaque and implemented in the API calls themselves. They follow the current argument formatting. Existing apps should only need to skip using `login_api` and send all of their calls to `condenser_api` without any other changes required to use Appbase.


For example, calling `get_dynamic_global_properties` with `condenser_api` vs `database_api`:

`{"jsonrpc":"2.0", "method":"condenser_api.get_dynamic_global_properties", "params":[], "id":1}`

`{"jsonrpc":"2.0", "method":"database_api.get_dynamic_global_properties", "id":1}`

Because the method has no arguments, the `params` field can be omitted when not using `condenser_api`. However, it can optionally be included as the void type (e.g. `"params":{}`) but it is not required.

**Streamlined syntax**

You might have noticed that the previous examples used a different format to call the API. Previously, there was an outdated call syntax that looked like this:

`{"jsonrpc":"2.0", "id":0, "method":"call", "params":["api","function",[ARGS]]}`. 

However, we now support a more streamlined call syntax:

`{"jsonrpc":"2.0", "id":0, "method":"api.function", "params":[ARGS]}`

Both formats work, but with the new format being preferred for readability.

**Enhanced JSON-RPC compliance**

Some other changes were made to make steemd more compliant with the widely-used JSON-RPC specification. This is still new. Please help us test our json-rpc implementation to ensure that it is spec compliant.

**Backward compatibility**

Our reverse proxy service, `jussi`, handles the method translation. This means that even after deploying Appbase to our production environment, the old API calls should still work. 

**Future updates required**

Note that the new APIs introduced in this release are still Work in Progress. There are a number of serialization changes that are still being made to them and hence they are in various states of completeness. We will post again in the near future explaining the nature of those changes. Feel free to play around with those APIs, but know that they will be changed. Once we finalize those APIs, we will deprecate `condenser_api` and begin migration to the new APIs.

## Config file changes

The logging config has always been a sore spot in the config file because of the number of options available. It was so complex that it required a different parser. We have changed to using a json format, which allows us to use only one parser. The default logging config is the following:

```
# Console appender definition json: {"appender", "stream"}
log-console-appender = {"appender":"stderr","stream":"std_error"}

# File appender definition json:  {"appender", "file"}
log-file-appender = {"appender":"p2p","file":"logs/p2p/p2p.log"}

# Logger definition json: {"name", "level", "appender"}
log-logger = {"name":"default","level":"debug","appender":"stderr"}
log-logger = {"name":"p2p","level":"debug","appender":"p2p"}
```

**Plugins**

Plugins are enabled via the `plugin` option. There is no more `public-api` option and all the APIs are now enabled via `plugin` as well.

Most config options are now namespaced by the plugin they belong to. Config options that were not namespaced are still supported but will now log a deprecation warning when used. `contrib/config-for-docker.ini` and `contrib/fullnode.config.ini` are example configs that are used in the Docker images. You can use these as example config files.  As usual, we strongly recommend using the Docker images to deploy your node.

# Conclusions

These changes have been in the works for many months, and represent a major step forward for Steem. AppBase provides a robust foundation for meeting all of our future scaling needs, and will allow us to grow the platform while at the same time managing the resource requirements for third-party application developers, witnesses, and exchanges to grow along with it.