fix: #60, Check if preimage exists on chain before creating a proposal

.eslintrc.js

@@ -1,3 +1,8 @@
 const { getConfiguration } = require("opstooling-js-style/src/eslint/configuration");
 
-module.exports = getConfiguration({ typescript: { rootDir: __dirname } });
+const conf = getConfiguration({ typescript: { rootDir: __dirname } });
+
+conf.overrides[0].rules["@typescript-eslint/no-misused-promises"] = "off";
+conf.overrides[0].rules["no-async-promise-executor"] = "off";
+
+module.exports = conf;

README.md

@@ -70,7 +70,14 @@ There are semi-automatic integration tests that execute the tip functions agains
 | Local Kusama   | `docker run --rm -p 9901:9901 parity/polkadot:v0.9.39 --chain=kusama-dev --tmp --alice --execution Native --ws-port 9901 --ws-external --force-kusama` |
 | Local Polkadot | `docker run --rm -p 9900:9900 parity/polkadot:v0.9.39 --chain=dev --tmp --alice --execution Native --ws-port 9900 --ws-external` |
 
-Note that the node needs to have the OpenGov features - Kusama development chain can be used for that (`--chain=kusama-dev`).
+Notes: 
+- the node needs to have the OpenGov features - Kusama development chain can be used for that (`--chain=kusama-dev`).
+- on macos apple silicon chip, you might see error `docker: no matching manifest for linux/arm64/v8 in the manifest list entries.`, 
+  in this case 
+  - close docker desktop, 
+  - open terminal in Rosetta. 
+  - run `open /Applications/Docker.app`
+  - add `--platform linux/amd64` flag to docker run command after `--rm`
 
 With that, run the tests:
 

package.json

