@agoric/orchestration 0.1.1-dev-e26d66b.0 → 0.1.1-dev-9b9282d.0

package/src/proposals/start-axelar-gmp.js

@@ -0,0 +1,153 @@
+/// <reference types="@agoric/vats/src/core/types-ambient"/>
+
+import {
+  deeplyFulfilledObject,
+  makeTracer,
+  NonNullish,
+} from '@agoric/internal';
+import { E } from '@endo/far';
+
+/**
+ * @import {Issuer} from '@agoric/ertp';
+ * @import {Installation, Instance} from '@agoric/zoe/src/zoeService/utils.js';
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
+ * @import {start as StartFn} from '@agoric/orchestration/src/examples/axelar-gmp.contract.js';
+ */
+
+const trace = makeTracer('start axelarGmp', true);
+
+/**
+ * @param {BootstrapPowers & {
+ *   installation: {
+ *     consume: {
+ *       axelarGmp: Installation<StartFn>;
+ *     };
+ *   };
+ *   instance: {
+ *     produce: {
+ *       axelarGmp: Producer<Instance<StartFn>>;
+ *     };
+ *   };
+ *   issuer: {
+ *     consume: {
+ *       BLD: Issuer<'nat'>;
+ *       IST: Issuer<'nat'>;
+ *     };
+ *   };
+ * }} powers
+ * @param {{
+ *   options: {
+ *     chainInfo: Record<string, CosmosChainInfo>;
+ *     assetInfo: [Denom, DenomDetail & { brandKey?: string }][];
+ *   };
+ * }} config
+ */
+export const startAxelarGmp = async (
+  {
+    consume: {
+      agoricNames,
+      board,
+      chainStorage,
+      chainTimerService,
+      cosmosInterchainService,
+      localchain,
+      startUpgradable,
+    },
+    installation: {
+      consume: { axelarGmp },
+    },
+    instance: {
+      produce: { axelarGmp: produceInstance },
+    },
+    issuer: {
+      consume: { BLD, IST },
+    },
+  },
+  { options: { chainInfo, assetInfo } },
+) => {
+  trace(startAxelarGmp.name);
+
+  const marshaller = await E(board).getReadonlyMarshaller();
+
+  trace('Setting privateArgs');
+
+  const privateArgs = await deeplyFulfilledObject(
+    harden({
+      agoricNames,
+      localchain,
+      marshaller,
+      orchestrationService: cosmosInterchainService,
+      storageNode: E(NonNullish(await chainStorage)).makeChildNode('axelarGmp'),
+      timerService: chainTimerService,
+      chainInfo,
+      assetInfo,
+    }),
+  );
+
+  /** @param {() => Promise<Issuer>} p */
+  const safeFulfill = async p =>
+    E.when(
+      p(),
+      i => i,
+      () => undefined,
+    );
+
+  const axlIssuer = await safeFulfill(() =>
+    E(agoricNames).lookup('issuer', 'AXL'),
+  );
+
+  // const wavaxIssuer = await safeFulfill(() =>
+  //   E(agoricNames).lookup('issuer', 'WAVAX'),
+  // );
+
+  const issuerKeywordRecord = harden({
+    BLD: await BLD,
+    IST: await IST,
+    ...(axlIssuer && { AXL: axlIssuer }),
+    // ...(wavaxIssuer && { WAVAX: wavaxIssuer }),
+  });
+  trace('issuerKeywordRecord', issuerKeywordRecord);
+
+  trace('Starting contract instance');
+  const { instance } = await E(startUpgradable)({
+    label: 'axelarGmp',
+    installation: axelarGmp,
+    issuerKeywordRecord,
+    privateArgs,
+  });
+  produceInstance.resolve(instance);
+  trace('done');
+};
+harden(startAxelarGmp);
+
+export const getManifest = ({ restoreRef }, { installationRef, options }) => {
+  return {
+    manifest: {
+      [startAxelarGmp.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainTimerService: true,
+          chainStorage: true,
+          cosmosInterchainService: true,
+          localchain: true,
+
+          startUpgradable: true,
+        },
+        installation: {
+          consume: { axelarGmp: true },
+        },
+        instance: {
+          produce: { axelarGmp: true },
+        },
+        issuer: {
+          consume: { BLD: true, IST: true },
+        },
+      },
+    },
+    installations: {
+      axelarGmp: restoreRef(installationRef),
+    },
+    options,
+  };
+};

