DEV Community: Cormac

How to Reconnect to Process logs on Ubuntu

Cormac — Tue, 07 Jun 2022 22:05:09 +0000

Running continuous processes or functions on a virtual machine is essential for any large development process.

Here's how to continuously run a process on Ubuntu, disconnect and then reconnect to access a process' logs.

Step 1) Start `screen`

This might be already installed, check with: screen --version

If not, install with one of these commands (OS specific)

yum install screen
apt install screen

Open a screen session:

screen

Screen User Manual

Step 2) Run your program with `&`

I'm running a validator in a GCP ubuntu virtual machine so my start command looks like:
sudo mortar server --data-dir ./data-dir --chain genesis.json --libp2p 0.0.0.0:1478 --nat IP-ADDRESS --seal --price-limit 1 &

Just make sure to add & to the end of whatever command you use. This is let the program to keep running even after you quit the shell session.

Step 3) Disconnect your SSH session

You can do this by closing the shell window

Step 4) Reconnect

Resume screen session: screen -r

You should now see the output of the process logs in real time

How to Manage Multiple Github Accounts

Cormac — Tue, 07 Jun 2022 19:04:45 +0000

If you work for a company and code on the side you may need to manage multiple Github accounts from the same device.

Here's how to push from two different Github accounts locally

Step 1) Create SSH keys

For each SSH key pairs:
run ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

You'll be prompted: "Enter a file in which to save the key" so make sure to use a unique name like "company" or "personal".

Step 2) Add public key to Github

Follow these steps.

Step 3) Create an ssh config file
cd ~/.ssh
touch config

Enter something like this making sure to save after:

#personal account
Host github.com-personal
   HostName github.com
   User git
   IdentityFile ~/.ssh/personal
   IdentitiesOnly yes

#user2 account
Host github.com-company
   HostName github.com
   User git
   IdentityFile ~/.ssh/company
   IdentitiesOnly yes

Step 4) Clone Repo

git clone git@github.com-company:REPOSITORY_NAME.git

Step 5) Edit config

You'll need to do this for each repo

Open up local git config using git config --local -e and add:

[user]
    name = company
    email = name@company.com

type :wq and enter to save and quit

Step 6) Confirm your remote url

git remote set-url origin git@github-comcompany:REPOSITORY_NAME.git

Step 7) Git add commit and push

Now you can git actions (pull/push/fetch...etc) all you like!

Resources:
https://www.youtube.com/watch?v=R5yS23LKr04
https://gist.github.com/Jonalogy/54091c98946cfe4f8cdab2bea79430f9

How to Debug Reactjs App running on iPhone in Safari

Cormac — Fri, 27 May 2022 17:03:27 +0000

Sometimes Chrome and Safari dev tools mobile view for a web app aren't perfectly accurate so it's important to test it on a real mobile device.

This is how to debug a Reactjs application running on an iPhone.

Step 1) Start your application locally

This usually entails running yarn start or next dev

Step 2) Start ngrok

This allows you to access your local app on your phone and edit files in real-time.

Step 3) Allow Web Inspector on iPhone

This can be turned on in Settings > Safari > Advanced

Step 4) Open Reactjs app on Safari

Instead of using http://localhost:3000/ open your app using the ngrok url in Safari on your phone

Step 5) Open Dev Tools in Safari

If you've correctly followed the previous steps now you can open Safari on your laptop by opening Safari > Develop > Device > ngrok

Step 6) Debug!

With your React app running locally from Safari on your phone and dev tools opened in Safari you can now debug your app with the same visibility you could from Chrome dev tools.

How to Dockerize a Next.js app

Cormac — Sat, 14 May 2022 18:21:36 +0000

Use this example dockerfile to dockerize and build your Next.js app as an image.

# Node version
FROM node:14-alpine as build

RUN apk update
RUN apk --no-cache --virtual build-dependencies add \
    jpeg-dev \
    cairo-dev \
    giflib-dev \
    pango-dev \
    python3 \
    make \
    g++ 


# Set the working directory
WORKDIR /app

# Add the source code to app
COPY . /app

# Install all the dependencies
RUN yarn install --frozen-lockfile

# Generate the build of the application
RUN yarn build

# Production image, copy all the files and run next
FROM node:14-alpine AS runner
WORKDIR /app

RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001

# Copy the build output to replace the default nginx contents.
# COPY --from=build /app/next.config.js ./
COPY --from=build /app/public ./public
COPY --from=build --chown=nextjs:nodejs /app/.next ./.next
COPY --from=build /app/node_modules ./node_modules
COPY --from=build /app/package.json ./package.json

