Agoric offer signer endo maker

packages/ag-trade/Makefile

@@ -0,0 +1,143 @@
+STATE=$(shell endo where state)
+PET=$(STATE)/pet-store
+
+where:
+	@echo state: $(STATE)
+
+bid-list: $(PET)/gov1-view
+
+$(PET)/gov1-view: $(PET)/query-tool
+	endo eval "E(hub).walletView('agoric1acfcen6peh9ed9tyrj5wyqtfrf7hthrh5smddy')" \
+	  hub:query-tool -n gov1-view
+
+reserve-add: $(PET)/reserve-tool $(PET)/user1-kit $(PET)/u1-ist
+	@echo ++ Add to reserve
+	endo eval "E(reserve).addToReserve(kit.smartWallet, \
+	  { brand, value: 7_000_000n }, 'add2')" \
+	  reserve:reserve-tool kit:user1-kit brand:u1-ist
+
+$(PET)/u1-ist: $(PET)/user1-kit
+	@echo ++ look up IST in user1 marshal context
+	endo eval "E(kit.query).lookup('agoricNames', 'brand', 'IST')" -n u1-ist kit:user1-kit
+
+$(PET)/reserve-tool: src/reserve-add.js
+	@echo ++ instantiate reserve add tool
+	endo make src/reserve-add.js -n reserve-tool
+
+kit: $(PET)/user1-kit
+
+$(PET)/user1-kit: $(PET)/desktop-secrets $(PET)/wallet-factory $(PET)/cosmos-fetch
+	@echo ++ Instantiate SigningStargetClient for user1
+	endo eval "\
+	  (async () => { \
+	    const passKey = E(secrets).makePassKey({ username: 'user1' }); \
+	    const mnemonic = await E(passKey).get(); \
+		const rpc = E(net).makeRPCClient('http://localhost:26657'); \
+		const lcd = E(net).makeLCDClient('http://localhost:1317'); \
+	    return E(wf).makeWalletKit(mnemonic, rpc, lcd); \
+	  })()" \
+		secrets:desktop-secrets wf:wallet-factory net:cosmos-fetch \
+		-n user1-kit
+
+$(PET)/wallet-factory: src/smartWallet.js
+	@echo ++ start smart wallet caplet -- TODO: should not need UNSAFE
+	endo make --UNSAFE src/smartWallet.js -n wallet-factory
+
+$(PET)/cosmos-fetch: src/cosmosFetch.js
+	@echo ++ install cosmos fetch plugin
+	endo make --UNSAFE src/cosmosFetch.js -n cosmos-fetch
+
+
+get-brand: $(PET)/ist-brand
+
+$(PET)/ist-brand: $(PET)/query-tool
+	@echo ++ Get IST brand
+	endo eval "E(hub).lookup('agoricNames', 'brand', 'IST')" hub:query-tool -n ist-brand
+
+$(PET)/query-tool: $(PET)/client-maker
+	@echo ++ Instantiate QueryTool
+	endo eval "E(mkClient).makeQueryTool('http://localhost:1317')" mkClient:client-maker -n query-tool
+
+send-tokens: $(PET)/validator-client
+	@echo ++ Send tokens
+	endo eval "E(client).sendTokens(\
+	  'agoric14pfrxg63jn6ha0cp6wxkm4nlvswtscrh2pymwm', \
+	  'agoric1a3zu5aqw255q0tuxzy9aftvgheekw2wedz3xwq', \
+	  [{ denom: 'ubld', amount: '12345' }], 'auto').then( \
+	  tx => tx.code === 0 ? tx.transactionHash : assert.fail(tx.rawLog))" client:validator-client
+
+$(PET)/validator-client: $(PET)/validator-passkey $(PET)/client-maker  $(PET)/cosmos-fetch
+	@echo ++ Instantiate SigningStargetClient
+	endo eval "E(key).get().then( \
+	  m => E(mkClient).makeTxTool( \
+		m, E(net).makeRPCClient('http://localhost:26657')))" \
+		mkClient:client-maker key:validator-passkey net:cosmos-fetch \
+		-n validator-client
+
+$(PET)/validator-signer: $(PET)/signer-maker $(PET)/validator-passkey
+	endo eval "E(key).get().then(m => E(mkSign).fromMnemonic(m))" mkSign:signer-maker key:validator-passkey -n validator-signer
+
+$(PET)/client-maker: src/smartWallet.js
+	@echo ++ make endo plugin for SigningStargetClient
+	endo make --UNSAFE src/smartWallet.js -n client-maker
+
+$(PET)/signer-maker: src/hdWallet.js
+	@echo ++ make endo plugin for hd wallets
+	endo make --UNSAFE src/hdWallet.js -n signer-maker
+
+$(PET)/validator-passkey: $(PET)/desktop-secrets
+	endo eval "E(secrets).makePassKey({ username: 'validator' })" -n validator-passkey secrets:desktop-secrets
+
+sync: $(PET)/synctool $(PET)/gcdb $(PET)/finsync
+	@echo ++ Push GnuCash transation ids to Sheetsync
+	endo eval "E(synctool).pushTxIds(sc, gc)" synctool gc:gcdb sc:finsync
+
+$(PET)/synctool: src/txSync.js
+	@echo ++ instantiate confined sync tool
+	endo make src/txSync.js -n synctool
+
+db: $(PET)/gdcb
+
+watchdl: $(PET)/watchdl
+
+$(PET)/watchdl: $(PET)/fsevents
+	@echo ++ make watcher for ~/Downloads
+	endo eval "'$${HOME}/Downloads'" -n dl
+	endo eval "E(fsevents).subWatcher(dl)" -n watchdl dl fsevents
+
+$(PET)/fsevents: src/fileWatcher.js
+	@echo ++ make endo plugin for file watcher
+	endo make --UNSAFE src/fileWatcher.js -n fsevents
+
+$(PET)/gcdb: $(PET)/hub1
+	@echo ++ Choose a sqlite3 database file path
+	endo eval "'$${GNUCASH_DB}'" -n p1
+	@echo ++ look up the path in the DBHub
+	endo eval "E(hub).lookup(path)" hub:hub1 path:p1 -n gcdb
+
+$(PET)/hub1: ./src/dbTool.js
+	@echo ++ Instantiate sqlite3 database hub plugin
+	endo make -n hub1 --UNSAFE ./src/dbTool.js
+
+sheet: $(PET)/finsync
+
+$(PET)/finsync: $(PET)/fin-sync-creds $(PET)/gsheets
+	@echo ++ Load a spreadsheet based on item from desktop secret store.
+	endo eval "E(gsheets).load(item)" -n finsync gsheets item:fin-sync-creds
+
+$(PET)/gsheets: src/sheetsTool.js
+	@echo ++ make endo plugin for Google Sheets
+	endo make --UNSAFE src/sheetsTool.js -n gsheets
+
+$(PET)/fin-sync-creds: $(PET)/desktop-secrets
+	@echo ++ make a PassKey to access finSync Google Sheet
+	@echo ++ Assumes: secret-tool store --label='finSync' id 1-66j... title finSync \<project-id-661....json
+	endo eval "'$${SHEET1_ID}'" -n finsync-id
+	endo eval "E(secrets).makePassKey({ title: 'finSync', id })" -n fin-sync-creds secrets:desktop-secrets id:finsync-id
+
+$(PET)/desktop-secrets: ../fincaps/src/secret-tool.js
+	@echo ++ make endo plugin for desktop secrets
+	endo make -n desktop-secrets --UNSAFE ../fincaps/src/secret-tool.js
+
+clean:
+	endo reset