package/src/utils/agd-lib.d.ts

@@ -0,0 +1,109 @@
+export function flags(record: Record<string, unknown>): string[];
+export function makeAgd({ execFileSync, log }: {
+    execFileSync: ExecSync;
+    log?: typeof console.log;
+}): Readonly<{
+    readOnly: () => Readonly<{
+        status: () => Promise<any>;
+        /**
+         * @param {[kind: 'gov', domain: string, ...rest: any]
+         *   | [kind: 'tx', txhash: string]
+         *   | [mod: 'vstorage', kind: 'data' | 'children', path: string]
+         *   | [mod: 'ibc', ...rest: string[]]} qArgs
+         */
+        query: (qArgs: [kind: "gov", domain: string, ...rest: any] | [kind: "tx", txhash: string] | [mod: "vstorage", kind: "data" | "children", path: string] | [mod: "ibc", ...rest: string[]]) => Promise<any>;
+    }>;
+    nameHub: () => Readonly<{
+        /**
+         * NOTE: synchronous I/O
+         *
+         * @param {string[]} path
+         */
+        lookup: (...path: string[]) => string;
+    }>;
+    keys: {
+        /**
+         * @param {string} name
+         * @param {string} mnemonic
+         */
+        add: (name: string, mnemonic: string) => string;
+        showAddress: (...path: string[]) => string;
+        /** @param {string} name */
+        delete: (name: string) => string;
+    };
+    /**
+     * @param {Record<string, unknown>} opts
+     */
+    withOpts: (opts: Record<string, unknown>) => Readonly</*elided*/ any>;
+    lookup: (...path: string[]) => string;
+    status: () => Promise<any>;
+    query: (qArgs: [kind: "gov", domain: string, ...rest: any] | [kind: "tx", txhash: string] | [mod: "vstorage", kind: "data" | "children", path: string] | [mod: "ibc", ...rest: string[]]) => Promise<any>;
+    /**
+     * TODO: gas
+     *
+     * @param {string[]} txArgs
+     * @param {{ chainId: string; from: string; yes?: boolean }} opts
+     */
+    tx: (txArgs: string[], { chainId, from, yes }: {
+        chainId: string;
+        from: string;
+        yes?: boolean;
+    }) => Promise<any>;
+}>;
+export type ExecSync = (file: string, args: string[], opts: {
+    encoding: "utf-8";
+} & {
+    [k: string]: unknown;
+}) => string;
+export type Agd = ReturnType<({ execFileSync, log }: {
+    execFileSync: ExecSync;
+    log?: typeof console.log;
+}) => Readonly<{
+    readOnly: () => Readonly<{
+        status: () => Promise<any>;
+        /**
+         * @param {[kind: 'gov', domain: string, ...rest: any]
+         *   | [kind: 'tx', txhash: string]
+         *   | [mod: 'vstorage', kind: 'data' | 'children', path: string]
+         *   | [mod: 'ibc', ...rest: string[]]} qArgs
+         */
+        query: (qArgs: [kind: "gov", domain: string, ...rest: any] | [kind: "tx", txhash: string] | [mod: "vstorage", kind: "data" | "children", path: string] | [mod: "ibc", ...rest: string[]]) => Promise<any>;
+    }>;
+    nameHub: () => Readonly<{
+        /**
+         * NOTE: synchronous I/O
+         *
+         * @param {string[]} path
+         */
+        lookup: (...path: string[]) => string;
+    }>;
+    keys: {
+        /**
+         * @param {string} name
+         * @param {string} mnemonic
+         */
+        add: (name: string, mnemonic: string) => string;
+        showAddress: (...path: string[]) => string;
+        /** @param {string} name */
+        delete: (name: string) => string;
+    };
+    /**
+     * @param {Record<string, unknown>} opts
+     */
+    withOpts: (opts: Record<string, unknown>) => Readonly</*elided*/ any>;
+    lookup: (...path: string[]) => string;
+    status: () => Promise<any>;
+    query: (qArgs: [kind: "gov", domain: string, ...rest: any] | [kind: "tx", txhash: string] | [mod: "vstorage", kind: "data" | "children", path: string] | [mod: "ibc", ...rest: string[]]) => Promise<any>;
+    /**
+     * TODO: gas
+     *
+     * @param {string[]} txArgs
+     * @param {{ chainId: string; from: string; yes?: boolean }} opts
+     */
+    tx: (txArgs: string[], { chainId, from, yes }: {
+        chainId: string;
+        from: string;
+        yes?: boolean;
+    }) => Promise<any>;
+}>>;
+//# sourceMappingURL=agd-lib.d.ts.map