@@ -22,9 +22,9 @@
     "test": "NODE_OPTIONS='--experimental-vm-modules --es-module-specifier-resolution=node' jest"
   },
   "dependencies": {
-    "@polkadot/api": "^10.3.2",
-    "@polkadot/util": "^11.0.1",
-    "@polkadot/util-crypto": "^11.0.1",
+    "@polkadot/api": "^10.7.1",
+    "@polkadot/util": "^12.2.1",
+    "@polkadot/util-crypto": "^12.2.1",
     "opstooling-integrations": "https://github.com/paritytech/opstooling-integrations#v2.0.0",
     "opstooling-js": "https://github.com/paritytech/opstooling-js#v0.0.14",
     "probot": "^12.2.8",

src/tip-opengov.ts

@@ -2,11 +2,13 @@ import "@polkadot/api-augment";
 import "@polkadot/types-augment";
 import { ApiPromise } from "@polkadot/api";
 import { KeyringPair } from "@polkadot/keyring/types";
+import { ISubmittableResult } from "@polkadot/types/types";
 import { blake2AsHex } from "@polkadot/util-crypto";
 import assert from "assert";
+import { Probot } from "probot";
 
 import { getChainConfig, getTipUrl } from "./chain-config";
-import { State, TipRequest, TipResult } from "./types";
+import { ContributorAccount, State, TipRequest, TipResult } from "./types";
 import { formatReason, tipSizeToOpenGovTrack } from "./util";
 
 export async function tipOpenGov(opts: {
@@ -29,40 +31,75 @@ export async function tipOpenGov(opts: {
   if ("error" in track) {
     return { success: false, errorMessage: track.error };
   }
+  const contributorAddress = contributor.account.address;
 
   const proposalTx = api.tx.utility.batch([
     api.tx.system.remark(formatReason(tipRequest)),
-    api.tx.treasury.spend(track.value.toString(), contributor.account.address),
+    api.tx.treasury.spend(track.value.toString(), contributorAddress),
   ]);
   const encodedProposal = proposalTx.method.toHex();
   const proposalHash = blake2AsHex(encodedProposal);
+  const encodedLength = Math.ceil((encodedProposal.length - 2) / 2);
 
-  const preimage_unsub = await api.tx.preimage
-    .notePreimage(encodedProposal)
-    .signAndSend(botTipAccount, { nonce: -1 }, (result) => {
-      if (result.status.isInBlock) {
-        bot.log(`Preimage Upload included at blockHash ${result.status.asInBlock.toString()}`);
-      } else if (result.status.isFinalized) {
-        bot.log(`Preimage Upload finalized at blockHash ${result.status.asFinalized.toString()}`);
-        preimage_unsub();
-      }
-    });
+  console.log(`encodedLength: ${encodedLength}`);
 
-  const referenda_unsub = await api.tx.referenda
-    .submit(
-      // TODO: There should be a way to set those types properly.
-      { Origins: track.track } as any, // eslint-disable-line
-      { Lookup: { hash: proposalHash, length: proposalTx.length - 1 } },
-      { after: 10 } as any, // eslint-disable-line
-    )
-    .signAndSend(botTipAccount, { nonce: -1 }, (result) => {
-      if (result.status.isInBlock) {
-        bot.log(`Tip referendum included at blockHash ${result.status.asInBlock.toString()}`);
-      } else if (result.status.isFinalized) {
-        bot.log(`Tip referendum finalized at blockHash ${result.status.asFinalized.toString()}`);
-        referenda_unsub();
-      }
-    });
+  return await new Promise(async (resolve, reject) => {
+    // create a preimage from opengov with the encodedProposal above
+    const preimageUnsubscribe = await api.tx.preimage
+      .notePreimage(encodedProposal)
+      .signAndSend(botTipAccount, { nonce: -1 }, async (result) => {
+        await signAndSendCallback(bot, contributor.account, "preimage", preimageUnsubscribe, result)
+          .then(async () => {
+            const readPreimage = await api.query.preimage.statusFor(proposalHash);
 
-  return { success: true, tipUrl: getTipUrl(contributor.account.network) };
+            if (readPreimage.isEmpty) {
+              reject(new Error(`Preimage for ${proposalHash} was not found, check if the bot has enough funds.`));
+            }
+
+            const proposalUnsubscribe = await api.tx.referenda
+              .submit(
+                // TODO: There should be a way to set those types properly.
+                { Origins: track.track } as never,
+                { Lookup: { hash: proposalHash, length: proposalTx.length - 1 } },
+                { after: 10 } as never,
+              )
+              .signAndSend(botTipAccount, { nonce: -1 }, async (refResult) => {
+                await signAndSendCallback(bot, contributor.account, "referendum", proposalUnsubscribe, refResult)
+                  .then(resolve)
+                  .catch(reject);
+              });
+          })
+          .catch(reject);
+      });
+  });
+}
+
+async function signAndSendCallback(
+  bot: Probot,
+  contributor: ContributorAccount,
+  type: "preimage" | "referendum",
+  unsubscribe: () => void,
+  result: ISubmittableResult,
+): Promise<TipResult> {
+  return await new Promise((resolve, reject) => {
+    if (result.status.isInBlock) {
+      bot.log(`${type} for ${contributor.address} included at blockHash ${result.status.asInBlock.toString()}`);
+    } else if (result.status.isFinalized) {
+      bot.log(`Tip for ${contributor.address} ${type} finalized at blockHash ${result.status.asFinalized.toString()}`);
+      unsubscribe();
+      resolve({ success: true, tipUrl: getTipUrl(contributor.network) });
+    } else if (
+      result.status.isDropped ||
+      result.status.isInvalid ||
+      result.status.isUsurped ||
+      result.status.isRetracted ||
+      result.status.isBroadcast
+    ) {
+      const msg = `Tip for ${contributor.address} ${type} status is 👎: ${result.status.type}`;
+      bot.log(msg, result.status);
+      reject({ success: false, errorMessage: msg });
+    } else {
+      bot.log(`Tip for ${contributor.address} ${type} status: ${result.status.type}`, result.status);
+    }
+  });
 }

src/types.ts

@@ -49,4 +49,4 @@ export type TipRequest = {
   };
 };
 
-export type TipResult = { success: true; tipUrl: string } | { success: false; errorMessage?: string | undefined };
+export type TipResult = { success: true; tipUrl: string } | { success: false; errorMessage?: string };