packages/ag-trade/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "ag-trace",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "lint-fix": "eslint --fix .",
+    "lint": "run-s --continue-on-error lint:*",
+    "lint:js": "eslint .",
+    "lint:types": "tsc -p jsconfig.json"
+  },
+  "devDependencies": {
+    "@agoric/smart-wallet": "^0.5.4-u12.0",
+    "@endo/cli": "/home/connolly/projects/endo/packages/cli",
+    "@fast-check/ava": "^1.1.5",
+    "@types/google-spreadsheet": "^4.0.0",
+    "ava": "^5.3.1",
+    "eslint": "^8.36.0",
+    "npm-run-all": "^4.1.5",
+    "typescript": "~5.1.6"
+  },
+  "ava": {
+    "files": [
+      "**/test-*.js"
+    ]
+  },
+  "dependencies": {
+    "@agoric/cosmic-proto": "^0.3.0",
+    "@cosmjs/amino": "^0.31.3",
+    "@cosmjs/crypto": "^0.31.3",
+    "@cosmjs/encoding": "^0.31.3",
+    "@cosmjs/proto-signing": "^0.31.3",
+    "@cosmjs/stargate": "^0.31.3",
+    "@cosmjs/tendermint-rpc": "^0.31.3",
+    "@endo/far": "^0.2.21",
+    "@endo/patterns": "^0.2.5",
+    "better-sqlite3": "^8.5.2",
+    "google-auth-library": "^9.0.0",
+    "google-spreadsheet": "^4.0.2",
+    "minimatch": "^9.0.3",
+    "watcher": "^2.3.0"
+  }
+}

