# Utilities

### Constants

#### `BigGas`

Following up your function arguments with BigGas to set a high gas limit and price so that your transactions are more likely to execute. You can change these values within the ReaperSDK.js file.

`reaper.BigGas === { gasPrice: 100000000000, gasLimit: 5000000 }`

For example:

```javascript
await wrappedFantom.transfer(momAddress, 1000, reaper.BigGas);
```

#### `Addresses.json`

Addresses.json contains the addresses of many popular contracts on the Fantom network, and it's easy to add more. Simply import it from the directory's root with a require statement and use dot notation to reference the addresses within. The object is separated by token addresses, testnet contract addresses, and mainnet contract addresses.

Import them each with the following:

`const { tokens, testnet, mainnet } = require("../Addresses.json");`

```javascript
const { tokens, testnet, mainnet } = require("../Addresses.json");

async function main() {
  
  console.log(tokens.usdc);
  console.log(tokens.wftm);
  console.log(testnet.router);
  console.log(mainnet.spooky.masterChef);

}

> 0x04068DA6C83AFCFA0e13ba15A6696662335D5B75
> 0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83
> 0xcCAFCf876caB8f9542d6972f87B5D62e1182767d
> 0x2b2929E785374c651a81A63878Ab22742656DcDd
```

### Contract Instantiation

You can create a contract interface and attach it to an address in a single function call with our createContract function. Just make sure you've already compiled your contracts with Hardhat. Refer to the contract title as a string for the first argument and use the target address as the second like so:

`reaper.createContract(contractTitle: string, contractAddress: string);`

```javascript
  let usdc = await reaper.createContract("ERC20", tokens.usdc);
  let usdcSupply = await usdc.totalSupply();
  console.log(usdcSupply);

  let spookyChef = await reaper.createContract("MasterChef", mainnet.spooky.masterChef);
  let farmCount = await spookyChef.poolLength();
  console.log(farmCount);

> BigNumber { _hex: '0x343b58ee24c1', _isBigNumber: true }
> BigNumber { _hex: '0x0911258c64', _isBigNumber: true }
> BigNumber { _hex: '0xc100e8020d8478e62c7e79', _isBigNumber: true }
```

### Decimal Formatting

#### Formatting human-readable inputs with `reaper.parseToken()`

You can turn floating point inputs of any type into a blockchain-readable BigNumber value in parts-per notation with 18 decimal places. An optional tokenAddress argument will automatically format your input using the correct amount of decimal places, such as 6 for USDC or 8 for BTC.

`reaper.parseToken(amount:string or number, { tokenAddress: string });`

```javascript
  let usdcInput = await reaper.parseToken("100", tokens.usdc);
  console.log(usdcInput);
  console.log(usdcInput.toString());
  
  let wbtcInput = await reaper.parseToken("100", tokens.wbtc);
  console.log(wbtcInput);
  console.log(wbtcInput.toString());
  
  let wftmInput = await reaper.parseToken("100", tokens.wftm);
  console.log(wftmInput);
  console.log(wftmInput.toString());

> BigNumber { _hex: '0x05f5e100', _isBigNumber: true }
> 100000000

> BigNumber { _hex: '0x02540be400', _isBigNumber: true }
> 10000000000

> BigNumber { _hex: '0x056bc75e2d63100000', _isBigNumber: true }
> 100000000000000000000
```

#### Formatting big number outputs with `reaper.formatToken()`

Using the format() function, you can turn any bigNumber-ish value into a human readable fixed-point integer. Using the optional tokenAddress input will allow the function to automatically determine the token's decimals and adjust accordingly. See an example of this below - the function automatically adjusts to USDC's 6 decimals and BTC's 8 decimals.

`reaper.formatToken(amount:BigNumber, { tokenAddress: string });`

```javascript
  let usdc = await reaper.createContract("ERC20", tokens.usdc);
  let usdcSupply = await usdc.totalSupply();
  console.log(await reaper.formatToken(usdcSupply, tokens.usdc));
  
  let wbtc = await reaper.createContract("ERC20", tokens.wbtc);
  let wbtcSupply = await wbtc.totalSupply();
  console.log(await reaper.formatToken(wbtcSupply, tokens.wbtc));
  
  let wftm = await reaper.createContract("ERC20", tokens.wftm);
  let wftmSupply = await wftm.totalSupply();
  console.log(await reaper.formatToken(wftmSupply, tokens.wftm));
  
> 58931849.963579

> 398.79588332

> 233007968.40776092
```

### Pausing Execution

Due to its unpredictable nature, blockchain development can be a tricky beast. On Fantom, you may find your transactions failing due to being sent too soon after the preceding transaction. You may also want to manage transaction timing off-chain when running scripts or simulations. You can handle all of this with Reaper's sleep function.

`reaper.sleep(miliseconds:uint)`

```javascript
  let wftm = await reaper.createContract("ERC20", tokens.wftm);
  sleep(5000) //5 second pause to wait for the contract to be deployed
  await wftm.deposit({ value: ethers.utils.parseEther("1") });
```

### Getting a timestamp

Getting the block.timestamp value in Javascript can be kind of tricky, so Reaper took care of that for you. It's so simple I'm not even going to include an example >:^)

`reaper.getTimestamp() => timestamp:uint`


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.reaper.farm/sdk/reaper-sdk/utilities.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.