@agoric/client-utils 0.1.1-dev-02c06c4.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,37 @@
+# Client Utils
+
+Utilities for building clients of an Agoric chain
+
+## Overview
+
+The Agoric chain takes mutations through signed messages and reveals state updates through vstorage. This package abstracts the calls to RPC nodes into a [CQRS](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation) interface. The commands are made mostly through an on-chain Smart Wallet and the queries through vstorage.
+
+## Design
+
+This package will be used in several kinds of clients:
+- CLI (such as the `agoric` command)
+- GUI (such as dapps)
+- Tests (such as a3p-integration tests)
+
+As such the modules cannot assume they're running in Node. There are some ambient authorities in common in the above environments (e.g. `setTimeout`) but a further constraint is that these modules will not export ambient authority. Instead they will provide interfaces that are ergonomic for creating empowered objects in the client context.
+
+## Related packages
+
+### cli
+`agoric` package has a command line UI (CLI) for working with an Agoric chain. It's in this repository at `packages/agoric-cli`.
+
+### rpc
+`@agoric/rpc` is a small library that currently just has utilities for watching vstorage. This package avoids depending on `@agoric/rpc` for now because it:
+ - is in a separate repository ([ui-kit](https://github.com/Agoric/ui-kit/blob/main/packages/rpc)) so not part of agoric-sdk CI
+ - depends on `axios` and `vite` which are unnecessary constraints
+
+Some of the functionality in this package could make sense in that package, but for now it will be ignored.
+
+### cosmic-proto
+
+`@agoric/cosmic-proto` is a package that contains the protobuf stubs for the Agoric cosmos-sdk module. At various points it has also held generated RPC clients. Because that package is imported into contracts we've kept those out. They may end up in `@agoric/rpc` eventually.
+
+### * / clientSupport
+
+The `clientSupport.js` module of several packages. Some packages export this module with certain helpers that this package may abstract.
+

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@agoric/client-utils",
+  "version": "0.1.1-dev-02c06c4.0+02c06c4",
+  "description": "Utilities for building Agoric clients",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "src/main.js",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "build": "exit 0",
+    "prepack": "tsc --build tsconfig.build.json",
+    "postpack": "git clean -f '*.d.ts*' '*.tsbuildinfo'",
+    "test": "ava",
+    "test:c8": "c8 $C8_OPTIONS ava --config=ava-nesm.config.js",
+    "test:xs": "exit 0",
+    "lint-fix": "yarn lint:eslint --fix",
+    "lint": "run-s --continue-on-error lint:*",
+    "lint:types": "tsc",
+    "lint:eslint": "eslint ."
+  },
+  "devDependencies": {
+    "ava": "^5.3.0",
+    "c8": "^9.1.0",
+    "ts-blank-space": "^0.4.1"
+  },
+  "dependencies": {
+    "@agoric/casting": "0.4.3-dev-02c06c4.0+02c06c4",
+    "@agoric/ertp": "0.16.3-dev-02c06c4.0+02c06c4",
+    "@agoric/internal": "0.3.3-dev-02c06c4.0+02c06c4",
+    "@agoric/smart-wallet": "0.5.4-dev-02c06c4.0+02c06c4",
+    "@agoric/vats": "0.15.2-dev-02c06c4.0+02c06c4",
+    "@cosmjs/stargate": "^0.32.3",
+    "@cosmjs/tendermint-rpc": "^0.32.3",
+    "@endo/common": "^1.2.7",
+    "@endo/errors": "^1.2.7",
+    "@endo/marshal": "^1.6.1",
+    "@endo/pass-style": "^1.4.6",
+    "@endo/patterns": "^1.4.6",
+    "@endo/promise-kit": "^1.1.7"
+  },
+  "ava": {
+    "extensions": {
+      "js": true,
+      "ts": "module"
+    },
+    "files": [
+      "test/**/*.test.*"
+    ],
+    "nodeArguments": [
+      "--import=ts-blank-space/register",
+      "--no-warnings"
+    ],
+    "require": [
+      "@endo/init/legacy.js"
+    ],
+    "timeout": "20m"
+  },
+  "gitHead": "02c06c489677233c0daa112284d16c314aff97c6"
+}

package/src/chain.d.ts

@@ -0,0 +1,11 @@
+export function pollBlocks(opts: {
+    client: StargateClient;
+    delay: (ms: number) => Promise<void>;
+    period?: number;
+    retryMessage?: string;
+}): <T>(l: (b: {
+    time: string;
+    height: number;
+}) => Promise<T>) => Promise<T>;
+import type { StargateClient } from '@cosmjs/stargate';
+//# sourceMappingURL=chain.d.ts.map

package/src/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["chain.js"],"names":[],"mappings":"AAaO,iCARI;IACN,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GACS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CA2BrF;oCArCgC,kBAAkB"}

package/src/chain.js

@@ -0,0 +1,39 @@
+/**
+ * @import {StargateClient} from '@cosmjs/stargate';
+ */
+
+/**
+ * @param {{
+ *   client: StargateClient,
+ *   delay: (ms: number) => Promise<void>,
+ *   period?: number,
+ *   retryMessage?: string,
+ * }} opts
+ * @returns {<T>(l: (b: { time: string, height: number }) => Promise<T>) => Promise<T>}
+ */
+export const pollBlocks = opts => async lookup => {
+  const { client, delay, period = 3 * 1000 } = opts;
+  const { retryMessage } = opts;
+
+  await null; // separate sync prologue
+
+  for (;;) {
+    const status = await client.getBlock();
+    const {
+      header: { time, height },
+    } = status;
+    try {
+      // see await null above
+      const result = await lookup({ time, height });
+      return result;
+    } catch (_err) {
+      console.error(
+        time,
+        retryMessage || 'not in block',
+        height,
+        'retrying...',
+      );
+      await delay(period);
+    }
+  }
+};

