@agoric/orchestration 0.1.1-dev-df81dca.0 → 0.1.1-dev-be74a2b.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-df81dca.0+df81dca",
+  "version": "0.1.1-dev-be74a2b.0+be74a2b",
   "description": "Chain abstraction for Agoric's orchestration clients",
   "type": "module",
   "main": "index.js",
@@ -100,5 +100,5 @@
   "typeCoverage": {
     "atLeast": 97.7
   },
-  "gitHead": "df81dcaf96c8e7f3e8aeb74f63e8bca9cd31d007"
+  "gitHead": "be74a2bc3be6c03203f4fe76e9e287f49271ef76"
 }

package/src/examples/swap-anything.contract.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @import {Remote, Vow} from '@agoric/vow';
+ * @import {Zone} from '@agoric/zone';
+ * @import {OrchestrationPowers, OrchestrationTools} from '../utils/start-helper.js';
+ * @import {CosmosChainInfo, Denom, DenomDetail, OrchestrationAccount} from '@agoric/orchestration';
+ */
+export const SingleNatAmountRecord: import("@endo/patterns").Matcher;
+export function contract(zcf: ZCF, privateArgs: OrchestrationPowers & {
+    assetInfo?: [Denom, DenomDetail & {
+        brandKey?: string;
+    }][];
+    chainInfo?: Record<string, CosmosChainInfo>;
+    marshaller: Marshaller;
+    storageNode: Remote<StorageNode>;
+}, zone: Zone, { chainHub, orchestrate, vowTools, zoeTools }: OrchestrationTools): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        makeSwapInvitation(): Promise<globalThis.Invitation<Vow<string>, import("./swap-anything.flows.js").SwapInfo>>;
+    }>;
+    creatorFacet: import("@endo/exo").Guarded<{
+        registerChain(chainName: string, chainInfo: import("@agoric/orchestration").ChainInfo, ibcConnectionInfo?: import("@agoric/orchestration").IBCConnectionInfo): Promise<void>;
+        registerAsset(denom: Denom, detail: DenomDetail): Promise<void>;
+    }>;
+}>;
+export const start: (zcf: globalThis.ZCF<Record<string, unknown>>, privateArgs: OrchestrationPowers & {
+    assetInfo?: [Denom, DenomDetail & {
+        brandKey?: string;
+    }][];
+    chainInfo?: Record<string, CosmosChainInfo>;
+    marshaller: Marshaller;
+    storageNode: Remote<StorageNode>;
+}, baggage: Baggage) => Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        makeSwapInvitation(): Promise<globalThis.Invitation<Vow<string>, import("./swap-anything.flows.js").SwapInfo>>;
+    }>;
+    creatorFacet: import("@endo/exo").Guarded<{
+        registerChain(chainName: string, chainInfo: import("@agoric/orchestration").ChainInfo, ibcConnectionInfo?: import("@agoric/orchestration").IBCConnectionInfo): Promise<void>;
+        registerAsset(denom: Denom, detail: DenomDetail): Promise<void>;
+    }>;
+}>;
+import type { OrchestrationPowers } from '../utils/start-helper.js';
+import type { Denom } from '@agoric/orchestration';
+import type { DenomDetail } from '@agoric/orchestration';
+import type { CosmosChainInfo } from '@agoric/orchestration';
+import type { Remote } from '@agoric/vow';
+import type { Zone } from '@agoric/zone';
+import type { OrchestrationTools } from '../utils/start-helper.js';
+import type { Vow } from '@agoric/vow';
+//# sourceMappingURL=swap-anything.contract.d.ts.map

package/src/examples/swap-anything.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap-anything.contract.d.ts","sourceRoot":"","sources":["swap-anything.contract.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AAEH,qEAGE;AAmBK,8BAVI,GAAG,eACH,mBAAmB,GAAG;IAC5B,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC5C,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,OAAO,WAAW,CAAC,CAAC;CAClC,QACO,IAAI,iDACJ,kBAAkB;;;;;;;;GA6I5B;AAGD;gBAtJiB,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE;gBAC9C,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;gBAC/B,UAAU;iBACT,OAAO,WAAW,CAAC;;;;;;;;;GAmJ0C;yCAxKrB,0BAA0B;2BACR,uBAAuB;iCAAvB,uBAAuB;qCAAvB,uBAAuB;4BAHrE,aAAa;0BACpB,cAAc;wCACqB,0BAA0B;yBAFtD,aAAa"}