package/src/utils/agd-lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agd-lib.d.ts","sourceRoot":"","sources":["agd-lib.js"],"names":[],"mappings":"AAUO,8BAHI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrB,MAAM,EAAE,CASpB;AAaM,+CAFI;IAAE,YAAY,EAAE,QAAQ,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,OAAO,CAAC,GAAG,CAAA;CAAE;;;QAgCzD;;;;;WAKG;uBAJQ,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,CAAC,GAC/C,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,GAC5B,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,IAAI,EAAE,MAAM,CAAC,GAC1D,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC;;;QAiBtC;;;;WAIG;0BADQ,MAAM,EAAE;;;QAuDjB;;;WAGG;oBAFQ,MAAM,YACN,MAAM;+BAzDR,MAAM,EAAE;QAmEjB,2BAA2B;uBAAf,MAAM;;IAKpB;;OAEG;qBADQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;sBAzEvB,MAAM,EAAE;;mBAvBR,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,CAAC,GAC/C,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,GAC5B,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,IAAI,EAAE,MAAM,CAAC,GAC1D,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC;IAoCtC;;;;;OAKG;iBAFQ,MAAM,EAAE,0BACR;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;GA4DhE;8BA/IU,MAAM,QACN,MAAM,EAAE,QACR;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,KAC9C,MAAM;kBA8IL,UAAU,yBA1Ib;IAAE,YAAY,EAAE,QAAQ,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,OAAO,CAAC,GAAG,CAAA;CAAE;;;QAgCzD;;;;;WAKG;uBAJQ,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,CAAC,GAC/C,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,GAC5B,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,IAAI,EAAE,MAAM,CAAC,GAC1D,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC;;;QAiBtC;;;;WAIG;0BADQ,MAAM,EAAE;;;QAuDjB;;;WAGG;oBAFQ,MAAM,YACN,MAAM;+BAzDR,MAAM,EAAE;QAmEjB,2BAA2B;uBAAf,MAAM;;IAKpB;;OAEG;qBADQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;sBAzEvB,MAAM,EAAE;;mBAvBR,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,CAAC,GAC/C,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,GAC5B,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,IAAI,EAAE,MAAM,CAAC,GAC1D,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC;IAoCtC;;;;;OAKG;iBAFQ,MAAM,EAAE,0BACR;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;GA8DhC"}

package/src/utils/agd-lib.js