package/src/main.d.ts

@@ -0,0 +1,5 @@
+export * from "./rpc.js";
+export * from "./sync-tools.js";
+export * from "./vstorage-kit.js";
+export * from "./wallet-utils.js";
+//# sourceMappingURL=main.d.ts.map

package/src/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["main.js"],"names":[],"mappings":""}

package/src/main.js

@@ -0,0 +1,4 @@
+export * from './rpc.js';
+export * from './sync-tools.js';
+export * from './vstorage-kit.js';
+export * from './wallet-utils.js';

package/src/rpc.d.ts

@@ -0,0 +1,16 @@
+export function pickEndpoint({ rpcAddrs }: {
+    rpcAddrs: any;
+}): any;
+export function makeTendermint34Client(endpoint: string, { fetch }: {
+    fetch: typeof window.fetch;
+}): Promise<Tendermint34Client>;
+export function makeStargateClient(config: MinimalNetworkConfig, { fetch }: {
+    fetch: typeof window.fetch;
+}): Promise<StargateClient>;
+export type MinimalNetworkConfig = {
+    rpcAddrs: string[];
+    chainName: string;
+};
+import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
+import { StargateClient } from '@cosmjs/stargate';
+//# sourceMappingURL=rpc.d.ts.map

package/src/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["rpc.js"],"names":[],"mappings":"AASO;;QAAkD;AAOlD,iDAJI,MAAM,aACN;IAAE,KAAK,EAAE,OAAO,MAAM,CAAC,KAAK,CAAA;CAAE,GAC5B,OAAO,CAAC,kBAAkB,CAAC,CAKvC;AAOM,2CAJI,oBAAoB,aACpB;IAAE,KAAK,EAAE,OAAO,MAAM,CAAC,KAAK,CAAA;CAAE,GAC5B,OAAO,CAAC,cAAc,CAAC,CAMnC;mCAzBY;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;mCAHnB,wBAAwB;+BAD5B,kBAAkB"}

package/src/rpc.js

@@ -0,0 +1,31 @@
+import { makeTendermintRpcClient } from '@agoric/casting';
+import { StargateClient } from '@cosmjs/stargate';
+import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
+
+/**
+ * @typedef {{ rpcAddrs: string[], chainName: string }} MinimalNetworkConfig
+ */
+
+// TODO distribute load
+export const pickEndpoint = ({ rpcAddrs }) => rpcAddrs[0];
+
+/**
+ * @param {string} endpoint
+ * @param {{ fetch: typeof window.fetch }} io
+ * @returns {Promise<Tendermint34Client>}
+ */
+export const makeTendermint34Client = (endpoint, { fetch }) => {
+  const rpcClient = makeTendermintRpcClient(endpoint, fetch);
+  return Tendermint34Client.create(rpcClient);
+};
+
+/**
+ * @param {MinimalNetworkConfig} config
+ * @param {{ fetch: typeof window.fetch }} io
+ * @returns {Promise<StargateClient>}
+ */
+export const makeStargateClient = async (config, { fetch }) => {
+  const url = pickEndpoint(config);
+  const tm = await makeTendermint34Client(url, { fetch });
+  return StargateClient.create(tm);
+};

package/src/sync-tools.d.ts

@@ -0,0 +1,43 @@
+export function sleep(ms: number, { log, setTimeout }: {
+    log: (message: string) => void;
+    setTimeout: typeof global.setTimeout;
+}): Promise<any>;
+export function retryUntilCondition(operation: () => Promise<any>, condition: (result: any) => boolean, message: string, { maxRetries, retryIntervalMs, log, setTimeout }: RetryOptions & {
+    log?: typeof console.log;
+    setTimeout: typeof global.setTimeout;
+}): Promise<any>;
+export function waitUntilContractDeployed(contractName: string, ambientAuthority: {
+    log: (message: string) => void;
+    follow: () => object;
+    setTimeout: typeof global.setTimeout;
+}, options: WaitUntilOptions): Promise<any>;
+export function waitUntilAccountFunded(destAcct: string, io: {
+    log: (message: string) => void;
+    query: () => Promise<object>;
+    setTimeout: typeof global.setTimeout;
+}, threshold: {
+    denom: string;
+    value: number;
+}, options: WaitUntilOptions): Promise<any>;
+export function waitUntilOfferResult(addr: string, offerId: string, waitForPayouts: boolean, io: {
+    log: typeof console.log;
+    follow: () => object;
+    setTimeout: typeof global.setTimeout;
+}, options: WaitUntilOptions): Promise<any>;
+export function waitUntilInvitationReceived(addr: string, io: {
+    follow: () => object;
+    log: typeof console.log;
+    setTimeout: typeof global.setTimeout;
+}, options: WaitUntilOptions): Promise<any>;
+export type RetryOptions = {
+    maxRetries?: number | undefined;
+    retryIntervalMs?: number | undefined;
+};
+export type WaitUntilOptions = RetryOptions & {
+    errorMessage: string;
+};
+export type CosmosBalanceThreshold = {
+    denom: string;
+    value: number;
+};
+//# sourceMappingURL=sync-tools.d.ts.map

