Building Secure, Scalable, and Cross-chain dApps with Agoric’s Orchestration API

If you’ve ever tried to build a cross-chain application, you’ve probably experienced the headaches of managing multiple blockchains, each with its unique properties and challenges. It’s a bit like juggling while riding a unicycle, except the unicycle is on fire. The fragmented nature of the blockchain space makes interoperability a true test of patience and skill. From managing different consensus algorithms and transaction finalities to dealing with varied programming languages and security models, the obstacles are endless.

Current Challenges When Building in the Crypto Space

One of the first things I realized was how isolated each blockchain is, they're all speaking different languages. This fragmentation means cross-chain communication is far from straightforward. Add to that the constant worry about security, with each chain having its own security model, ensuring the safety of assets and data as they move across chains is nerve-wracking.

Then there's the complexity of it all, switching between different programming languages and environments feels like constantly having to switch between different operating systems, each with its peculiarities. And, of course, there’s scalability. Building something that can grow across multiple chains without falling apart? Now that's a whole other story.

As you see, the need for seamless, secure, and scalable solutions is critical. Recently, I came across Agoric’s Orchestration tools, and they seem to take a lot of that pain away.

Introducing Agoric

Agoric is a Cosmos-based Layer 1 blockchain designed for building cross-chain smart contracts in JavaScript. By leveraging JavaScript, Agoric makes blockchain programming accessible to the large community of developers familiar with the language. Its new orchestration tools enable developers to build decentralized applications (dApps) that can securely and efficiently interact across multiple blockchains, solving the interoperability challenges faced in the crypto space.

Key Features of Agoric

Async/Await & Multi-Block Execution: Supports long-lived processes and cross-chain actions, making it easier to build applications with rich features.

Timers: Allows smart contracts to perform actions at predefined times, enhancing their autonomy and complexity.

Interoperability: Native support for Inter-Blockchain Communication (IBC) and extensions like Axelar’s General Message Passing (GMP) provide access to a wide range of blockchain networks.

JavaScript Smart Contracts: Written in a hardened version of JavaScript, offering advanced safety features and composability akin to web development frameworks like ReactJS.

Step-by-Step Guide to Using Agoric's Orchestration API

Agoric's Orchestration API simplifies building multi-chain applications by providing tools to manage cross-chain accounts, execute asynchronous tasks, and handle complex workflows. Here’s a step-by-step guide on how to use these tools to build a secure and scalable dApp.

Getting Started with the Orchestration API

Setup:
Install the necessary libraries and dependencies.

npm install @agoric/sdk

Initialize the Orchestration:
Import the orchestration tools and set up your environment.

import { makeChainHub, Orchestrator } from '@agoric/sdk';

const orchestrator = new Orchestrator();
const chainHub = makeChainHub(remotePowers.agoricNames);

Register Chains:
Connect the Agoric chain to other blockchains.

chainHub.registerChain('polygon', { /* Polygon chain info */ });
chainHub.registerConnection('agoric', 'polygon', { /* Connection info */ });

Create Accounts:
Create accounts on the registered chains.

const polygonAccount = await chainHub.getChain('polygon').makeAccount();
const agoricAccount = await chainHub.getChain('agoric').makeAccount();

Manage Interchain Accounts (ICA):
Use ICAs to control accounts on other blockchains.

const polygonAddress = await polygonAccount.getAddress();

Example: Orchestrating Multi-Chain Staking

Take, for example, a scenario where a user wants to stake MATIC tokens from Polygon on the Cosmos Hub. In the past, this would have required multiple steps, each with potential pitfalls. But with Agoric’s Orchestration, the process is streamlined. You can deposit the tokens, swap them, and stake them, all within a coherent workflow that doesn’t require endless code switching. The fact that you can orchestrate this entire process with a few API calls hits home how much easier multi-chain development can be.

The steps will look something as the following:

Deposit Tokens: Transfer MATIC tokens from the user's wallet to the Agoric chain.

const depositMsg = { /* Transfer details */ };
await agoricAccount.transferSteps(depositMsg);

Swap Tokens: Swap MATIC for ATOM on the Agoric chain.

const swapMsg = { /* Swap details */ };
await agoricAccount.transferSteps(swapMsg);

Stake Tokens: Stake the converted ATOM tokens on the Cosmos Hub.

const stakingMsg = { /* Staking details */ };
await polygonAccount.delegate(stakingMsg);

Here’s a detailed walkthrough of a smart contract that performs cross-chain staking will look as follows:

import { withOrchestration } from '@agoric/sdk/utils';
import { makeNatAmountShape } from '@agoric/sdk/amounts';

const contract = async (zcf, privateArgs, zone, { orchestrate }) => {
  const { brands } = zcf.getTerms();

  const stakeAndSwapFn = async (orch, { zcf }, seat, offerArgs) => {
    const { give } = seat.getProposal();
    const polygon = await orch.getChain('polygon');
    const agoric = await orch.getChain('agoric');

    const [polygonAccount, localAccount] = await Promise.all([
      polygon.makeAccount(),
      agoric.makeAccount(),
    ]);

    const polygonAddress = polygonAccount.getAddress();

    const payments = await withdrawFromSeat(zcf, seat, give);
    await deeplyFulfilled(objectMap(payments, payment => localAccount.deposit(payment)));
    seat.exit();

    const transferMsg = orcUtils.makeOsmosisSwap({
      destChain: 'polygon',
      destAddress: polygonAddress,
      amountIn: give.Stable,
      brandOut: '...',
      slippage: 0.03,
    });

    try {
      await localAccount.transferSteps(give.Stable, transferMsg);
      await polygonAccount.delegate(offerArgs.validator, offerArgs.staked);
    } catch (e) {
      console.error(e);
    }
  };

  const swapAndStakeHandler = orchestrate('LSTTia', { zcf }, stakeAndSwapFn);

  const publicFacet = zone.exo('publicFacet', undefined, {
    makeSwapAndStakeInvitation() {
      return zcf.makeInvitation(
        swapAndStakeHandler,
        'Swap for TIA and stake',
        undefined,
        harden({
          give: { Stable: makeNatAmountShape(brands.Stable, 1n) },
          want: {},
          exit: M.any(),
        }),
      );
    },
  });

  return harden({ publicFacet });
};

export const start = withOrchestration(contract);

Conclusion

In the end, Agoric’s Orchestration API made what used to be a complicated task into something almost routine. By leveraging familiar JavaScript patterns and offering robust APIs, it feels like the days of wrestling with blockchain fragmentation might finally be behind us. For anyone building in this space, it’s worth exploring. Sometimes, the right tools make all the difference.