@Gapi Ethereum

#### @Gapi Ethereum module @StrongTyped

##### For questions/issues you can write ticket here
##### This module is intended to be used with GAPI

Installation and basic examples:

##### To install this Gapi module, run:

``bash
$ npm install @gapi/ethereum --save
`

Consuming @gapi/ethereum

$3


##### Import inside AppModule or CoreModule
`typescript

import { Module } from '@rxdi/core';
import { EthereumModule } from '@gapi/ethereum';

@Module({
imports: [
EthereumModule.forRoot({
port: 8545,
rpc: 'http://localhost',
}),
]
})
export class CoreModule { }
`

With this simple configuration you are connected to Ethereum Node and you can inject Web3Token and Web3Provider inside your Services, Controllers, Types, etc.
There is a typing provided and tested inside this module link

Web3Token
`typescript
{
provide: Web3Token,
useValue: new Web3(null)
},
`

Web3ProviderToken
`typescript
{
provide: Web3ProviderToken,
deps: [Web3Token],
useFactory: (web3: Web3Token) => {
const provider = new web3.providers.HttpProvider(${config.rpc}:${config.port});
web3.setProvider(provider);
return provider;
}
},
`

More information you can find here

Usage:

`typescript
import { Controller } from '@rxdi/core';
import { Web3Token, Web3ProviderToken } from '@gapi/ethereum';

@Controller() // or @Service()
export class EthereumQueriesController {

constructor(
@Inject(Web3Token) private web3: Web3Token,
@Inject(Web3ProviderToken) private provider: Web3ProviderToken
) {
this.web3;
this.provider;
}

}
`

$3

#### loading contracts to Gapi Dependency Injection

To Compile Solidity Contracts you can use truffle
`bash
$ npm i -g truffle
`

Example Contracts you can find here inside truffle-metacoin-example

To compile and migrate your contracts type:

`bash
$ truffle migrate
`

From compiled ABI files *.json you need to install TypeChain compiler to Typescript which will help us to create Methods and classes related with specific contracts that we created

Generate modules using TypeChain

To install it type:

`bash
$ npm i -g typechain
`

Use it as folow inside Gapi root project folder
`bash
$ typechain --force --outDir src/app/core/contracts './truffle-metacoin-example/build/contracts/*.json'
`

You can use contracts parameter inside forRoot configuration to import freshly generated contracts mmm.... smellss like Ethereum :D
`typescript

import { Module } from '@gapi/core';
import { EthereumModule } from '@gapi/ethereum';
import { Coin } from '../core/contracts/Coin';
import { CoinCrowdsale } from '../core/contracts/CoinCrowdsale';

const CoinCrowdsaleABI = require('../../../truffle-metacoin-example/build/contracts/CoinCrowdsale.json');
const CoinABI = require('../../../truffle-metacoin-example/build/contracts/Coin.json');

@Module({
imports: [
EthereumModule.forRoot({
port: process.env.ETHEREUM_PORT || 8545,
rpc: process.env.ETHEREUM_HOST || 'http://localhost',
contracts: [
{
contract: Coin,
abi: CoinABI
},
{
contract: CoinCrowdsale,
abi: CoinCrowdsaleABI
}
]
})
]
})
export class CoreModule { }
`

Or you can import your contract like raw TypeChain contracts
`typescript
import { Module, ModuleWithServices } from '@gapi/core';
import { Web3Token } from '@gapi/ethereum';
import { Coin } from '../core/contracts/Coin';
import { CoinCrowdsale } from '../core/contracts/CoinCrowdsale';

const CoinCrowdsaleABI = require('../../../truffle-metacoin-example/build/contracts/CoinCrowdsale.json');
const CoinABI = require('../../../truffle-metacoin-example/build/contracts/Coin.json');

@Module()
export class ContractsModule {
public static forRoot(): ModuleWithServices {
return {
gapiModule: ContractsModule,
services: [
{
provide: Coin,
deps: [Web3Token],
lazy: true,
useFactory: async (web3: Web3Token) => {
return await Coin.createAndValidate(web3, CoinABI.networks[Object.keys(CoinABI.networks)[0]].address);
}
},
{
provide: CoinCrowdsale,
deps: [Web3Token],
lazy: true,
useFactory: async (web3: Web3Token) => {
return await CoinCrowdsale.createAndValidate(web3, CoinCrowdsaleABI.networks[Object.keys(CoinCrowdsaleABI.networks)[0]].address);
}
}
]
};
}
}

`

Then import them inside your Core module

`typescript

import { Module } from '@gapi/core';
import { EthereumModule } from '@gapi/ethereum';
import { ContractsModule } from './ethereum/contracts.module';

@Module({
imports: [
EthereumModule.forRoot({
port: process.env.ETHEREUM_PORT || 8545,
rpc: process.env.ETHEREUM_HOST || 'http://localhost'
})
ContractsModule.forRoot()
]
})
export class CoreModule { }
`

Then use them inside your controller
`typescript
import {
Query, GraphQLNonNull, Type,
Controller, GraphQLInt, Public
} from '@gapi/core';
import { CoinCrowdsale } from '../core/contracts/CoinCrowdsale';

@ObjectType()
export class EthereumCrowdsaleType {
startTime: number | GraphQLScalarType = GraphQLInt;
endTime: number | GraphQLScalarType = GraphQLInt;
hasEnded: boolean | GraphQLScalarType = GraphQLBoolean;
token: string | GraphQLScalarType = GraphQLString;
weiRaised: number | GraphQLScalarType = GraphQLInt;
wallet: string | GraphQLScalarType = GraphQLString;
}


@Controller()
export class EthereumQueriesController {

constructor(
private crowdsale: CoinCrowdsale
) {}

@Type(EthereumCrowdsaleType)
@Public()
@Query()
async getCrowdsaleInfo(root, payload, context): Promise {
const crowdsaleType = {
startTime: (await this.crowdsale.startTime).toNumber(),
endTime: (await this.crowdsale.endTime).toNumber(),
hasEnded: await this.crowdsale.hasEnded,
token: await this.crowdsale.token,
weiRaised: (await this.crowdsale.weiRaised).toNumber(),
wallet: await this.crowdsale.wallet,
};
console.log('START TIME: ', crowdsaleType.startTime);
console.log('END TIME: ', crowdsaleType.endTime);
console.log('Has Ended: ', crowdsaleType.hasEnded);
console.log('Token: ', crowdsaleType.token);
console.log('WeiRaised: ', crowdsaleType.weiRaised);
console.log('Owner Wallet: ', crowdsaleType.wallet);
return crowdsaleType;
}

}

`

Running private blockchain using Ganache with Docker

$3

The Simplest way to get started with the Docker image:

`Bash
docker run -d -p 8545:8545 trufflesuite/ganache-cli:latest
`

To pass options to ganache-cli through Docker simply add the arguments to
the run command:

`Bash
docker run -d -p 8545:8545 trufflesuite/ganache-cli:latest -a 10 --debug
`

To build the Docker container from source:

`Bash
git clone https://github.com/trufflesuite/ganache-cli.git && cd ganache-cli
docker build -t trufflesuite/ganache-cli .
``

TODO: Better documentation...

Enjoy ! :)