@@ -0,0 +1,167 @@
+import assert from 'node:assert';
+
+const { freeze } = Object;
+
+const agdBinary = 'agd';
+
+/**
+ * @param {Record<string, unknown>} record - e.g. { color: 'blue' }
+ * @returns {string[]} - e.g. ['--color', 'blue']
+ */
+export const flags = record => {
+  // TODO? support --yes with boolean?
+
+  /** @type {[string, string][]} */
+  // @ts-expect-error undefined is filtered out
+  const skipUndef = Object.entries(record).filter(([_k, v]) => v !== undefined);
+  return skipUndef.map(([k, v]) => [`--${k}`, v]).flat();
+};
+
+/**
+ * @callback ExecSync
+ * @param {string} file
+ * @param {string[]} args
+ * @param {{ encoding: 'utf-8' } & { [k: string]: unknown }} opts
+ * @returns {string}
+ */
+
+/**
+ * @param {{ execFileSync: ExecSync; log?: typeof console.log }} io
+ */
+export const makeAgd = ({ execFileSync, log = console.log }) => {
+  /**
+   * @param {{
+   *   home?: string;
+   *   keyringBackend?: string;
+   *   rpcAddrs?: string[];
+   * }} opts
+   */
+  const make = ({ home, keyringBackend, rpcAddrs } = {}) => {
+    const keyringArgs = flags({ home, 'keyring-backend': keyringBackend });
+    if (rpcAddrs) {
+      assert.equal(
+        rpcAddrs.length,
+        1,
+        'XXX rpcAddrs must contain only one entry',
+      );
+    }
+    const nodeArgs = flags({ node: rpcAddrs && rpcAddrs[0] });
+
+    /**
+     * @param {string[]} args
+     * @param {any} [opts]
+     */
+    const exec = (args, opts = { encoding: 'utf-8' }) =>
+      execFileSync(agdBinary, args, opts);
+
+    const outJson = flags({ output: 'json' });
+
+    const ro = freeze({
+      status: async () => JSON.parse(exec([...nodeArgs, 'status'])),
+      /**
+       * @param {[kind: 'gov', domain: string, ...rest: any]
+       *   | [kind: 'tx', txhash: string]
+       *   | [mod: 'vstorage', kind: 'data' | 'children', path: string]
+       *   | [mod: 'ibc', ...rest: string[]]} qArgs
+       */
+      query: async qArgs => {
+        const out = exec(['query', ...qArgs, ...nodeArgs, ...outJson], {
+          encoding: 'utf-8',
+          stdio: ['ignore', 'pipe', 'ignore'],
+        });
+
+        try {
+          return JSON.parse(out);
+        } catch (e) {
+          console.error(e);
+          console.info('output:', out);
+        }
+      },
+    });
+    const nameHub = freeze({
+      /**
+       * NOTE: synchronous I/O
+       *
+       * @param {string[]} path
+       */
+      lookup: (...path) => {
+        if (!Array.isArray(path)) {
+          // TODO: use COND || Fail``
+          throw TypeError();
+        }
+        if (path.length !== 1) {
+          throw Error(`path length limited to 1: ${path.length}`);
+        }
+        const [name] = path;
+        const txt = exec(['keys', 'show', `--address`, name, ...keyringArgs]);
+        return txt.trim();
+      },
+    });
+    const rw = freeze({
+      /**
+       * TODO: gas
+       *
+       * @param {string[]} txArgs
+       * @param {{ chainId: string; from: string; yes?: boolean }} opts
+       */
+      tx: async (txArgs, { chainId, from, yes }) => {
+        const args = [
+          'tx',
+          ...txArgs,
+          ...nodeArgs,
+          ...keyringArgs,
+          ...flags({ 'chain-id': chainId, from }),
+          ...flags({
+            'broadcast-mode': 'block',
+            gas: 'auto',
+            'gas-adjustment': '1.4',
+          }),
+          ...(yes ? ['--yes'] : []),
+          ...outJson,
+        ];
+        log('$$$', agdBinary, ...args);
+        const out = exec(args);
+        try {
+          const detail = JSON.parse(out);
+          if (detail.code !== 0) {
+            throw Error(detail.raw_log);
+          }
+          return detail;
+        } catch (e) {
+          console.error(e);
+          console.info('output:', out);
+        }
+      },
+      ...ro,
+      ...nameHub,
+      readOnly: () => ro,
+      nameHub: () => nameHub,
+      keys: {
+        /**
+         * @param {string} name
+         * @param {string} mnemonic
+         */
+        add: (name, mnemonic) => {
+          return execFileSync(
+            agdBinary,
+            [...keyringArgs, 'keys', 'add', name, '--recover'],
+            { encoding: 'utf-8', input: mnemonic },
+          ).toString();
+        },
+        showAddress: nameHub.lookup,
+        /** @param {string} name */
+        delete: name => {
+          return exec([...keyringArgs, 'keys', 'delete', name, '-y']);
+        },
+      },
+      /**
+       * @param {Record<string, unknown>} opts
+       */
+      withOpts: opts => make({ home, keyringBackend, rpcAddrs, ...opts }),
+    });
+    return rw;
+  };
+  return make();
+};
+
+/** @typedef {ReturnType<makeAgd>} Agd */

package/src/utils/axelar-static-config.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @import {Brand} from '@agoric/ertp';
+ * @import {Denom} from '@agoric/orchestration';
+ */
+/**
+ * @typedef {object} DenomDetail
+ * @property {string} baseName - name of issuing chain; e.g. cosmoshub
+ * @property {Denom} baseDenom - e.g. uatom
+ * @property {string} chainName - name of holding chain; e.g. agoric
+ * @property {Brand<'nat'>} [brand] - vbank brand, if registered
+ * @see {ChainHub} `registerAsset` method
+ */
+export const assetInfo: string;
+export type DenomDetail = {
+    /**
+     * - name of issuing chain; e.g. cosmoshub
+     */
+    baseName: string;
+    /**
+     * - e.g. uatom
+     */
+    baseDenom: Denom;
+    /**
+     * - name of holding chain; e.g. agoric
+     */
+    chainName: string;
+    /**
+     * - vbank brand, if registered
+     */
+    brand?: Brand<"nat"> | undefined;
+};
+import type { Denom } from '@agoric/orchestration';
+import type { Brand } from '@agoric/ertp';
+//# sourceMappingURL=axelar-static-config.d.ts.map