package/src/examples/swap-anything.contract.js

@@ -0,0 +1,187 @@
+import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
+import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+import { decodeAddressHook } from '@agoric/cosmic-proto/address-hooks.js';
+import { prepareChainHubAdmin } from '../exos/chain-hub-admin.js';
+import { withOrchestration } from '../utils/start-helper.js';
+import * as sharedFlows from './shared.flows.js';
+import { swapAnythingViaHook, swapIt } from './swap-anything.flows.js';
+import { AnyNatAmountShape } from '../typeGuards.js';
+import { registerChainsAndAssets } from '../utils/chain-hub-helper.js';
+
+const trace = makeTracer('SwapAnything.Contract');
+const interfaceTODO = undefined;
+/**
+ * @import {Remote, Vow} from '@agoric/vow';
+ * @import {Zone} from '@agoric/zone';
+ * @import {OrchestrationPowers, OrchestrationTools} from '../utils/start-helper.js';
+ * @import {CosmosChainInfo, Denom, DenomDetail, OrchestrationAccount} from '@agoric/orchestration';
+ */
+
+export const SingleNatAmountRecord = M.and(
+  M.recordOf(M.string(), AnyNatAmountShape, { numPropertiesLimit: 1 }),
+  M.not(harden({})),
+);
+harden(SingleNatAmountRecord);
+
+/**
+ * Swap assets that are currently in an ERTP purse against another cosmos asset
+ * by using an Osmosis pool then have the swap output routed to any address
+ *
+ * Orchestration contract to be wrapped by withOrchestration for Zoe
+ *
+ * @param {ZCF} zcf
+ * @param {OrchestrationPowers & {
+ *   assetInfo?: [Denom, DenomDetail & { brandKey?: string }][];
+ *   chainInfo?: Record<string, CosmosChainInfo>;
+ *   marshaller: Marshaller;
+ *   storageNode: Remote<StorageNode>;
+ * }} privateArgs
+ * @param {Zone} zone
+ * @param {OrchestrationTools} tools
+ */
+export const contract = async (
+  zcf,
+  privateArgs,
+  zone,
+  { chainHub, orchestrate, vowTools, zoeTools },
+) => {
+  const creatorFacet = prepareChainHubAdmin(zone, chainHub);
+
+  /**
+   * @type {OrchestrationAccount<{ chainId: 'agoric' }>} ;
+   */
+  let sharedLocalAccount;
+
+  // UNTIL https://github.com/Agoric/agoric-sdk/issues/9066
+  const logNode = E(privateArgs.storageNode).makeChildNode('log');
+  /** @type {(msg: string) => Vow<void>} */
+  const log = (msg, level = 'info') =>
+    vowTools.watch(E(logNode).setValue(JSON.stringify({ msg, level })));
+
+  const makeLocalAccount = orchestrate(
+    'makeLocalAccount',
+    {},
+    sharedFlows.makeLocalAccount,
+  );
+
+  registerChainsAndAssets(
+    chainHub,
+    zcf.getTerms().brands,
+    privateArgs.chainInfo,
+    privateArgs.assetInfo,
+  );
+
+  /**
+   * @type {any} sharedLocalAccountP expects a Promise but this is a vow UNTIL
+   *   https://github.com/Agoric/agoric-sdk/issues/9822
+   */
+  const sharedLocalAccountP = zone.makeOnce('localAccount', () =>
+    makeLocalAccount(),
+  );
+
+  const swapAnythingOffer = orchestrate(
+    'swapAnything',
+    { chainHub, sharedLocalAccountP, log, zoeTools },
+    swapIt,
+  );
+
+  const swapAnythingAddressHook = orchestrate(
+    'swapAnythingViaHook',
+    {
+      chainHub,
+      sharedLocalAccountP,
+      log,
+    },
+    swapAnythingViaHook,
+  );
+
+  const tap = zone.makeOnce('tapPosition', _key => {
+    console.log('making tap');
+    return zone.exo('tap', interfaceTODO, {
+      /**
+       * @param {import('@agoric/vats').VTransferIBCEvent} event
+       */
+      async receiveUpcall(event) {
+        await null;
+        trace('receiveUpcall', event);
+
+        if (event.event !== 'writeAcknowledgement') return;
+        trace('Moving on...');
+
+        const {
+          amount,
+          extra: { receiver: origReceiver },
+        } = await vowTools.when(
+          E(sharedLocalAccount).parseInboundTransfer(event.packet),
+        );
+
+        const { baseAddress, query } = decodeAddressHook(origReceiver);
+
+        /**
+         * @type {{
+         *   destAddr: string;
+         *   receiverAddr: string;
+         *   outDenom: string;
+         * }}
+         */
+        // @ts-expect-error
+        const { destAddr, receiverAddr, outDenom } = query;
+
+        trace({
+          baseAddress,
+          destAddr,
+          receiverAddr,
+          outDenom,
+        });
+
+        if (!receiverAddr || !destAddr || !outDenom) return;
+        // Invoke the flow to perform swap and end up at the final destination.
+        return swapAnythingAddressHook(amount, {
+          destAddr,
+          receiverAddr,
+          outDenom, // swapOutDenom
+          onFailedDelivery: 'do_nothing',
+          slippage: {
+            slippagePercentage: '20',
+            windowSeconds: 10,
+          },
+        });
+      },
+    });
+  });
+
+  void vowTools.when(sharedLocalAccountP, async lca => {
+    sharedLocalAccount = lca;
+    await sharedLocalAccount.monitorTransfers(tap);
+    const encoded = await E(privateArgs.marshaller).toCapData({
+      sharedLocalAccount: sharedLocalAccount.getAddress(),
+    });
+    void E(privateArgs.storageNode).setValue(JSON.stringify(encoded));
+    trace('Localchain account information published', encoded);
+  });
+
+  const publicFacet = zone.exo(
+    'Swap Anything PF',
+    M.interface('Swap Anything PF', {
+      makeSwapInvitation: M.callWhen().returns(InvitationShape),
+    }),
+    {
+      makeSwapInvitation() {
+        return zcf.makeInvitation(
+          swapAnythingOffer,
+          'swap',
+          undefined,
+          M.splitRecord({ give: SingleNatAmountRecord }),
+        );
+      },
+    },
+  );
+
+  return { publicFacet, creatorFacet };
+};
+harden(contract);
+
+export const start = withOrchestration(contract, { publishAccountInfo: true });
+harden(start);