package/src/sync-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-tools.d.ts","sourceRoot":"","sources":["sync-tools.js"],"names":[],"mappings":"AAgCO,0BAHI,MAAM,uBACN;IAAC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,UAAU,EAAE,OAAO,MAAM,CAAC,UAAU,CAAA;CAAC,gBAM7E;AAUG,+CALI,kBAAa,aACb,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,WACxB,MAAM,oDACN,YAAY,GAAG;IAAC,GAAG,CAAC,EAAE,OAAO,OAAO,CAAC,GAAG,CAAC;IAAC,UAAU,EAAE,OAAO,MAAM,CAAC,UAAU,CAAA;CAAC,gBAoCzF;AAiCM,wDAJI,MAAM,oBACN;IAAE,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,MAAM,CAAC,UAAU,CAAA;CAAE,WAC9F,gBAAgB,gBAkB1B;AA0BM,iDALI,MAAM,MACN;IAAE,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,UAAU,EAAE,OAAO,MAAM,CAAC,UAAU,CAAA;CAAC,aACrG;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,WAC9B,gBAAgB,gBAc1B;AAqCM,2CANI,MAAM,WACN,MAAM,kBACN,OAAO,MACP;IAAE,GAAG,EAAE,OAAO,OAAO,CAAC,GAAG,CAAC;IAAC,MAAM,EAAE,MAAM,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,MAAM,CAAC,UAAU,CAAA;CAAE,WACvF,gBAAgB,gBAoB1B;AAwBM,kDAJI,MAAM,MACN;IAAE,MAAM,EAAE,MAAM,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,OAAO,CAAC,GAAG,CAAC;IAAC,UAAU,EAAE,OAAO,MAAM,CAAC,UAAU,CAAA;CAAC,WACtF,gBAAgB,gBAc1B;;;;;+BA/OY,YAAY,GAAG;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC;;WAGpC,MAAM;WACN,MAAM"}

package/src/sync-tools.js