USER root

EXPOSE 3000

CMD ["yarn", "start"]

Then run the following to build it:
docker build --no-cache -t latest .
docker run latest

You can now use this to push to Google Cloud Container Registry

How to send Ether or Matic using Ethers

Cormac — Sat, 14 May 2022 16:57:18 +0000

If you're building a dapp you'll probably need to implement a solution for users to send tokens to one another.

Here's how to send ethers or any ERC-20 token from the frontend using ethers and web3.

First we'll need these three libraries: web3, web3modal and ethers

yarn add ethers web3 web3modal

Then we need to request to connect to Metamask or any other Ethereum web wallet a user is using.

const connectToMetamask = async () => {
    const web3Modal = new Web3Modal()
    const connection = await web3Modal.connect()
    const provider = new ethers.providers.Web3Provider(connection)
    const signer = provider.getSigner()
    const address = await signer.getAddress()
    if (!address || !signer || !provider) {
      console.log("ERROR couldn't connect to metamask")
    } 
  }

The function above collects the user's address and signer which allows us to request a transaction to the network. In this case I will demonstrate how to send Matic on Polygon.

const requestPolygonTransaction = async (signer, address, provider) => {
    // check validity of addresses
    if (
      !web3.utils.isAddress(address) || !web3.utils.isAddress(process.env.NEXT_PUBLIC_OWNER_WALLET)
    ) {
      console.log('ERROR invalid wallet addresses provided')
      return
    }

    const transactionParameters = {
      from: address, // sender wallet address
      to: process.env.NEXT_PUBLIC_OWNER_WALLET,  // receiver address
      data: '0x',
      value: ethers.utils.parseEther(polygonAmount),
      gasLimit: ethers.utils.hexlify(10000),
      gasPrice: ethers.utils.hexlify(parseInt(await provider.getGasPrice())),
    }

    await signer
      .sendTransaction(transactionParameters)
      .then((transaction) => {
        isModalVisible = false
        Modal.success({
          title: 'Transaction success!',
      })
      .catch((e) => {
        console.log('failed!')
        Modal.error({
          title: 'Oops transaction failed!',
          content: 'please double check the amount and try again',
        })

        return
      })
  }

To help with things I'm using a Polygon node endpoint provided by Alchemy.

Putting things all together this is what my final code looks like to send matic on polygon using ethers.

import { Modal, Input, Tooltip } from 'antd'
import { ethers } from 'ethers'
import Web3 from 'web3'
import Web3Modal from 'web3modal'
import utilStyles from '../styles/utils.module.css'
import 'antd/dist/antd.css'

const web3 = new Web3(process.env.NEXT_PUBLIC_ALCHEMY_ENDPOINT)

export default function CryptoCheckout({
  isModalVisible,
  handleOk,
  handleCancel,
  polygonAmount,
  updateAmount,
}) {
  const connectToMetamask = async () => {
    const web3Modal = new Web3Modal()
    const connection = await web3Modal.connect()
    const provider = new ethers.providers.Web3Provider(connection)
    const signer = provider.getSigner()
    const address = await signer.getAddress()
    if (address && signer && provider) {
      requestPolygonTransaction(signer, address, provider)
    } else {
      console.log("ERROR couldn't connect to metamask")
    }
  }

  const requestPolygonTransaction = async (signer, address, provider) => {
    // check validity of addresses
    if (
      !web3.utils.isAddress(address) ||
   !web3.utils.isAddress(process.env.NEXT_PUBLIC_OWNER_WALLET)
    ) {
      console.log('ERROR invalid wallet addresses provided')
      return
    }

    const transactionParameters = {
      from: address,
      to: process.env.NEXT_PUBLIC_OWNER_WALLET, 
      data: '0x',
      value: ethers.utils.parseEther(polygonAmount),
      gasLimit: ethers.utils.hexlify(10000),
      gasPrice: ethers.utils.hexlify(parseInt(await provider.getGasPrice())),
    }

    await signer
      .sendTransaction(transactionParameters)
      .then((transaction) => {
        isModalVisible = false
        Modal.success({
          title: 'Tx Success!'
      })
      .catch((e) => {
        console.log('failed!')
        Modal.error({
          title: 'Oops transaction failed!',
          content: 'please double check the amount and try again',
        })

        return
      })
  }

  return (
    <>
      <Modal
        title="Crypto Checkout"
        visible={isModalVisible}
        onOk={handleOk}
        onCancel={handleCancel}
        footer={[
          <button
            key="submit"
            className={`${utilStyles.primaryButton}`}
            onClick={connectToMetamask}
          >
            Submit
          </button>,
        ]}
      >
        <p>Enter amount in polygon (MATIC) you'd like to send</p>

        <Input
          prefix=""
          className={`${utilStyles.input}`}
          value={polygonAmount}
          onChange={updateAmount}
          placeholder="50"
          suffix="matic"
        />
      </Modal>
    </>
  )
}

That's it! You can also use the same method to send ether and any other Ethereum based token.

How to Update Google Cloud Run Instance using an API Axios Request

Cormac — Thu, 12 May 2022 01:41:51 +0000

This tutorial is explains how to update an existing google cloud run instance using a google cloud build docker image.

First to push your docker image to Google Cloud you can run the following from your local codebase:
gcloud builds submit --timeout=2000s --machine-type=e2-highcpu-32 --tag gcr.io/PROJECT-NAME/IMAGE-NAME .

This will build your docker project and store it as an image in GCP container registry.

Then to deploy the image as a Google Cloud instance you can run this command:
gcloud run deploy INSTANCE-NAME --image gcr.io/PROJECT-NAME/IMAGE-NAME --region us-east1 --platform managed --allow-unauthenticated --quiet

Cool! Now our docker project is running in Cloud Run.

In my case I use have different code bases for different website themes and build them using docker. So I used the first command to submit all my themes to Google Cloud, but I needed a programmatic way to overwrite my cloud run instance with a new docker image when switching between themes from my frontend app.

Usually you could run the gcloud run deploy CLI command but I needed to convert the CLI command to an axios API request I add to a cloud function in my backend.

Here's I did it:

try {
async function updateTheme() {
  let token: any
  const jwtClient = new google.auth.JWT(firebaseClientEmail, "", firebaseKey, [
    'https://www.googleapis.com/auth/cloud-platform',
  ])

  await jwtClient.authorize(async function (err: any, _token: any) {
    if (err) {
      console.log("JWT ERROR: ", err)
      return err
    } else {
      token = _token.access_token.split('.')
      token = token[0] + '.' + token[1] + '.' + token[2]

      const deploySteps = [
        {
          name: 'gcr.io/cloud-builders/gcloud',
          args: [
            'run',
            'deploy',
            `${name}`,
            '--image',
            `gcr.io/${googleCloudProject}/theme-${theme}`,
            '--region',
            'us-east1',
            '--allow-unauthenticated',
            '--platform',
            'managed',
            '--quiet',
          ],
        },
      ]

      const deployRevisions = async () => {
        await axios({
          method: "post",
          url: `https://cloudbuild.googleapis.com/v1/projects/${googleCloudProject}/builds`,
          headers: {
            Authorization: `Bearer ${token}`,
          },
          data: {
            steps: deploySteps,
            timeout: "1200s",
          },
        })
          .catch(function (error: any) {
            console.log("ERROR UPDATING THEME: ", error)
            return
          })
          .then(function (response: any) {
            console.log("SUCCESSFULLY DEPLOYED THEME UPDATE")
          })
      }

      if (token) {
        deployRevisions()
      } else {
        console.log("MISSING TOKEN")
      }
    }
  })
}

await updateTheme()

} catch (e) {
    console.log("tried updating theme but something went wrong")
    return
}

The above chunk of code utilizes the Cloud Build API to overwrite a cloud run instance with a docker image in Google Cloud. It fetches the Google Cloud authentication code to use in the request as well.

Place it in a function and simple pass in the image name when you wish to update your cloud run instance

Deploying an Expo Web React Native App to Google Cloud

Cormac — Thu, 14 Apr 2022 23:35:35 +0000

Building mobile apps has never been easier thanks to Expo. According to their website, Expo is an open-source platform for making universal native apps for Android, iOS, and the web with JavaScript and React.

Paired with Google Cloud Run, highly scalable containerized a fully managed serverless platform, Expo web apps can be extremely quick to make and ship.

Here’s how to build and deploy your React Native Expo web app to Google Cloud Run:

0) Setup Expo

I’m assuming you already have an Expo app setup and running locally (their docs are super easy to follow)

1) Add a Dockerfile to the root of your application

You can copy and paste this one into your project:

`# build environment
FROM node:14-alpine as react-build

install global packages

ENV NPM_CONFIG_PREFIX=/home/node/.npm-global
ENV PATH /home/node/.npm-global/bin:$PATH
RUN npm i --unsafe-perm -g npm@latest expo-cli@latest
WORKDIR /app
ADD . ./
RUN yarn
RUN npx expo-optimize

used for ENV

RUN expo build:web --release-channel prod

server environment

FROM nginx:alpine
ADD nginx.conf /etc/nginx/conf.d/configfile.template
COPY --from=react-build /app/web-build /usr/share/nginx/html
ENV PORT 8080
ENV HOST 0.0.0.0
EXPOSE 8080
CMD sh -c "envsubst '\$PORT' < /etc/nginx/conf.d/configfile.template > /etc/nginx/conf.d/default.conf && nginx -g 'daemon off;'"`

The key elements here which are super important is making sure to expo-cli as well as including the RUN npx expo-optimize and RUN expo build:web — release-channel prod commands.

These include all the necessary Expo packages and scripts.

3. Setup Google Cloud

You’ll need to make sure you’ve enabled Cloud Build, Cloud Run and Container Registry in your project.

You’ll also need to sign into Gcloud from the command line:

gcloud auth login gcloud config set project YOUR_PROJECT_ID

Build using Docker

gcloud builds submit --timeout=2000s --machine-type=N1_HIGHCPU_8 --tag gcr.io/YOUR_PROJECT_ID/frontend

You can remove the machine-type=N1_HIGHCPU_8 tag if you want to use the starter level server. Make sure to add your project ID.

The cli will prompt you to enter a project name

5. Submit build to Google Cloud Run

gcloud run deploy YOUR_PROJECT_NAME —image gcr.io/mortar-329801/frontend --region us-west2 --platform managed
Feel free to change the region.

And your app is live!

How to Access ENV Variables in Google Cloud Run using Next.js

Cormac — Thu, 14 Apr 2022 23:31:48 +0000

If you’re building a web application, Google Cloud Run is a great option for you to deploy microservices to the cloud. It’s built on top of Kubernetes and allows you to scale backend and monorepos with ease.

However, when our team at Ownchain was working to deploy our users’ based on a Docker image sitting in Google Cloud Build and Container Registry, our client-side code was unable to access our environment variables set in Cloud Run–they were showing up as undefined.

Here’s how we were able to deploy our Next.js monorepo application to Google Cloud using Docker and dynamic ENV variables:

I’m assuming you have already setup lerna and can run you’re application locally.

Initial Setup

This is the key to exposing your ENV variables to the client once you deploy your application to Cloud Run.

We ended up using @beam-australia/react-env to fetch ENV variables from the server and expose them to the client.

You can follow the NEXT.js example in their repo, or they also have instructions if you used Create React App.
Here’s an example of how it works:

// package.json { "name": "web", "version": "0.1.0", "dependencies": { "@beam-australia/react-env": "^3.1.1", "next": "^11.0.1", "next-compose-plugins": "^2.2.1", "next-with-less": "^1.0.0", "react": "17.0.2", "react-dom": "17.0.2", "react-env": "^0.0.0", "react-router-dom": "^5.2.0", }, "scripts": { "start": "react-env --path ../../../.env -- next dev", "build": "next build", "export": "next export", "start:prod": "react-env --path ../../../.env -- next start", "test": "jest", }, }

Using the react-env package we can set a custom path for our .env file within our monorepo application.

`// app.tsx
import React, { useEffect } from 'react';
import Head from 'next/head';
import env from "@beam-australia/react-env";

function App() {
useEffect(() => {
console.log("Firebase User: ", env("FIREBASE_USER_ID"))
}, [])

return (
<>

Ownchain

</>
);
}`

By adding the script t our

component we can read in our ENV variables using env("FIREBASE_USER_ID") format.

Some Devops Stuff

Once that’s all setup, you should have your Dockerfile in the root directory ready to go. Our’s looked something like this:

`# Stage 1: Compile and Build the app

Node version

FROM node:14.17.3-alpine as build

Check https://github.com/nodejs/docker-node/tree/b4117f9333da4138b03a546ec926ef50a31506c3#nodealpine to understand why libc6-compat might be needed.

RUN apk add --no-cache libc6-compat git

Set the working directory

WORKDIR /app

Add the source code to app

COPY ./js /app

Install all the dependencies

RUN yarn install
RUN yarn bootstrap

Generate the build of the application

RUN yarn build

Stage 2: Serve app with nginx server

Production image, copy all the files and run next

FROM node:14.17.3-alpine AS runner
WORKDIR /app
ENV NODE_ENV production
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001

Copy the build output to replace the default nginx contents.

COPY --from=build /app/packages/web/next.config.js ./
COPY --from=build /app/packages/web/public ./public
COPY --from=build --chown=nextjs:nodejs /app/packages/web/.next ./.next
COPY --from=build /app/node_modules ./node_modules
COPY --from=build /app/packages/web/package.json ./package.json
USER root
EXPOSE 3000
CMD ["yarn", "start:prod"]`

**Make sure to add your USER as root otherwise @beam-australia/react-env won’t have enough access to your environment variables.

Sync Github with CloudBuild and set Cloud Run Automated Deployments

This is pretty easy to setup, Google has some great documentation for this: https://cloud.google.com/build/docs/automating-builds/build-repos-from-github

In addition, we can also utilize Cloud Functions to setup continuous delivery to Cloud Run with each new Cloud Build using Pub/Sub. Follow this article for specific instructions: https://medium.com/google-cloud/continuous-deployment-to-cloud-run-services-based-on-a-new-container-image-bccd776b7357

Showing it off

Now we can add ENV variables directly to Cloud Run:

Or you can add them as tags with API or CLI requests like so (see bottom):

"run", "deploy",${serviceName}, "--image", "gcr.io/GOOGLE_CLOUD_PROJECT/store", "--region", "us-west2", "--allow-unauthenticated", "--platform", "managed", "--update-env-vars",REACT_APP_FIREBASE_USER_ID=${userId},REACT_APP_STORE_LOGO=${logoUrl}``

Now when you visit your Cloud Run url your client will be able to access your env variables. 🥳

How to Deploy Your Shopify React App to Heroku

Cormac — Thu, 14 Apr 2022 23:24:32 +0000

I followed the Build a Shopify App with Node and React to start my first Shopify app. The server sets you up using a local ngrok server which was pretty impractical since I travel a bit.

The steps are as follows:

Create new app on Heroku
Connect app with your Github repo/branch (it may take a minute or two to load)
Place your SHOPIFY_API_KEY and SHOPIFY_API_SECRET_KEY in your Heroku app’s Config Vars located in Settings.
Update your Shopify App Urls with your live Heroku app link (https://example-app.herokuapp.com/) and (https://example-app.herokuapp.com/auth/callback)

That’s it. Your app should be live and ready to scale!

How to Run Firebase Functions Emulator on your iPhone using Expo

Cormac — Thu, 14 Apr 2022 23:21:17 +0000

Using Expo makes developing React Native apps incredibly easy and it works great with many tools including firebase.

By following these steps you can setup your React Native Expo app with firebase functions and run them locally.

Setting up Expo and React Native

yarn global add expo-cli
then..

expo init AwesomeProject cd AwesomeProject yarn start

Boom done.

Connect with Firebase Functions

First you’re going to want to go to console.firebase.com, create a project and add a web app. Make sure to activate all the services you’re interested in using including Firebase Functions by clicking through the left menu bar.

Then switch back to your code editor and install firebase:

expo install firebase
Then you need to create a firebase.js file in the root of your directory and add your config details that you can find in the Firebase console. Mine looks like the following:

import firebase from 'firebase/app' import 'firebase/firestore' import 'firebase/functions' import 'firebase/storage' import 'firebase/auth'; // Initialize Firebase const firebaseConfig = { apiKey: PLACE_YOUR_CONFIG_HERE, authDomain: PLACE_YOUR_CONFIG_HERE, databaseURL: PLACE_YOUR_CONFIG_HERE, projectId: PLACE_YOUR_CONFIG_HERE, storageBucket: PLACE_YOUR_CONFIG_HERE, messagingSenderId: PLACE_YOUR_CONFIG_HERE, appId: PLACE_YOUR_CONFIG_HERE, measurementId: PLACE_YOUR_CONFIG_HERE }; if (!firebase.apps.length) { firebase.initializeApp(firebaseConfig) } else { firebase.app(); // if already initialized, use that one } export const firestoreDatabase = firebase.firestore() export const firebaseStorage = firebase.storage() export const firebaseFunctions = firebase.functions() export const firebaseAuth = firebase.auth()

Cool, next enter firebase init into the command line and select functions and press enter. Firebase will setup the folder structure and add an index.js or index.txs file for you to get started. Edit these as you please.

Running Firebase Functions Locally

If you want to test out your react native app in the Expo interface on your mobile device you’re going to need your IP address, specifically your IP4v address which you can find here: https://whatismyipaddress.com/

Good, now that you’ve got your IP, switch back to your firebase.js file and let’s add another line.

firebase.functions().useEmulator("PLACE_YOUR_IP_HERE:5001");
Then we need to edit our firebase.json file and add a new “host” line to our emulator settings like so:
"emulators": { "functions": { "port": 5001, "host": "0.0.0.0" }, "ui": { "enabled": true } },

Sweet.

If you added configs to your firebase functions you’ll need to run the following command:

firebase functions:config:get > .runtimeconfig.json
If you’re using Typescript functions make sure to run this as well:

cd functions npx tsc --watch

Now We’re Ready

Now that’s setup we are ready to run:

firebase emulators:start — only functions
If all went well your firebase functions should be responding when you expo start and test your app on your mobile device.

Local and Production ENV Variables using Expo React Native

Cormac — Thu, 14 Apr 2022 23:17:18 +0000

Expo recently came out with a new feature which makes managing ENVs a lot easier using what they call a dynamic app config file.

*Here’s you to setup env variables for different environments in Expo:
*

Create and app.config.js file at the root of your repo
Populate the file, it should look something like this:

import 'dotenv/config';

export default { name: 'APP_NAME', version: '1.0.0', extra: { environment: 'dev' }, };

Call variable. Now when we run our application, we can access the environment variable by doing the following:

import Constants from 'expo-constants'; export default function App(props) { console.log("props.environment: ", props.environment) } App.defaultProps = { environment: Constants.manifest.extra.environment, };

Setup different variables for production and local development. To do this, we’ll need to change out deploy script to manually add a variable describing the environment.

I place mine in a Dockerfile which Google Cloud uses to build my application:

RUN ENVIRONMENT=prod expo build:web
But you you add the ENVIRONMENT=prod to wherever you are building your app.

Update the app.config.js to make variables dynamic based on the environment.

import 'dotenv/config'; if (process.env.ENVIRONMENT === 'prod') { export default { name: 'APP_NAME', version: '1.0.0', extra: { environment: 'prod' }, }; } else { export default { name: 'APP_NAME', version: '1.0.0', extra: { environment: 'dev' }, }; }

Here we check the ENVIRONMENT variable and then we can update the extra variables based on where we are using our app. When we deploy our app will use variables defined in the top section.

How to make an API Query the Blockchain

Cormac — Thu, 14 Apr 2022 17:03:34 +0000

Blockchain makes data public to anyone however it can be a little tricky to access.

In this blog I’ll break down how to make API requests to blockchains, using Avalanche as an example.

Much of Avalanche’s API functionality requires you to have access to each Node’s permissions or to run your own node which currently has a startup staking fee of 2,000 AVAX or $126,000.

For developers who wish to access Avalanches on-chain data without staking their own node, the Avalanche team provides a public endpoint to make api requests.

For this demonstration we will be request the latest block from Avalanche’s C-Chain.

Because the C-Chain is an instance of the Ethereum Virtual Machine powered, you can request much of the same information you could using GETH in Ethereum:

Let’s Get Started

To make things easy, we’ll first request the latest block curl. Using the first link above, we see we can request information from the C-chain using
.

By browsing through the eth execution-apis in the second link we can use eth_getBlockByNumber to get the latest block data.

Putting it all together we get the following curl request:

curl -X POST --data '{ "jsonrpc":"2.0", "id" :1, "method":"eth_getBlockByNumber", "params":["latest", false] }' -H 'content-type:application/json;' https://api.avax.network/ext/bc/C/rpc

If you open terminal, paste and enter this command you should get a response looking similar to this:

Congratulations! You just made a request to the Avalanche blockchain.

Avalanche Request using HTTP Postman

If you prefer http requests, we can make the same request be using postman:

Paste in link and the body into Postman like in the screenshot above, then press Send.

You’ll get a response looking like this:

Just like before we can see the latest block’s gas fee, height, transaction hashes and more.

We could also use Axios

await axios.post(postUrl, { "jsonrpc": "2.0", "id": 1, "method": "eth_getBlockByNumber", "params": ["latest", false] }) .then((res: any) => { console.log("AVAX BLOCK DATA: ", res.data.result) }) .catch((err: any) => { console.log("err: ", err.response) return err })

Once you get the hang of it, requesting Avalanche and Ethereum chains is pretty straightforward and by using public APIs we can save a lot of resources.