package/src/examples/swap-anything.flows.d.ts

@@ -0,0 +1,32 @@
+export function swapIt(orch: Orchestrator, { chainHub, sharedLocalAccountP, log, zoeTools: { localTransfer, withdrawToSeat }, }: {
+    chainHub: GuestInterface<ChainHub>;
+    sharedLocalAccountP: Promise<GuestInterface<LocalOrchestrationAccountKit["holder"]>>;
+    zoeTools: GuestInterface<ZoeTools>;
+    log: GuestOf<(msg: string, level?: string) => Vow<void>>;
+}, seat: ZCFSeat, offerArgs: SwapInfo): Promise<string>;
+export function swapAnythingViaHook(_orch: Orchestrator, { chainHub, sharedLocalAccountP }: {
+    chainHub: GuestInterface<ChainHub>;
+    sharedLocalAccountP: Promise<GuestInterface<LocalOrchestrationAccountKit["holder"]>>;
+}, { denom, value }: DenomAmount, memoArgs: SwapInfo): Promise<void>;
+export type SwapInfo = {
+    destAddr: string;
+    receiverAddr: string;
+    outDenom: Denom;
+    slippage: {
+        slippagePercentage: string;
+        windowSeconds: number;
+    };
+    onFailedDelivery: string;
+    nextMemo?: string;
+};
+import type { Orchestrator } from '../types.js';
+import type { ChainHub } from '../types.js';
+import type { GuestInterface } from '@agoric/async-flow';
+import type { LocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
+import type { ZoeTools } from '../utils/zoe-tools.js';
+import type { Vow } from '@agoric/vow';
+import type { GuestOf } from '@agoric/async-flow';
+import type { ZCFSeat } from '@agoric/zoe';
+import type { DenomAmount } from '../types.js';
+import type { Denom } from '@agoric/orchestration';
+//# sourceMappingURL=swap-anything.flows.d.ts.map

package/src/examples/swap-anything.flows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap-anything.flows.d.ts","sourceRoot":"","sources":["swap-anything.flows.js"],"names":[],"mappings":"AA8EO,6BAXI,YAAY,wFAEpB;IAAsC,QAAQ,EAAtC,eAAe,QAAQ,CAAC;IAC6C,mBAAmB,EAAxF,OAAO,CAAC,eAAe,4BAA4B,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjC,QAAQ,EAAtC,eAAe,QAAQ,CAAC;IACiC,GAAG,EAA5D,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,IAAI,CAAC,CAAC;CAC3D,QAAQ,OAAO,aACP,QAAQ,mBAwFlB;AAYM,2CAPI,YAAY,qCAEpB;IAAsC,QAAQ,EAAtC,eAAe,QAAQ,CAAC;IAC6C,mBAAmB,EAAxF,OAAO,CAAC,eAAe,4BAA4B,CAAC,QAAQ,CAAC,CAAC,CAAC;CACvE,oBAAQ,WAAW,YACX,QAAQ,iBAgDlB;uBAnNY;IACR,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,KAAK,CAAC;IAChB,QAAQ,EAAE;QAAE,kBAAkB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IAChE,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;kCAQsF,aAAa;8BAAb,aAAa;oCAN7D,oBAAoB;kDAIf,wCAAwC;8BAC5D,uBAAuB;yBAF5B,aAAa;6BAHO,oBAAoB;6BAEpC,aAAa;iCAImD,aAAa;2BAL/E,uBAAuB"}

package/src/examples/swap-anything.flows.js

@@ -0,0 +1,222 @@
+import { NonNullish, makeTracer } from '@agoric/internal';
+import { makeError, q } from '@endo/errors';
+import { M, mustMatch } from '@endo/patterns';
+
+const trace = makeTracer('SwapAnything.Flow');
+
+const { entries } = Object;
+
+/**
+ * @typedef {{
+ *   destAddr: string;
+ *   receiverAddr: string;
+ *   outDenom: Denom;
+ *   slippage: { slippagePercentage: string; windowSeconds: number };
+ *   onFailedDelivery: string;
+ *   nextMemo?: string;
+ * }} SwapInfo
+ *
+ * @import {GuestInterface, GuestOf} from '@agoric/async-flow';
+ * @import {Denom} from '@agoric/orchestration';
+ * @import {ZCFSeat} from '@agoric/zoe';
+ * @import {Vow} from '@agoric/vow';
+ * @import {LocalOrchestrationAccountKit} from '../exos/local-orchestration-account.js';
+ * @import {ZoeTools} from '../utils/zoe-tools.js';
+ * @import {Orchestrator, OrchestrationFlow, ChainHub, CosmosChainInfo, DenomAmount} from '../types.js';
+ */
+
+const denomForBrand = async (orch, brand) => {
+  const agoric = await orch.getChain('agoric');
+  const assets = await agoric.getVBankAssetInfo();
+  const { denom } = NonNullish(
+    assets.find(a => a.brand === brand),
+    `${brand} not registered in ChainHub`,
+  );
+  return denom;
+};
+
+/**
+ * @param {SwapInfo} swapInfo
+ * @returns {string}
+ */
+const buildXCSMemo = swapInfo => {
+  const memo = {
+    wasm: {
+      contract: swapInfo.destAddr,
+      msg: {
+        osmosis_swap: {
+          output_denom: swapInfo.outDenom,
+          slippage: {
+            twap: {
+              window_seconds: swapInfo.slippage.windowSeconds,
+              slippage_percentage: swapInfo.slippage.slippagePercentage,
+            },
+          },
+          receiver: swapInfo.receiverAddr,
+          on_failed_delivery: swapInfo.onFailedDelivery,
+          nextMemo: swapInfo.nextMemo,
+        },
+      },
+    },
+  };
+
+  return JSON.stringify(memo);
+};
+
+/**
+ * @satisfies {OrchestrationFlow}
+ * @param {Orchestrator} orch
+ * @param {object} ctx
+ * @param {GuestInterface<ChainHub>} ctx.chainHub
+ * @param {Promise<GuestInterface<LocalOrchestrationAccountKit['holder']>>} ctx.sharedLocalAccountP
+ * @param {GuestInterface<ZoeTools>} ctx.zoeTools
+ * @param {GuestOf<(msg: string, level?: string) => Vow<void>>} ctx.log
+ * @param {ZCFSeat} seat
+ * @param {SwapInfo} offerArgs
+ */
+
+// Ref: https://github.com/osmosis-labs/osmosis/tree/main/cosmwasm/contracts/crosschain-swaps#via-ibc
+export const swapIt = async (
+  orch,
+  {
+    chainHub,
+    sharedLocalAccountP,
+    log,
+    zoeTools: { localTransfer, withdrawToSeat },
+  },
+  seat,
+  offerArgs,
+) => {
+  mustMatch(
+    offerArgs,
+    M.splitRecord(
+      {
+        destAddr: M.string(),
+        receiverAddr: M.string(),
+        outDenom: M.string(),
+        onFailedDelivery: M.string(),
+        slippage: { slippagePercentage: M.string(), windowSeconds: M.number() },
+      },
+      { nextMemo: M.string() },
+    ),
+  );
+  void log('Begin swapIt');
+
+  const { receiverAddr, destAddr } = offerArgs;
+  // NOTE the proposal shape ensures that the `give` is a single asset
+  const { give } = seat.getProposal();
+  const [[_kw, amt]] = entries(give);
+  trace(`sending {${amt.value}} from osmosis to ${receiverAddr}`);
+  const denom = await denomForBrand(orch, amt.brand);
+
+  /**
+   * @type {any} XXX methods returning vows
+   *   https://github.com/Agoric/agoric-sdk/issues/9822
+   */
+  const sharedLocalAccount = await sharedLocalAccountP;
+
+  /**
+   * Helper function to recover if IBC Transfer fails
+   *
+   * @param {Error} e
+   */
+  const recoverFailedTransfer = async e => {
+    await withdrawToSeat(sharedLocalAccount, seat, give);
+    const errorMsg = `IBC Transfer failed ${q(e)}`;
+    trace(`ERROR: ${errorMsg}`);
+    void log(errorMsg, 'error');
+    seat.fail(errorMsg);
+    throw makeError(errorMsg);
+  };
+
+  const [_a, osmosisChainInfo, _connection] =
+    await chainHub.getChainsAndConnection('agoric', 'osmosis');
+
+  trace(`got info for chain: osmosis ${osmosisChainInfo}`);
+  trace(osmosisChainInfo);
+
+  await localTransfer(seat, sharedLocalAccount, give);
+  trace(`completed transfer to localAccount`);
+
+  try {
+    const memo = buildXCSMemo(offerArgs);
+    trace(memo);
+    void log(`sending transfer with ${q(memo)}`);
+
+    await sharedLocalAccount.transfer(
+      {
+        value: destAddr,
+        encoding: 'bech32',
+        chainId: /** @type {CosmosChainInfo} */ (osmosisChainInfo).chainId,
+      },
+      { denom, value: amt.value },
+      { memo },
+    );
+    trace(`completed transfer to ${destAddr}`);
+  } catch (e) {
+    void log(`transfer error ${q(e)}`, 'error');
+    return recoverFailedTransfer(e);
+  }
+
+  seat.exit();
+  return 'transfer complete, seat exited';
+};
+harden(swapIt);
+
+/**
+ * @satisfies {OrchestrationFlow}
+ * @param {Orchestrator} _orch
+ * @param {object} ctx
+ * @param {GuestInterface<ChainHub>} ctx.chainHub
+ * @param {Promise<GuestInterface<LocalOrchestrationAccountKit['holder']>>} ctx.sharedLocalAccountP
+ * @param {DenomAmount} transferInfo
+ * @param {SwapInfo} memoArgs
+ */
+export const swapAnythingViaHook = async (
+  _orch,
+  { chainHub, sharedLocalAccountP },
+  { denom, value },
+  memoArgs,
+) => {
+  mustMatch(
+    memoArgs,
+    M.splitRecord(
+      {
+        destAddr: M.string(),
+        receiverAddr: M.string(),
+        outDenom: M.string(),
+        onFailedDelivery: M.string(),
+        slippage: { slippagePercentage: M.string(), windowSeconds: M.number() },
+      },
+      { nextMemo: M.string() },
+    ),
+  );
+
+  const { receiverAddr, destAddr } = memoArgs;
+  trace(`sending {${value}} from osmosis to ${receiverAddr}`);
+
+  /**
+   * @type {any} XXX methods returning vows
+   *   https://github.com/Agoric/agoric-sdk/issues/9822
+   */
+  const sharedLocalAccount = await sharedLocalAccountP;
+
+  const [_a, osmosisChainInfo, _connection] =
+    await chainHub.getChainsAndConnection('agoric', 'osmosis');
+
+  trace(`got info for chain: osmosis ${osmosisChainInfo}`);
+  trace(osmosisChainInfo);
+
+  const memo = buildXCSMemo(memoArgs);
+
+  await sharedLocalAccount.transfer(
+    {
+      value: destAddr,
+      encoding: 'bech32',
+      chainId: /** @type {CosmosChainInfo} */ (osmosisChainInfo).chainId,
+    },
+    { denom, value },
+    { memo },
+  );
+};
+harden(swapAnythingViaHook);

package/src/exos/ibc-packet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ibc-packet.d.ts","sourceRoot":"","sources":["ibc-packet.js"],"names":[],"mappings":"AAMA,4CAA6C,MAAM,CAAC;AAsB7C,gDAHI,GAAG,GACD,OAAO,CAgCnB;AAOM,+CAHI,OAAO,mBAAmB,EAAE,IAAI,8BAChC,QAAQ,GAAG;IAAE,eAAe,EAAE,eAAe,CAAA;CAAE,IA0GhD,GAAG,MAFA,UAAU;eAtFH,iBAAiB,CAAC,WAAW,CAAC;;;;;QAU1C;;;;;WAKG;0BAJQ,IACV,SAAa,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAC,CAC9D,QACO,aAAa;;;;;;QAYxB;;;;;;;;;;;;;;;;WAgBG;oCAbQ,CACV,SACA,WACA,UAAkB,2CAA2C,CAAC,CACvD,CACF,CACF,OACO;YACN,IAAI,EAAE,aAAa,CAAC;YACpB,KAAK,EAAE,IACX,SAAe,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAC,CAC9D,CAAC;SACH;;;;;;;;GA+CK;IA9ET;;;;;OAKG;sBAJQ,IACV,SAAa,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAC,CAC9D,QACO,aAAa;;;;GA2E/B;AAaM,yCAHI,OAAO,mBAAmB,EAAE,IAAI,YAChC,QAAQ,IAqC6D,CAAC,SAAjE,SAAS,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAE,sFACjE,OAAO,UACP,IAAI,CAAC,CAAC,QACN,aAAa;;;EAmBzB;AAQM,sCAHI,OAAO,mBAAmB,EAAE,IAAI,YAChC,QAAQ;;mBArKC,iBAAiB,CAAC,WAAW,CAAC;;;;QAU1C;;;;;WAKG;0BAJQ,IACV,SAAa,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAC,CAC9D,QACO,aAAa;;;;;sBA2HgD,CAAC,SAAjE,SAAS,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAE,sFACjE,OAAO,UACP,IAAI,CAAC,CAAC,QACN,aAAa;;;;EAkCzB;8BAba,UAAU,CAAC,OAAO,kBAAkB,CAAC;6BAvOpB,gBAAgB;8BAEf,aAAa;8BACP,cAAc;yBADpB,aAAa;mCAGb,mBAAmB;uCADf,gCAAgC;+BAHlB,sBAAsB;gCAAtB,sBAAsB;8BAAtB,sBAAsB"}
+{"version":3,"file":"ibc-packet.d.ts","sourceRoot":"","sources":["ibc-packet.js"],"names":[],"mappings":"AAMA,4CAA6C,MAAM,CAAC;AAsB7C,gDAHI,GAAG,GACD,OAAO,CAgCnB;AAOM,+CAHI,OAAO,mBAAmB,EAAE,IAAI,8BAChC,QAAQ,GAAG;IAAE,eAAe,EAAE,eAAe,CAAA;CAAE,IA2HhD,GAAG,MAFA,UAAU;eAvGH,iBAAiB,CAAC,WAAW,CAAC;;;;;QAU1C;;;;;WAKG;0BAJQ,IACV,SAAa,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAC,CAC9D,QACO,aAAa;;;;;;QAYxB;;;;;;;;;;;;;;;;WAgBG;oCAbQ,CACV,SACA,WACA,UAAkB,2CAA2C,CAAC,CACvD,CACF,CACF,OACO;YACN,IAAI,EAAE,aAAa,CAAC;YACpB,KAAK,EAAE,IACX,SAAe,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAC,CAC9D,CAAC;SACH;;;;;;;;GAgEK;IA/FT;;;;;OAKG;sBAJQ,IACV,SAAa,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAC,CAC9D,QACO,aAAa;;;;GA4F/B;AAaM,yCAHI,OAAO,mBAAmB,EAAE,IAAI,YAChC,QAAQ,IAqC6D,CAAC,SAAjE,SAAS,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAE,sFACjE,OAAO,UACP,IAAI,CAAC,CAAC,QACN,aAAa;;;EAmBzB;AAQM,sCAHI,OAAO,mBAAmB,EAAE,IAAI,YAChC,QAAQ;;mBAtLC,iBAAiB,CAAC,WAAW,CAAC;;;;QAU1C;;;;;WAKG;0BAJQ,IACV,SAAa,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAC,CAC9D,QACO,aAAa;;;;;sBA4IgD,CAAC,SAAjE,SAAS,uBAAuB,CAAC,GAAG,SAAS,eAAe,CAAE,sFACjE,OAAO,UACP,IAAI,CAAC,CAAC,QACN,aAAa;;;;EAkCzB;8BAba,UAAU,CAAC,OAAO,kBAAkB,CAAC;6BAxPpB,gBAAgB;8BAEf,aAAa;8BACP,cAAc;yBADpB,aAAa;mCAGb,mBAAmB;uCADf,gCAAgC;+BAHlB,sBAAsB;gCAAtB,sBAAsB;8BAAtB,sBAAsB"}

package/src/exos/ibc-packet.js

@@ -157,8 +157,25 @@ export const prepareIBCTransferSender = (zone, { watch, makeIBCReplyKit }) => {
           const { result, error } = obj;
           error === undefined || Fail`ICS20-1 transfer error ${error}`;
           result ?? Fail`Missing result in ICS20-1 transfer ack ${obj}`;
-          result === ICS20_TRANSFER_SUCCESS_RESULT ||
-            Fail`ICS20-1 transfer unsuccessful with ack result ${result}`;
+          if (result === ICS20_TRANSFER_SUCCESS_RESULT) {
+            return; // OK, transfer was successful, nothing to do
+          }
+
+          // Function to safely base64-decode and parse JSON
+          const decodeAndParse = b64 => {
+            try {
+              return JSON.parse(atob(b64));
+            } catch {
+              Fail`Decoding of base64-encoded ack obj object failed: ${JSON.stringify(b64)}`;
+            }
+          };
+
+          const outerDecoded = decodeAndParse(result);
+          const ibcAck =
+            outerDecoded?.ibc_ack && decodeAndParse(outerDecoded.ibc_ack);
+
+          ibcAck?.result === ICS20_TRANSFER_SUCCESS_RESULT ||
+            Fail`ICS20-1 transfer unsuccessful with ack result: ${outerDecoded}`;
         },
       },
     },

package/src/proposals/start-swap-anything.js

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