@@ -0,0 +1,259 @@
+/**
+ * @file The purpose of this file is to bring together a set of tools that
+ * developers can use to synchronize operations they carry out in their tests.
+ *
+ * These operations include;
+ * - Making sure a core-eval resulted in successfully deploying a contract
+ * - Making sure a core-eval successfully sent zoe invitations to committee members for governance
+ * - Making sure an account is successfully funded with vbank assets like IST, BLD etc.
+ *  - operation: query dest account's balance
+ *  - condition: dest account has a balance >= sent token
+ * - Making sure an offer resulted successfully
+ *
+ */
+
+/**
+ * @typedef {object} RetryOptions
+ * @property {number} [maxRetries]
+ * @property {number} [retryIntervalMs]
+ *
+ * @typedef {RetryOptions & {errorMessage: string}} WaitUntilOptions
+ *
+ * @typedef {object} CosmosBalanceThreshold
+ * @property {string} denom
+ * @property {number} value
+ */
+
+/**
+ * From https://github.com/Agoric/agoric-sdk/blob/442f07c8f0af03281b52b90e90c27131eef6f331/multichain-testing/tools/sleep.ts#L10
+ *
+ * @param {number} ms
+ * @param {{log: (message: string) => void, setTimeout: typeof global.setTimeout}} io
+ */
+export const sleep = (ms, { log = () => {}, setTimeout }) =>
+  new Promise(resolve => {
+    log(`Sleeping for ${ms}ms...`);
+    setTimeout(resolve, ms);
+  });
+
+/**
+ * From https://github.com/Agoric/agoric-sdk/blob/442f07c8f0af03281b52b90e90c27131eef6f331/multichain-testing/tools/sleep.ts#L24
+ *
+ * @param {() => Promise} operation
+ * @param {(result: any) => boolean} condition
+ * @param {string} message
+ * @param {RetryOptions & {log?: typeof console.log, setTimeout: typeof global.setTimeout}} options
+ */
+export const retryUntilCondition = async (
+  operation,
+  condition,
+  message,
+  { maxRetries = 6, retryIntervalMs = 3500, log = console.log, setTimeout },
+) => {
+  console.log({ maxRetries, retryIntervalMs, message });
+  let retries = 0;
+
+  await null; // separate sync prologue
+
+  while (retries < maxRetries) {
+    try {
+      const result = await operation();
+      log('RESULT', result);
+      if (condition(result)) {
+        return result;
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        log(`Error: ${error.message}`);
+      } else {
+        log(`Unknown error: ${String(error)}`);
+      }
+    }
+
+    retries += 1;
+    console.log(
+      `Retry ${retries}/${maxRetries} - Waiting for ${retryIntervalMs}ms for ${message}...`,
+    );
+    await sleep(retryIntervalMs, { log, setTimeout });
+  }
+
+  throw Error(`${message} condition failed after ${maxRetries} retries.`);
+};
+
+/**
+ * @param {WaitUntilOptions} options
+ */
+const overrideDefaultOptions = options => {
+  const defaultValues = {
+    maxRetries: 6,
+    retryIntervalMs: 3500,
+    log: console.log,
+    errorMessage: 'Error',
+  };
+
+  return { ...defaultValues, ...options };
+};
+
+/// ////////// Making sure a core-eval resulted successfully deploying a contract /////////////
+
+const makeGetInstances = follow => async () => {
+  const instanceEntries = await follow(
+    '-lF',
+    `:published.agoricNames.instance`,
+  );
+
+  return Object.fromEntries(instanceEntries);
+};
+
+/**
+ *
+ * @param {string} contractName
+ * @param {{ log: (message: string) => void, follow: () => object, setTimeout: typeof global.setTimeout }} ambientAuthority
+ * @param {WaitUntilOptions} options
+ */
+export const waitUntilContractDeployed = (
+  contractName,
+  ambientAuthority,
+  options,
+) => {
+  const { follow, setTimeout } = ambientAuthority;
+  const getInstances = makeGetInstances(follow);
+  const { maxRetries, retryIntervalMs, errorMessage, log } =
+    overrideDefaultOptions(options);
+
+  return retryUntilCondition(
+    getInstances,
+    instanceObject => Object.keys(instanceObject).includes(contractName),
+    errorMessage,
+    { maxRetries, retryIntervalMs, log, setTimeout },
+  );
+};
+
+/// ////////// Making sure an account is successfully funded with vbank assets like IST, BLD etc. ///////////////
+
+const makeQueryCosmosBalance = queryCb => async dest => {
+  const coins = await queryCb('bank', 'balances', dest);
+  return coins.balances;
+};
+
+/**
+ *
+ * @param {Array} balances
+ * @param {CosmosBalanceThreshold} threshold
+ * @returns {boolean}
+ */
+const checkCosmosBalance = (balances, threshold) => {
+  const balance = [...balances].find(({ denom }) => denom === threshold.denom);
+  return Number(balance.amount) >= threshold.value;
+};
+
+/**
+ * @param {string} destAcct
+ * @param {{ log: (message: string) => void, query: () => Promise<object>, setTimeout: typeof global.setTimeout}} io
+ * @param {{denom: string, value: number}} threshold
+ * @param {WaitUntilOptions} options
+ */
+export const waitUntilAccountFunded = (destAcct, io, threshold, options) => {
+  const { query, setTimeout } = io;
+  const queryCosmosBalance = makeQueryCosmosBalance(query);
+  const { maxRetries, retryIntervalMs, errorMessage, log } =
+    overrideDefaultOptions(options);
+
+  return retryUntilCondition(
+    async () => queryCosmosBalance(destAcct),
+    balances => checkCosmosBalance(balances, threshold),
+    errorMessage,
+    { maxRetries, retryIntervalMs, log, setTimeout },
+  );
+};
+
+/// ////////// Making sure an offers get results  /////////////
+
+const makeQueryWallet = follow => async (/** @type {string} */ addr) => {
+  const update = await follow('-lF', `:published.wallet.${addr}`);
+
+  return update;
+};
+
+/**
+ *
+ * @param {object} offerStatus
+ * @param {boolean} waitForPayouts
+ * @param {string} offerId
+ */
+const checkOfferState = (offerStatus, waitForPayouts, offerId) => {
+  const { updated, status } = offerStatus;
+
+  if (updated !== 'offerStatus') return false;
+  if (!status) return false;
+  if (status.id !== offerId) return false;
+  if (!status.numWantsSatisfied || status.numWantsSatisfied !== 1) return false;
+  if (waitForPayouts && status.payouts) return true;
+  if (!waitForPayouts && status.result) return true;
+
+  return false;
+};
+
+/**
+ *
+ * @param {string} addr
+ * @param {string} offerId
+ * @param {boolean} waitForPayouts
+ * @param {{ log: typeof console.log, follow: () => object, setTimeout: typeof global.setTimeout }} io
+ * @param {WaitUntilOptions} options
+ */
+export const waitUntilOfferResult = (
+  addr,
+  offerId,
+  waitForPayouts,
+  io,
+  options,
+) => {
+  const { follow, setTimeout } = io;
+  const queryWallet = makeQueryWallet(follow);
+  const { maxRetries, retryIntervalMs, errorMessage, log } =
+    overrideDefaultOptions(options);
+
+  return retryUntilCondition(
+    async () => queryWallet(addr),
+    status => checkOfferState(status, waitForPayouts, offerId),
+    errorMessage,
+    { maxRetries, retryIntervalMs, log, setTimeout },
+  );
+};
+
+/// ////////// Making sure a core-eval successfully sent zoe invitations to committee members for governance /////////////
+
+/**
+ *
+ * @param {{ updated: string, currentAmount: any }} update
+ * @returns {boolean}
+ */
+const checkForInvitation = update => {
+  const { updated, currentAmount } = update;
+
+  if (updated !== 'balance') return false;
+  if (!currentAmount || !currentAmount.brand) return false;
+
+  return currentAmount.brand.includes('Invitation');
+};
+
+/**
+ *
+ * @param {string} addr
+ * @param {{ follow: () => object, log: typeof console.log, setTimeout: typeof global.setTimeout}} io
+ * @param {WaitUntilOptions} options
+ */
+export const waitUntilInvitationReceived = (addr, io, options) => {
+  const { follow, setTimeout } = io;
+  const queryWallet = makeQueryWallet(follow);
+  const { maxRetries, retryIntervalMs, errorMessage, log } =
+    overrideDefaultOptions(options);
+
+  return retryUntilCondition(
+    async () => queryWallet(addr),
+    checkForInvitation,
+    errorMessage,
+    { maxRetries, retryIntervalMs, log, setTimeout },
+  );
+};

package/src/vstorage-kit.d.ts

