Execute via Mech + Pilot

.eslintrc.json

@@ -29,8 +29,7 @@
         ],
         "arrow-body-style": 0,
         "import/extensions": 0,
-        "no-unused-vars": 0, // disable for now lots of these too
-        "no-use-before-define": 1,
+        "no-unused-vars": 0, // disable for now lots of these too        
         "import/prefer-default-export": 0,
         "import/no-unresolved": 0,
         "no-restricted-syntax": 0,

package.json

@@ -34,7 +34,6 @@
   "author": "anon",
   "license": "LGPL-3.0-or-later",
   "devDependencies": {
-    "@graphql-tools/utils": "^9.2.1",
     "@release-it/conventional-changelog": "^7.0.0",
     "@types/level-js": "4.0.2",
     "@types/leveldown": "4.0.3",
@@ -60,19 +59,21 @@
     "typescript": "5.1.6"
   },
   "dependencies": {
+    "@gnosis-guild/zodiac-core": "^3.0.0",
     "@libp2p/interface": "1.3.0",
-    "@railgun-community/cookbook": "2.10.3",
+    "@railgun-community/cookbook": "2.12.0",
     "@railgun-community/curve25519-scalarmult-rsjs": "0.2.4",
     "@railgun-community/poseidon-hash-rsjs": "1.0.1",
-    "@railgun-community/shared-models": "7.6.1",
-    "@railgun-community/waku-broadcaster-client-node": "8.2.7",
-    "@railgun-community/wallet": "10.4.1",
+    "@railgun-community/shared-models": "8.0.0",
+    "@railgun-community/waku-broadcaster-client-node": "8.4.0",
+    "@railgun-community/wallet": "10.8.0",
     "bn": "1.0.5",
     "colors": "^1.4.0",
     "enquirer": "2.3.6",
     "ethers": "6.13.1",
     "level-js": "6.1.0",
     "leveldown": "6.1.1",
+    "open": "10.2.0",
     "snarkjs": "0.7.0"
   },
   "packageManager": "yarn@1.22.19"

src/balance/balance-util.ts

@@ -140,6 +140,7 @@ export const getPrivateERC20BalancesForChain = (
     return [];
   }
   const erc20Addresses = Object.keys(cache);