packages/ag-trade/src/agoricZone.js

@@ -0,0 +1,32 @@
+// @ts-check
+import { MsgWalletSpendAction } from '@agoric/cosmic-proto/swingset/msgs.js';
+
+import { Registry } from '@cosmjs/proto-signing';
+import { GasPrice, defaultRegistryTypes } from '@cosmjs/stargate';
+
+// https://github.com/Agoric/agoric-sdk/blob/master/golang/cosmos/daemon/main.go
+export const Bech32MainPrefix = 'agoric';
+
+export const CoinType = 564;
+
+/**
+ * `/agoric.swingset.XXX` matches package agoric.swingset in swingset/msgs.proto
+ * aminoType taken from Type() in golang/cosmos/x/swingset/types/msgs.go
+ */
+export const SwingsetMsgs = {
+  MsgWalletSpendAction: {
+    typeUrl: '/agoric.swingset.MsgWalletSpendAction',
+    aminoType: 'swingset/WalletSpendAction',
+  },
+};
+
+export const SwingsetRegistry = new Registry([
+  ...defaultRegistryTypes,
+  // XXX should this list be "upstreamed" to @agoric/cosmic-proto?
+  [SwingsetMsgs.MsgWalletSpendAction.typeUrl, MsgWalletSpendAction],
+]);
+
+// https://community.agoric.com/t/network-change-instituting-fees-on-the-agoric-chain-to-mitigate-spam-transactions/109/2
+// minimum-gas-prices = "0.01ubld,0.005uist"
+export const gasPriceStake = GasPrice.fromString('0.01ubld');
+export const gasPriceStable = GasPrice.fromString('0.005uist');

packages/ag-trade/src/batchQuery.js

