Java Script API

In order for a software application to be able to interact with the Hash Ahead blockchain (eg: read blockchain data or send transaction information to the network), the software must be connected to a Hash Ahead node.

For this purpose, each Hash Ahead client implements the JSON-RPC specification, so applications can rely on a uniform set of endpoints.

If you want to connect to a Hash Ahead node with JavaScript, you can use native JavaScript, but there are some handy libraries in the ecosystem that make this easier. Through these libraries, developers can write intuitive and easy to understand or even a single line of code to initialize the interaction with Ethereum (using JSON RPC requests behind the scenes).

Running a node requires a connection to the Hash Ahead software -- the Hash Ahead client. If your node is not on your local machine (for example, your node is running on an AWS instance), please update the IP address in the tutorial accordingly. See our page on running nodes for more information.

Why use a library?

These libraries reduce the complexity of interacting directly with a Hash Ahead node. They also provide utility functions (example: converting HAH to Gwei), so as a developer you can spend less time dealing with the intricacies of the Hash Ahead client and more time working on your application's unique features.

Library Function

Connect to the Hash Ahead node

Using providers, these libraries allow you to connect to Hash Ahead and read its data, either via JSON-RPC or Metamask.

For example:

// A Web3Provider wraps a standard Web3 provider, which is
// what MetaMask injects as window.ethereum into each page
const provider = new ethers.providers.Web3Provider(window.ethereum)

// The MetaMask plugin also allows signing transactions to
// send ether and pay to change state within the blockchain.
// For this we need the account signer...
const signer = provider.getSigner()

Web3js example:

var web3 = new Web3("http://localhost:9090")
// or
var web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:9090"))

// change provider
web3.setProvider("ws://localhost:9091")
// or
web3.setProvider(new Web3.providers.WebsocketProvider("ws://localhost:9091"))

// Using the IPC provider in node.js
var net = require("net")
var web3 = new Web3("/Users/myuser/Library/Hashahead/geth.ipc", net) // mac os path
// or
var web3 = new Web3(
  new Web3.providers.IpcProvider("/Users/myuser/Library/Hashahead/geth.ipc", net)
) // mac os path
// on windows the path is: "\\\\.\\pipe\\hah.ipc"
// on linux the path is: "/users/myuser/.hashahead/geth.ipc"

Once set up, you will be able to query the blockchain for the following:

• Block number

• Fuel estimate

• Smart contract events

• Network id

and more...

Wallet Function

These libraries provide you with the functionality to create wallets, manage keys, and sign transactions.

An example in HAH is provided here:

// Create a wallet instance from a mnemonic...
mnemonic =
  "announce room limb pattern dry unit scale effort smooth jazz weasel alcohol"
walletMnemonic = Wallet.fromMnemonic(mnemonic)

// ...or from a private key
walletPrivateKey = new Wallet(walletMnemonic.privateKey)

walletMnemonic.address === walletPrivateKey.address
// true

// The address as a Promise per the Signer API
walletMnemonic.getAddress()
// { Promise: '0x71CB05EE1b1F506fF321Da3dac38f25c0c9ce6E1' }

// A Wallet address is also available synchronously
walletMnemonic.address
// '0x71CB05EE1b1F506fF321Da3dac38f25c0c9ce6E1'

// The internal cryptographic components
walletMnemonic.privateKey
// '0x1da6847600b0ee25e9ad9a52abbd786dd2502fa4005dd5af9310b7cc7a3b25db'
walletMnemonic.publicKey
// '0x04b9e72dfd423bcf95b3801ac93f4392be5ff22143f9980eb78b3a860c4843bfd04829ae61cdba4b3b1978ac5fc64f5cc2f4350e35a108a9c9a92a81200a60cd64'

// The wallet mnemonic
walletMnemonic.mnemonic
// {
//   locale: 'en',
//   path: 'm/44\'/60\'/0\'/0/0',
//   phrase: 'announce room limb pattern dry unit scale effort smooth jazz weasel alcohol'
// }

// Note: A wallet created with a private key does not
//       have a mnemonic (the derivation prevents it)
walletPrivateKey.mnemonic
// null

// Signing a message
walletMnemonic.signMessage("Hello World")
// { Promise: '0x14280e5885a19f60e536de50097e96e3738c7acae4e9e62d67272d794b8127d31c03d9cd59781d4ee31fb4e1b893bd9b020ec67dfa65cfb51e2bdadbb1de26d91c' }

tx = {
  to: "0x8ba1f109551bD432803012645Ac136ddd64DBA72",
  value: utils.parseEther("1.0"),
}

// Signing a transaction
walletMnemonic.signTransaction(tx)
// { Promise: '0xf865808080948ba1f109551bd432803012645ac136ddd64dba72880de0b6b3a7640000801ca0918e294306d177ab7bd664f5e141436563854ebe0a3e523b9690b4922bbb52b8a01181612cec9c431c4257a79b8c9f0c980a2c49bb5a0e6ac52949163eeb565dfc' }

// The connect method returns a new instance of the
// Wallet connected to a provider
wallet = walletMnemonic.connect(provider)

// Querying the network
wallet.getBalance()
// { Promise: { BigNumber: "42" } }
wallet.getTransactionCount()
// { Promise: 0 }

// Sending ether
wallet.sendTransaction(tx)

Once set up you'll be able to:

• create accounts

• send transactions

• sign transactions

and more...

Interact with smart contract functions

JavaScript client libraries allow your application to call smart contract functions by reading the Application Binary Interface (ABI) of a compiled contract.

The ABI essentially explains the contract's functions in a JSON format and allows you to use it like a normal JavaScript object.

So the following Solidity contract:\

contract Test {
    uint a;
    address d = 0x12345678901234567890123456789012;

    function Test(uint testInt)  { a = testInt;}

    event Event(uint indexed b, bytes32 c);

    event Event2(uint indexed b, bytes32 c);

    function foo(uint b, bytes32 c) returns(address) {
        Event(b, c);
        return d;
    }
}

Would result in the following JSON:

[{
    "type":"constructor",
    "payable":false,
    "stateMutability":"nonpayable"
    "inputs":[{"name":"testInt","type":"uint256"}],
  },{
    "type":"function",
    "name":"foo",
    "constant":false,
    "payable":false,
    "stateMutability":"nonpayable",
    "inputs":[{"name":"b","type":"uint256"}, {"name":"c","type":"bytes32"}],
    "outputs":[{"name":"","type":"address"}]
  },{
    "type":"event",
    "name":"Event",
    "inputs":[{"indexed":true,"name":"b","type":"uint256"}, {"indexed":false,"name":"c","type":"bytes32"}],
    "anonymous":false
  },{
    "type":"event",
    "name":"Event2",
    "inputs":[{"indexed":true,"name":"b","type":"uint256"},{"indexed":false,"name":"c","type":"bytes32"}],
    "anonymous":false
}]

This means you can:

• Send a transaction to the smart contract and execute its method

• Call to estimate the gas a method execution will take when executed in the EVM

• Deploy a contract

And more...

\