Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/stradivario/gapi-ethereum

@Gapi Ethereum module providing web3 as a dependency injection
https://github.com/stradivario/gapi-ethereum

Last synced: 4 days ago
JSON representation

@Gapi Ethereum module providing web3 as a dependency injection

Awesome Lists containing this project

README

        

# @Gapi Ethereum

#### @Gapi Ethereum module @StrongTyped

##### For questions/issues you can write ticket [here](http://gitlab.youvolio.com/gapi/ethereum/issues)
##### This module is intended to be used with [GAPI](https://github.com/Stradivario/gapi)

## Installation and basic examples:
##### To install this Gapi module, run:

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

## Consuming @gapi/ethereum

### Basic usage
##### 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](https://github.com/Stradivario/gapi-ethereum/blob/master/development/web3.typings.ts)

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](https://github.com/Stradivario/gapi-ethereum/blob/master/development/index.ts#L39)

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;
}

}
```

### Advanced usage
#### 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](https://github.com/katopz/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](https://github.com/Neufund/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

### Docker

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 ! :)