@@ -0,0 +1,108 @@
+export { boardSlottingMarshaller };
+export function makeVStorage(powers: {
+    fetch: typeof window.fetch;
+}, config: MinimalNetworkConfig): {
+    url: (path?: string, { kind, height }?: {
+        kind?: string | undefined;
+        height?: number | undefined;
+    }) => string;
+    decode({ result: { response } }: {
+        result: {
+            response: any;
+        };
+    }): string;
+    /**
+     *
+     * @param {string} path
+     * @returns {Promise<string>} latest vstorage value at path
+     */
+    readLatest(path?: string): Promise<string>;
+    keys(path?: string): Promise<any>;
+    /**
+     * @param {string} path
+     * @param {number} [height] default is highest
+     * @returns {Promise<{blockHeight: number, values: string[]}>}
+     */
+    readAt(path: string, height?: number | undefined): Promise<{
+        blockHeight: number;
+        values: string[];
+    }>;
+    /**
+     * Read values going back as far as available
+     *
+     * @param {string} path
+     * @param {number | string} [minHeight]
+     * @returns {Promise<string[]>}
+     */
+    readFully(path: string, minHeight?: string | number | undefined): Promise<string[]>;
+};
+export function makeFromBoard(): {
+    convertSlotToVal: (boardId: any, iface: any) => any;
+};
+export namespace storageHelper {
+    function parseCapData(txt: string): {
+        blockHeight: any;
+        capDatas: {
+            body: string;
+            slots: string[];
+        }[];
+    };
+    function unserializeTxt(txt: string, ctx: IdMap): any[];
+    function parseMany(capDataStrings: string[]): {
+        body: string;
+        slots: string[];
+    }[];
+}
+export function makeAgoricNames(ctx: IdMap, vstorage: VStorage): Promise<import("@agoric/vats/tools/board-utils.js").AgoricNamesRemotes>;
+export function makeVstorageKit({ fetch }: {
+    fetch: typeof window.fetch;
+}, config: MinimalNetworkConfig): Promise<{
+    agoricNames: import("@agoric/vats/tools/board-utils.js").AgoricNamesRemotes;
+    fromBoard: {
+        convertSlotToVal: (boardId: any, iface: any) => any;
+    };
+    marshaller: Omit<import("@endo/marshal").Marshal<string | null>, "serialize" | "unserialize">;
+    readLatestHead: (path: string) => Promise<unknown>;
+    unserializeHead: (txt: string) => unknown;
+    vstorage: {
+        url: (path?: string, { kind, height }?: {
+            kind?: string | undefined;
+            height?: number | undefined;
+        }) => string;
+        decode({ result: { response } }: {
+            result: {
+                response: any;
+            };
+        }): string;
+        /**
+         *
+         * @param {string} path
+         * @returns {Promise<string>} latest vstorage value at path
+         */
+        readLatest(path?: string): Promise<string>;
+        keys(path?: string): Promise<any>;
+        /**
+         * @param {string} path
+         * @param {number} [height] default is highest
+         * @returns {Promise<{blockHeight: number, values: string[]}>}
+         */
+        readAt(path: string, height?: number | undefined): Promise<{
+            blockHeight: number;
+            values: string[];
+        }>;
+        /**
+         * Read values going back as far as available
+         *
+         * @param {string} path
+         * @param {number | string} [minHeight]
+         * @returns {Promise<string[]>}
+         */
+        readFully(path: string, minHeight?: string | number | undefined): Promise<string[]>;
+    };
+}>;
+export type VStorage = ReturnType<typeof makeVStorage>;
+export type IdMap = ReturnType<typeof makeFromBoard>;
+export type VstorageKit = Awaited<ReturnType<typeof makeVstorageKit>>;
+import { boardSlottingMarshaller } from '@agoric/vats/tools/board-utils.js';
+import type { MinimalNetworkConfig } from './rpc.js';
+//# sourceMappingURL=vstorage-kit.d.ts.map

package/src/vstorage-kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vstorage-kit.d.ts","sourceRoot":"","sources":["vstorage-kit.js"],"names":[],"mappings":";AAiBO,qCAHJ;IAAoC,KAAK,EAAjC,OAAO,MAAM,CAAC,KAAK;CAC3B,UAAQ,oBAAoB;;;;;;;;;;IA4C3B;;;;OAIG;sBAFQ,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC;;IAU5B;;;;OAIG;iBAHQ,MAAM,gCAEJ,OAAO,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC;IAS7D;;;;;;OAMG;oBAHQ,MAAM,4CAEJ,OAAO,CAAC,MAAM,EAAE,CAAC;EAuCjC;AAIM;;EAWN;;IAMe,2BADD,MAAM;;;kBAwBE,MAAM;mBAAS,MAAM,EAAE;;MAd3C;IAKe,6BAHL,MAAM,OACN,KAAK,SAOf;IAEU,mCADC,MAAM,EAAE;cAGC,MAAM;eAAS,MAAM,EAAE;QAS3C;;AAUI,qCAJI,KAAK,YACL,QAAQ,GACN,OAAO,CAAC,OAAO,mCAAmC,EAAE,kBAAkB,CAAC,CAoBnF;AAMM,2CAHI;IAAE,KAAK,EAAE,OAAO,MAAM,CAAC,KAAK,CAAA;CAAE,UAC9B,oBAAoB;;;;;;2BAiBV,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC;2BAN3B,MAAM,KAAK,OAAO;;;;;;;;;;;QArKnC;;;;WAIG;0BAFQ,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC;;QAU5B;;;;WAIG;qBAHQ,MAAM,gCAEJ,OAAO,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,EAAE,CAAA;SAAC,CAAC;QAS7D;;;;;;WAMG;wBAHQ,MAAM,4CAEJ,OAAO,CAAC,MAAM,EAAE,CAAC;;GA6JjC;uBArHa,UAAU,CAAC,OAAO,YAAY,CAAC;oBAe/B,UAAU,CAAC,OAAO,aAAa,CAAC;0BAuGhC,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;wCAnPlD,mCAAmC;0CAKH,UAAU"}