package/src/utils/axelar-static-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axelar-static-config.d.ts","sourceRoot":"","sources":["axelar-static-config.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,+BA0BG;;;;;cAjCW,MAAM;;;;eACN,KAAK;;;;eACL,MAAM;;;;;;2BAPI,uBAAuB;2BADvB,cAAc"}

package/src/utils/axelar-static-config.js

@@ -0,0 +1,41 @@
+/**
+ * @import {Brand} from '@agoric/ertp';
+ * @import {Denom} from '@agoric/orchestration';
+ */
+
+/**
+ * @typedef {object} DenomDetail
+ * @property {string} baseName - name of issuing chain; e.g. cosmoshub
+ * @property {Denom} baseDenom - e.g. uatom
+ * @property {string} chainName - name of holding chain; e.g. agoric
+ * @property {Brand<'nat'>} [brand] - vbank brand, if registered
+ * @see {ChainHub} `registerAsset` method
+ */
+
+export const assetInfo = JSON.stringify([
+  [
+    'uist',
+    {
+      baseDenom: 'uist',
+      baseName: 'agoric',
+      chainName: 'agoric',
+    },
+  ],
+  [
+    'ubld',
+    {
+      baseDenom: 'ubld',
+      baseName: 'agoric',
+      chainName: 'agoric',
+    },
+  ],
+  [
+    'ibc/2CC0B1B7A981ACC74854717F221008484603BB8360E81B262411B0D830EDE9B0',
+    {
+      baseDenom: 'uaxl',
+      baseName: 'axelar',
+      chainName: 'agoric',
+      brandKey: 'AXL',
+    },
+  ],
+]);

package/src/utils/gmp.d.ts

@@ -0,0 +1,61 @@
+export namespace GMPMessageType {
+    let MESSAGE_ONLY: number;
+    let MESSAGE_WITH_TOKEN: number;
+    let TOKEN_ONLY: number;
+}
+/**
+ * @type {{
+ *   AXELAR_GMP: Bech32Address;
+ *   AXELAR_GAS: Bech32Address;
+ *   OSMOSIS_RECEIVER: Bech32Address;
+ * }}
+ */
+export const gmpAddresses: {
+    AXELAR_GMP: Bech32Address;
+    AXELAR_GAS: Bech32Address;
+    OSMOSIS_RECEIVER: Bech32Address;
+};
+export function constructContractCall({ target, functionSignature, args }: ContractCall): AbiEncodedContractCall;
+export function buildGMPPayload(contractCalls: ContractCall[]): number[];
+export namespace networkConfigs {
+    namespace devnet {
+        let label: string;
+        let url: string;
+        let rpc: string;
+        let api: string;
+        let chainId: string;
+    }
+    namespace emerynet {
+        let label_1: string;
+        export { label_1 as label };
+        let url_1: string;
+        export { url_1 as url };
+        let rpc_1: string;
+        export { rpc_1 as rpc };
+        let api_1: string;
+        export { api_1 as api };
+        let chainId_1: string;
+        export { chainId_1 as chainId };
+    }
+    namespace localhost {
+        let label_2: string;
+        export { label_2 as label };
+        let url_2: string;
+        export { url_2 as url };
+        let rpc_2: string;
+        export { rpc_2 as rpc };
+        let api_2: string;
+        export { api_2 as api };
+        let chainId_2: string;
+        export { chainId_2 as chainId };
+    }
+}
+export namespace EVM_CHAINS {
+    let Avalanche: string;
+    let Base: string;
+    let Ethereum: string;
+}
+import type { Bech32Address } from '@agoric/orchestration';
+import type { ContractCall } from '../axelar-types.js';
+import type { AbiEncodedContractCall } from '../axelar-types.js';
+//# sourceMappingURL=gmp.d.ts.map