@@ -0,0 +1,175 @@
+// @ts-check
+import { E } from '@endo/far';
+
+/** @typedef {'children' | 'data'} AgoricChainStoragePathKind */
+/** @template T @typedef {import('@endo/marshal').FromCapData<T>} FromCapData<T> */
+/** @template T @typedef {import('@endo/eventual-send').ERef<T>} ERef<T> */
+
+/**
+ * @param {[kind: AgoricChainStoragePathKind, item: string]} path
+ */
+export const pathToKey = path => path.join('.');
+
+/** @param {string} key */
+export const keyToPath = key => {
+  const [kind, ...rest] = key.split('.');
+  assert(kind === 'children' || kind === 'data');
+  /** @type {[kind: 'children' | 'data', item: string]} */
+  const out = [kind, rest.join('.')];
+};
+
+/**
+ * @template T
+ * @param {(value: string) => T} f
+ * @param {AsyncGenerator<string[], void, unknown>} chunks
+ */
+async function* mapHistory(f, chunks) {
+  for await (const chunk of chunks) {
+    if (chunk === undefined) continue;
+    for (const value of chunk.reverse()) {
+      yield f(value);
+    }
+  }
+}
+
+/**
+ * @param {ERef<import('./httpClient').LCD>} lcd
+ */
+export const makeVStorage = lcd => {
+  const getJSON = (href, options) => E(lcd).getJSON(href, options);
+
+  // height=0 is the same as omitting height and implies the highest block
+  const href = (path = 'published', { kind = 'data' } = {}) =>
+    `/agoric/vstorage/${kind}/${path}`;
+  const headers = height =>
+    height ? { 'x-cosmos-block-height': `${height}` } : undefined;
+
+  const readStorage = (
+    path = 'published',
+    { kind = 'data', height = 0 } = {},
+  ) =>
+    getJSON(href(path, { kind }), { headers: headers(height) }).catch(err => {
+      throw Error(`cannot read ${kind} of ${path}: ${err.message}`);
+    });
+  const readCell = (path, opts) =>
+    readStorage(path, opts)
+      .then(data => data.value)
+      .then(s => (s === '' ? {} : JSON.parse(s)));
+
+  /**
+   * Read values going back as far as available
+   *
+   * @param {string} path
+   * @param {number | string} [minHeight]
+   */
+  async function* readHistory(path, minHeight = undefined) {
+    // undefined the first iteration, to query at the highest
+    let blockHeight;
+    await null;
+    do {
+      // console.debug('READING', { blockHeight });
+      /** @type {string[]} */
+      let values = [];
+      try {
+        ({ blockHeight, values } = await readCell(path, {
+          kind: 'data',
+          height: blockHeight && Number(blockHeight) - 1,
+        }));
+        // console.debug('readAt returned', { blockHeight });
+      } catch (err) {
+        if (err.message.match(/unknown request/)) {
+          // XXX FIXME
+          // console.error(err);
+          break;
+        }
+        throw err;
+      }
+      yield values;
+      // console.debug('PUSHED', values);
+      // console.debug('NEW', { blockHeight, minHeight });
+      if (minHeight && Number(blockHeight) <= Number(minHeight)) break;
+    } while (blockHeight > 0);
+  }
+
+  /**
+   * @template T
+   * @param {(value: string) => T} f
+   * @param {string} path
+   * @param {number | string} [minHeight]
+   */
+  const readHistoryBy = (f, path, minHeight) =>
+    mapHistory(f, readHistory(path, minHeight));
+
+  return {
+    lcd,
+    readStorage,
+    readCell,
+    readHistory,
+    readHistoryBy,
+  };
+};
+
+/** @typedef {ReturnType<typeof makeVStorage>} VStorage */
+
+/** @param {string | unknown} d */
+const parseIfJSON = d => {
+  if (typeof d !== 'string') return d;
+  try {
+    return JSON.parse(d);
+  } catch {
+    return d;
+  }
+};
+
+/**
+ * @param {ReturnType<makeVStorage>} vstorage
+ * @param {FromCapData<string>} unmarshal
+ * @param {[AgoricChainStoragePathKind, string][]} paths
+ */
+export const batchVstorageQuery = async (vstorage, unmarshal, paths) => {
+  const requests = paths.map(([kind, path]) =>
+    vstorage.readStorage(path, { kind }),
+  );
+
+  return Promise.all(requests).then(responses =>
+    responses.map((res, index) => {
+      if (paths[index][0] === 'children') {
+        return [
+          pathToKey(paths[index]),
+          { value: res.children, blockHeight: undefined },
+        ];
+      }
+
+      if (!res.value) {
+        return [
+          pathToKey(paths[index]),
+          {
+            error: `Cannot parse value of response for path [${
+              paths[index]
+            }]: ${JSON.stringify(res)}`,
+          },
+        ];
+      }
+
+      const data = parseIfJSON(res.value);
+
+      const latestValue =
+        typeof data.values !== 'undefined'
+          ? parseIfJSON(data.values[data.values.length - 1])
+          : parseIfJSON(data.value);
+
+      const unserialized =
+        typeof latestValue.slots !== 'undefined'
+          ? unmarshal(latestValue)
+          : latestValue;
+
+      return [
+        pathToKey(paths[index]),
+        {
+          blockHeight: data.blockHeight,
+          value: unserialized,
+        },
+      ];
+    }),
+  );
+};