package/src/vstorage-kit.js

@@ -0,0 +1,248 @@
+/* global Buffer */
+import {
+  boardSlottingMarshaller,
+  makeBoardRemote,
+} from '@agoric/vats/tools/board-utils.js';
+
+export { boardSlottingMarshaller };
+
+/**
+ * @import {MinimalNetworkConfig} from './rpc.js';
+ */
+
+/**
+ * @param {object} powers
+ * @param {typeof window.fetch} powers.fetch
+ * @param {MinimalNetworkConfig} config
+ */
+export const makeVStorage = (powers, config) => {
+  /** @param {string} path */
+  const getJSON = path => {
+    const url = config.rpcAddrs[0] + path;
+    // console.warn('fetching', url);
+    return powers.fetch(url, { keepalive: true }).then(res => res.json());
+  };
+  // height=0 is the same as omitting height and implies the highest block
+  const url = (path = 'published', { kind = 'children', height = 0 } = {}) =>
+    `/abci_query?path=%22/custom/vstorage/${kind}/${path}%22&height=${height}`;
+
+  const readStorage = (path = 'published', { kind = 'children', height = 0 }) =>
+    getJSON(url(path, { kind, height }))
+      .catch(err => {
+        throw Error(`cannot read ${kind} of ${path}: ${err.message}`);
+      })
+      .then(data => {
+        const {
+          result: { response },
+        } = data;
+        if (response?.code !== 0) {
+          /** @type {any} */
+          const err = Error(
+            `error code ${response?.code} reading ${kind} of ${path}: ${response.log}`,
+          );
+          err.code = response?.code;
+          err.codespace = response?.codespace;
+          throw err;
+        }
+        return data;
+      });
+
+  return {
+    url,
+    decode({ result: { response } }) {
+      const { code } = response;
+      if (code !== 0) {
+        throw response;
+      }
+      const { value } = response;
+      return Buffer.from(value, 'base64').toString();
+    },
+    /**
+     *
+     * @param {string} path
+     * @returns {Promise<string>} latest vstorage value at path
+     */
+    async readLatest(path = 'published') {
+      const raw = await readStorage(path, { kind: 'data' });
+      return this.decode(raw);
+    },
+    async keys(path = 'published') {
+      const raw = await readStorage(path, { kind: 'children' });
+      return JSON.parse(this.decode(raw)).children;
+    },
+    /**
+     * @param {string} path
+     * @param {number} [height] default is highest
+     * @returns {Promise<{blockHeight: number, values: string[]}>}
+     */
+    async readAt(path, height = undefined) {
+      const raw = await readStorage(path, { kind: 'data', height });
+      const txt = this.decode(raw);
+      /** @type {{ value: string }} */
+      const { value } = JSON.parse(txt);
+      return JSON.parse(value);
+    },
+    /**
+     * Read values going back as far as available
+     *
+     * @param {string} path
+     * @param {number | string} [minHeight]
+     * @returns {Promise<string[]>}
+     */
+    async readFully(path, minHeight = undefined) {
+      const parts = [];
+      // undefined the first iteration, to query at the highest
+      let blockHeight;
+      await null;
+      do {
+        // console.debug('READING', { blockHeight });
+        let values;
+        try {
+          ({ blockHeight, values } = await this.readAt(
+            path,
+            blockHeight && Number(blockHeight) - 1,
+          ));
+          // console.debug('readAt returned', { blockHeight });
+        } catch (err) {
+          if (
+            // CosmosSDK ErrInvalidRequest with particular message text;
+            // misrepresentation of pruned data
+            // TODO replace after incorporating a fix to
+            // https://github.com/cosmos/cosmos-sdk/issues/19992
+            err.codespace === 'sdk' &&
+            err.code === 18 &&
+            err.message.match(/pruned/)
+          ) {
+            // console.error(err);
+            break;
+          }
+          throw err;
+        }
+        parts.push(values);
+        // console.debug('PUSHED', values);
+        // console.debug('NEW', { blockHeight, minHeight });
+        if (minHeight && Number(blockHeight) <= Number(minHeight)) break;
+      } while (blockHeight > 0);
+      return parts.flat();
+    },
+  };
+};
+/** @typedef {ReturnType<typeof makeVStorage>} VStorage */
+
+/** @deprecated */
+export const makeFromBoard = () => {
+  const cache = new Map();
+  const convertSlotToVal = (boardId, iface) => {
+    if (cache.has(boardId)) {
+      return cache.get(boardId);
+    }
+    const val = makeBoardRemote({ boardId, iface });
+    cache.set(boardId, val);
+    return val;
+  };
+  return harden({ convertSlotToVal });
+};
+/** @typedef {ReturnType<typeof makeFromBoard>} IdMap */
+
+/** @deprecated */
+export const storageHelper = {
+  /** @param { string } txt */
+  parseCapData: txt => {
+    assert(typeof txt === 'string', typeof txt);
+    /** @type {{ value: string }} */
+    const { value } = JSON.parse(txt);
+    const specimen = JSON.parse(value);
+    const { blockHeight, values } = specimen;
+    assert(values, `empty values in specimen ${value}`);
+    const capDatas = storageHelper.parseMany(values);
+    return { blockHeight, capDatas };
+  },
+  /**
+   * @param {string} txt
+   * @param {IdMap} ctx
+   */
+  unserializeTxt: (txt, ctx) => {
+    const { capDatas } = storageHelper.parseCapData(txt);
+    return capDatas.map(capData =>
+      boardSlottingMarshaller(ctx.convertSlotToVal).fromCapData(capData),
+    );
+  },
+  /** @param {string[]} capDataStrings array of stringified capData */
+  parseMany: capDataStrings => {
+    assert(capDataStrings && capDataStrings.length);
+    /** @type {{ body: string, slots: string[] }[]} */
+    const capDatas = capDataStrings.map(s => JSON.parse(s));
+    for (const capData of capDatas) {
+      assert(typeof capData === 'object' && capData !== null);
+      assert('body' in capData && 'slots' in capData);
+      assert(typeof capData.body === 'string');
+      assert(Array.isArray(capData.slots));
+    }
+    return capDatas;
+  },
+};
+harden(storageHelper);
+
+/**
+ * @deprecated
+ * @param {IdMap} ctx
+ * @param {VStorage} vstorage
+ * @returns {Promise<import('@agoric/vats/tools/board-utils.js').AgoricNamesRemotes>}
+ */
+export const makeAgoricNames = async (ctx, vstorage) => {
+  const reverse = {};
+  const entries = await Promise.all(
+    ['brand', 'instance', 'vbankAsset'].map(async kind => {
+      const content = await vstorage.readLatest(
+        `published.agoricNames.${kind}`,
+      );
+      /** @type {Array<[string, import('@agoric/vats/tools/board-utils.js').BoardRemote]>} */
+      const parts = storageHelper.unserializeTxt(content, ctx).at(-1);
+      for (const [name, remote] of parts) {
+        if ('getBoardId' in remote) {
+          reverse[remote.getBoardId()] = name;
+        }
+      }
+      return [kind, Object.fromEntries(parts)];
+    }),
+  );
+  return { ...Object.fromEntries(entries), reverse };
+};
+
+/**
+ * @param {{ fetch: typeof window.fetch }} io
+ * @param {MinimalNetworkConfig} config
+ */
+export const makeVstorageKit = async ({ fetch }, config) => {
+  await null;
+  try {
+    const vstorage = makeVStorage({ fetch }, config);
+    const fromBoard = makeFromBoard();
+    const agoricNames = await makeAgoricNames(fromBoard, vstorage);
+
+    const marshaller = boardSlottingMarshaller(fromBoard.convertSlotToVal);
+
+    /** @type {(txt: string) => unknown} */
+    const unserializeHead = txt =>
+      storageHelper.unserializeTxt(txt, fromBoard).at(-1);
+
+    /**
+     * Read latest at path and unmarshal it
+     * @type {(path: string) => Promise<unknown>}
+     */
+    const readLatestHead = path =>
+      vstorage.readLatest(path).then(unserializeHead);
+
+    return {
+      agoricNames,
+      fromBoard,
+      marshaller,
+      readLatestHead,
+      unserializeHead,
+      vstorage,
+    };
+  } catch (err) {
+    throw Error(`RPC failure (${config.rpcAddrs}): ${err.message}`);
+  }
+};
+/** @typedef {Awaited<ReturnType<typeof makeVstorageKit>>} VstorageKit */