package/src/utils/gmp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gmp.d.ts","sourceRoot":"","sources":["gmp.js"],"names":[],"mappings":";;;;;AAaA;;;;;;GAMG;AACH,2BANU;IACL,UAAU,EAAE,aAAa,CAAC;IAC1B,UAAU,EAAE,aAAa,CAAC;IAC1B,gBAAgB,EAAE,aAAa,CAAC;CACjC,CAOF;AAQK,2EAHI,YAAY,GACV,sBAAsB,CAoBlC;AAQM,+CAHI,YAAY,EAAE,GACZ,MAAM,EAAE,CAyBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA9E+B,uBAAuB;kCADA,oBAAoB;4CAApB,oBAAoB"}

package/src/utils/gmp.js

@@ -0,0 +1,113 @@
+import { encodeFunctionData, encodeAbiParameters, hexToBytes } from 'viem';
+
+/**
+ * @import {ContractCall, AbiEncodedContractCall} from '../axelar-types.js';
+ * @import {Bech32Address} from '@agoric/orchestration';
+ */
+
+export const GMPMessageType = {
+  MESSAGE_ONLY: 1,
+  MESSAGE_WITH_TOKEN: 2,
+  TOKEN_ONLY: 3,
+};
+
+/**
+ * @type {{
+ *   AXELAR_GMP: Bech32Address;
+ *   AXELAR_GAS: Bech32Address;
+ *   OSMOSIS_RECEIVER: Bech32Address;
+ * }}
+ */
+export const gmpAddresses = {
+  AXELAR_GMP:
+    'axelar1dv4u5k73pzqrxlzujxg3qp8kvc3pje7jtdvu72npnt5zhq05ejcsn5qme5',
+  AXELAR_GAS: 'axelar1zl3rxpp70lmte2xr6c4lgske2fyuj3hupcsvcd',
+  OSMOSIS_RECEIVER: 'osmo1yh3ra8eage5xtr9a3m5utg6mx0pmqreytudaqj',
+};
+
+/**
+ * Constructs a contract call object with ABI encoding.
+ *
+ * @param {ContractCall} data - The data for the contract call.
+ * @returns {AbiEncodedContractCall} The encoded contract call object.
+ */
+export const constructContractCall = ({ target, functionSignature, args }) => {
+  const [name, paramsRaw] = functionSignature.split('(');
+  const params = paramsRaw.replace(')', '').split(',').filter(Boolean);
+
+  return {
+    target,
+    data: encodeFunctionData({
+      abi: [
+        {
+          type: 'function',
+          name,
+          inputs: params.map((type, i) => ({ type, name: `arg${i}` })),
+        },
+      ],
+      functionName: name,
+      args,
+    }),
+  };
+};
+
+/**
+ * Builds a GMP payload from an array of contract calls.
+ *
+ * @param {ContractCall[]} contractCalls - Array of contract call objects.
+ * @returns {number[]} The GMP payload object.
+ */
+export const buildGMPPayload = contractCalls => {
+  const abiEncodedContractCalls = [];
+  for (const call of contractCalls) {
+    const { target, functionSignature, args } = call;
+    abiEncodedContractCalls.push(
+      constructContractCall({ target, functionSignature, args }),
+    );
+  }
+
+  const abiEncodedData = encodeAbiParameters(
+    [
+      {
+        type: 'tuple[]',
+        components: [
+          { name: 'target', type: 'address' },
+          { name: 'data', type: 'bytes' },
+        ],
+      },
+    ],
+    [abiEncodedContractCalls],
+  );
+
+  return Array.from(hexToBytes(abiEncodedData));
+};
+
+export const networkConfigs = {
+  devnet: {
+    label: 'Agoric Devnet',
+    url: 'https://devnet.agoric.net/network-config',
+    rpc: 'https://devnet.rpc.agoric.net',
+    api: 'https://devnet.api.agoric.net',
+    chainId: 'agoricdev-25',
+  },
+  emerynet: {
+    label: 'Agoric Emerynet',
+    url: 'https://emerynet.agoric.net/network-config',
+    rpc: 'https://emerynet.rpc.agoric.net',
+    api: 'https://emerynet.api.agoric.net',
+    chainId: 'agoric-emerynet-9',
+  },
+  localhost: {
+    label: 'Local Network',
+    url: 'https://local.agoric.net/network-config',
+    rpc: 'http://localhost:26657',
+    api: 'http://localhost:1317',
+    chainId: 'agoriclocal',
+  },
+};
+
+export const EVM_CHAINS = {
+  Avalanche: 'Avalanche',
+  Base: 'base-sepolia',
+  Ethereum: 'ethereum-sepolia',
+};