+
   const balances: RailgunDisplayBalance[] = [];
   erc20Addresses.map(async (tokenAddress) => {
     const { name, symbol, decimals } = await getTokenInfo(
@@ -185,8 +186,10 @@ export const getDisplayStringFromBalance = (
   return balanceDisplayString;
 };
 
-export const getPrivateDisplayBalances = async (chainName: NetworkName, bucketType: RailgunWalletBalanceBucket) => {
-
+export const getPrivateDisplayBalances = async (
+  chainName: NetworkName,
+  bucketType: RailgunWalletBalanceBucket,
+) => {
   const CHAIN_NAME = configDefaults.networkConfig[chainName].name.toUpperCase();
   const display: string[] = [];
 
@@ -195,18 +198,19 @@ export const getPrivateDisplayBalances = async (chainName: NetworkName, bucketTy
     ? await getPrivateERC20BalancesForChain(chainName, bucketType)
     : await getPublicERC20BalancesForChain(chainName, true);
 
-
-  if(bucketType !== RailgunWalletBalanceBucket.Spendable){
-    if(balances.length === 0){
-      return ""
+  if (bucketType !== RailgunWalletBalanceBucket.Spendable) {
+    if (balances.length === 0) {
+      return "";
     }
-    if(!isPrivate){
+    if (!isPrivate) {
       // if not private, only show set of balances once. dont add header.
-      return ""
+      return "";
     }
   }
   const balanceType = isPrivate ? "PRIVATE" : "PUBLIC";
-  const header = `${CHAIN_NAME.green} ${ isPrivate ? bucketType.green : ''} ${balanceType} BALANCES`;
+  const header = `${CHAIN_NAME.green} ${
+    isPrivate ? bucketType.green : ""
+  } ${balanceType} BALANCES`;
   const headLen = stripColors(header).length;
   display.push("");
   const headerLine = `${header}`;

src/engine/engine.ts

@@ -36,9 +36,11 @@ export const isEngineRunning = () => {
 };
 
 const interceptLog = {
-  log: (log: string) => { },
+  log: (log: string) => {
+    console.log(log);
+  },
   error: (err: any) => {
-    console.log(err.message);
+    console.log(err);
   },
 };
 
@@ -197,8 +199,9 @@ export const getProviderPromptOptions = (chainName: NetworkName) => {
       const providerEnabled = customProviders[provider];
       return {
         name: provider,
-        message: `[${providerEnabled ? "Enabled ".green.dim : "Disabled".yellow.dim
-          }] ${provider}`,
+        message: `[${
+          providerEnabled ? "Enabled ".green.dim : "Disabled".yellow.dim
+        }] ${provider}`,
       };
     });
 

src/mech/deployments.ts

@@ -0,0 +1,52 @@
+import {
+  RailgunProxyContract,
+  RelayAdaptContract,
+} from "@railgun-community/shared-models";
+
+import { getCurrentNetwork } from "../engine/engine";
+import configDefaults from "../config/config-defaults";
+
+import { encodeMechCreate, predictMechAddress } from "./encode";
+
+// universal addresses:
+const erc6551Factory = "0x000000006551c19487814612e58fe06813775758";
+const mechMastercopy = "0xc62046fbbcf02725949afeab16dcf75f5066e2bb";
+const railgunNeuralLink = "0xd53c76d176c45f93bd86da63842abbc6d467c3ea";
+
+function chainId() {
+  const { chainId } = configDefaults.networkConfig[getCurrentNetwork()];
+  return chainId;
+}
+
+export default {
+  railgunSmartWallet: () => ({
+    address: RailgunProxyContract[getCurrentNetwork()].toLowerCase(),
+  }),
+  relayAdapt: () => ({
+    address: RelayAdaptContract[getCurrentNetwork()].toLowerCase(),
+  }),
+  railgunNeuralLink: railgunNeuralLink as `0x${string}`,
+  mech: (tokenId: bigint) => ({
+    address: predictMechAddress({
+      factory: erc6551Factory,
+      chainId: chainId(),
+      mastercopy: mechMastercopy,
+      tokenAddress: railgunNeuralLink,
+      tokenId,
+    }) as `0x${string}`,
+    tokenAddress: railgunNeuralLink as `0x${string}`,
+    tokenId,
+  }),
+};
+
+export function mechDeploymentTx(tokenId: bigint) {
+  return {
+    to: erc6551Factory,
+    data: encodeMechCreate({
+      mastercopy: mechMastercopy,
+      chainId: chainId(),
+      tokenAddress: railgunNeuralLink,
+      tokenId,
+    }),
+  };
+}

src/mech/encode.ts

@@ -0,0 +1,116 @@
+import {
+  AbiCoder,
+  concat,
+  getCreate2Address,
+  Interface,
+  keccak256,
+  ZeroHash,
+} from "ethers";
+
+const MECH_SALT =
+  "0x0000000000000000000000000000000000000000000000000000000000000bad";
+
+export function encodeMechCreate({
+  mastercopy,
+  chainId,
+  tokenAddress,
+  tokenId,
+}: {
+  mastercopy: string;
+  chainId: number | bigint;
+  tokenAddress: string;
+  tokenId: bigint;
+}) {
+  const iface = new Interface([
+    "function createAccount(address implementation, bytes32 salt, uint256 chainId, address tokenContract, uint256 tokenId) returns (address)",
+  ]);
+
+  return iface.encodeFunctionData("createAccount", [
+    mastercopy,
+    MECH_SALT,
+    chainId,
+    tokenAddress,
+    tokenId,
+  ]);
+}
+
+export function predictMechAddress({
+  factory,
+  chainId,
+  mastercopy,
+  tokenAddress,
+  tokenId,
+}: {
+  factory: string;
+  chainId: number;
+  mastercopy: string;
+  tokenAddress: string;
+  tokenId: bigint;
+}): string {
+  const eip6551ProxyCreationBytecode = concat([
+    "0x3d60ad80600a3d3981f3363d3d373d3d3d363d73",
+    mastercopy,
+    "0x5af43d82803e903d91602b57fd5bf3",
+    AbiCoder.defaultAbiCoder().encode(
+      ["bytes32", "uint256", "address", "uint256"],
+      [MECH_SALT, chainId, tokenAddress, tokenId],
+    ),
+  ]);
+  return getCreate2Address(
+    factory,
+    MECH_SALT,
+    keccak256(eip6551ProxyCreationBytecode),
+  );
+}
+
+export function encodeMechExecute({
+  to,
+  value,
+  data,
+  operation,
+}: {
+  to: string;
+  value?: string | bigint | number | undefined | null;
+  data: string;
+  operation?: number;
+}) {
+  const iface = new Interface([
+    "function execute(address to, uint256 value, bytes calldata data, uint8 operation) public payable returns (bytes memory returnData)",
+  ]);
+  return iface.encodeFunctionData("execute", [
+    to,
+    BigInt(value || 0),
+    data,
+    operation || 0,
+  ]);
+}
+
+export function encodeMint() {
+  const iface = new Interface(["function mint() external"]);
+
+  return iface.encodeFunctionData("mint");
+}
+
+export function encodeTranfer(to: string, amount: bigint | number) {
+  const iface = new Interface([
+    "function transfer(address to, uint256 amount)",
+  ]);
+
+  return iface.encodeFunctionData("transfer", [to, amount]);
+}
+
+export function encodeTranferFrom(from: string, to: string, tokenId: bigint) {
+  const iface = new Interface([
+    "function transferFrom(address from, address to, uint256 tokenId)",
+  ]);
+
+  return iface.encodeFunctionData("transferFrom", [from, to, tokenId]);
+}
+
+export function encodeApprove(to: string, tokenId: bigint) {
+  const iface = new Interface([
+    "function approve(address to, uint256 tokenId)",
+  ]);
+
+  return iface.encodeFunctionData("approve", [to, tokenId]);
+}