package/src/wallet-utils.d.ts

@@ -0,0 +1,49 @@
+export function makeWalletUtils({ fetch, delay }: {
+    fetch: typeof globalThis.fetch;
+    delay: (ms: number) => Promise<void>;
+}, networkConfig: MinimalNetworkConfig): Promise<{
+    networkConfig: MinimalNetworkConfig;
+    agoricNames: import("@agoric/vats/tools/board-utils.js").AgoricNamesRemotes;
+    fromBoard: {
+        convertSlotToVal: (boardId: any, iface: any) => any;
+    };
+    marshaller: Omit<import("@endo/marshal").Marshal<string | null>, "serialize" | "unserialize">;
+    vstorage: {
+        url: (path?: string, { kind, height }?: {
+            kind?: string | undefined;
+            height?: number | undefined;
+        }) => string;
+        decode({ result: { response } }: {
+            result: {
+                response: any;
+            };
+        }): string;
+        readLatest(path?: string): Promise<string>;
+        keys(path?: string): Promise<any>;
+        readAt(path: string, height?: number | undefined): Promise<{
+            blockHeight: number;
+            values: string[];
+        }>;
+        readFully(path: string, minHeight?: string | number | undefined): Promise<string[]>;
+    };
+    getLastUpdate: (addr: string) => Promise<UpdateRecord>;
+    getCurrentWalletRecord: (addr: string) => Promise<CurrentWalletRecord>;
+    readLatestHead: (path: string) => Promise<unknown>;
+    storedWalletState: (from: string, minHeight?: string | number | undefined) => Promise<{
+        invitationsReceived: Map<import("@agoric/smart-wallet/src/offers.js").OfferId, {
+            acceptedIn: import("@agoric/smart-wallet/src/offers.js").OfferId;
+            description: string;
+            instance: Instance;
+        }>;
+        offerStatuses: Map<import("@agoric/smart-wallet/src/offers.js").OfferId, import("@agoric/smart-wallet/src/offers.js").OfferStatus>;
+        balances: Map<Brand, Amount>;
+    }>;
+    pollOffer: (from: string, id: string | number, minHeight: number | string, untilNumWantsSatisfied?: boolean | undefined) => Promise<import("@agoric/smart-wallet/src/offers.js").OfferStatus>;
+}>;
+export type WalletUtils = Awaited<ReturnType<typeof makeWalletUtils>>;
+import type { MinimalNetworkConfig } from './rpc.js';
+import type { UpdateRecord } from '@agoric/smart-wallet/src/smartWallet.js';
+import type { CurrentWalletRecord } from '@agoric/smart-wallet/src/smartWallet.js';
+import type { Brand } from '@agoric/ertp/src/types.js';
+import type { Amount } from '@agoric/ertp/src/types.js';
+//# sourceMappingURL=wallet-utils.d.ts.map

package/src/wallet-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-utils.d.ts","sourceRoot":"","sources":["wallet-utils.js"],"names":[],"mappings":"AAkBO,kDAJJ;IAAuC,KAAK,EAApC,OAAO,UAAU,CAAC,KAAK;IACc,KAAK,EAA1C,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC;CACrC,iBAAQ,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;0BAoElB,MAAM,KACJ,OAAO,CAAC,YAAY,CAAC;mCASvB,MAAM,KACJ,OAAO,CAAC,mBAAmB,CAAC;;8BArE9B,MAAM;;;;;;;;;sBA2BN,MAAM,MACN,MAAM,GAAC,MAAM,aACb,MAAM,GAAC,MAAM;GA4DzB;0BACa,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;0CA5GlB,UAAU;kCADG,yCAAyC;yCAAzC,yCAAyC;2BAD7D,2BAA2B;4BAA3B,2BAA2B"}

package/src/wallet-utils.js

@@ -0,0 +1,117 @@
+import { makeWalletStateCoalescer } from '@agoric/smart-wallet/src/utils.js';
+import { pollBlocks } from './chain.js';
+import { makeStargateClient } from './rpc.js';
+import { boardSlottingMarshaller, makeVstorageKit } from './vstorage-kit.js';
+
+/**
+ * @import {Amount, Brand} from '@agoric/ertp/src/types.js'
+ * @import {CurrentWalletRecord, UpdateRecord} from '@agoric/smart-wallet/src/smartWallet.js';
+ * @import {MinimalNetworkConfig} from './rpc.js';
+ */
+
+/**
+ *
+ * @param {object} root0
+ * @param {typeof globalThis.fetch} root0.fetch
+ * @param {(ms: number) => Promise<void>} root0.delay
+ * @param {MinimalNetworkConfig} networkConfig
+ */
+export const makeWalletUtils = async ({ fetch, delay }, networkConfig) => {
+  const { agoricNames, fromBoard, marshaller, readLatestHead, vstorage } =
+    await makeVstorageKit({ fetch }, networkConfig);
+  const m = boardSlottingMarshaller(fromBoard.convertSlotToVal);
+
+  const client = await makeStargateClient(networkConfig, { fetch });
+
+  /**
+   * @param {string} from
+   * @param {number|string} [minHeight]
+   */
+  const storedWalletState = async (from, minHeight = undefined) => {
+    const history = await vstorage.readFully(
+      `published.wallet.${from}`,
+      minHeight,
+    );
+
+    /** @type {{ Invitation: Brand<'set'> }} */
+    // @ts-expect-error XXX how to narrow AssetKind to set?
+    const { Invitation } = agoricNames.brand;
+    const coalescer = makeWalletStateCoalescer(Invitation);
+    // update with oldest first
+    for (const txt of history.reverse()) {
+      const { body, slots } = JSON.parse(txt);
+      const record = m.fromCapData({ body, slots });
+      coalescer.update(record);
+    }
+    const coalesced = coalescer.state;
+    harden(coalesced);
+    return coalesced;
+  };
+
+  /**
+   * Get OfferStatus by id, polling until available.
+   *
+   * @param {string} from
+   * @param {string|number} id
+   * @param {number|string} minHeight
+   * @param {boolean} [untilNumWantsSatisfied]
+   */
+  const pollOffer = async (
+    from,
+    id,
+    minHeight,
+    untilNumWantsSatisfied = false,
+  ) => {
+    const poll = pollBlocks({
+      client,
+      delay,
+      retryMessage: 'offer not in wallet at block',
+    });
+
+    const lookup = async () => {
+      const { offerStatuses } = await storedWalletState(from, minHeight);
+      const offerStatus = [...offerStatuses.values()].find(s => s.id === id);
+      if (!offerStatus) throw Error('retry');
+      harden(offerStatus);
+      if (untilNumWantsSatisfied && !('numWantsSatisfied' in offerStatus)) {
+        throw Error('retry (no numWantsSatisfied yet)');
+      }
+      return offerStatus;
+    };
+    return poll(lookup);
+  };
+
+  /**
+   * @param {string} addr
+   * @returns {Promise<UpdateRecord>}
+   */
+  const getLastUpdate = addr => {
+    return /** @type {Promise<UpdateRecord>} */ (
+      readLatestHead(`published.wallet.${addr}`)
+    );
+  };
+
+  /**
+   * @param {string} addr
+   * @returns {Promise<CurrentWalletRecord>}
+   */
+  const getCurrentWalletRecord = addr => {
+    return /** @type {Promise<CurrentWalletRecord>} */ (
+      readLatestHead(`published.wallet.${addr}.current`)
+    );
+  };
+
+  return {
+    networkConfig,
+    agoricNames,
+    fromBoard,
+    marshaller,
+    vstorage,
+    getLastUpdate,
+    getCurrentWalletRecord,
+    readLatestHead,
+    storedWalletState,
+    pollOffer,
+  };
+};
+/** @typedef {Awaited<ReturnType<typeof makeWalletUtils>>} WalletUtils */