feat: add the permit-generator github action

.github/workflows/permit-generator.yml

@@ -0,0 +1,47 @@
+name: Permit Generator
+
+on:
+  workflow_dispatch:
+    inputs:
+      users_amounts:
+        description: "A JSON array containing usernames and associated amounts"
+        required: true
+        # example: '[{"user1": 100}, {"user2": 150}]'
+
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    permissions: write-all
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20.10.0"
+
+      - name: Process permit requests
+        id: parse
+        run: |
+          echo "Received input: ${{ github.event.inputs.users_amounts }}"
+          npx tsx scripts/github-action-permit-generator.ts permits.txt
+        shell: bash
+        env:
+          X25519_PRIVATE_KEY: ${{ secrets.X25519_PRIVATE_KEY }}
+          EVM_NETWORK_ID: ${{ secrets.EVM_NETWORK_ID }}
+          EVM_PRIVATE_KEY: ${{ secrets.EVM_PRIVATE_KEY }}
+          EVM_TOKEN_ADDRESS: ${{ secrets.EVM_TOKEN_ADDRESS }}
+          SUPABASE_URL: ${{ secrets.SUPABASE_URL}}
+          SUPABASE_KEY: ${{ secrets.SUPABASE_KEY }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          USERS_AMOUNTS: ${{ github.event.inputs.users_amounts }}
+
+      - name: Report by opening an issue
+        run: |
+          export PERMITS=$(cat permits.txt)
+          curl -X POST \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            -H "Content-Type: application/json" \
+            -d "{\"title\": \"Workflow Dispatch Report\", \"body\": \"$PERMITS\"}" \
+            "https://api.github.com/repos/${{ github.repository }}/issues"

scripts/github-action-permit-generator.ts

@@ -0,0 +1,116 @@
+import * as github from "@actions/github";
+import { Octokit } from "@octokit/rest";
+import { createClient } from "@supabase/supabase-js";
+import { createAdapters } from "../src/adapters";
+import { Database } from "../src/adapters/supabase/types/database";
+import { generatePayoutPermit } from "../src/handlers";
+import { Context } from "../src/types/context";
+import { PermitGenerationSettings, PermitRequest } from "../src/types/plugin-input";
+import { Value } from "@sinclair/typebox/value";
+import { envSchema } from "../src/types/env";
+import * as fs from "fs";
+
+/**
+ * Generates all the permits based on the current github workflow dispatch.
+ */
+export async function generatePermitsFromGithubWorkflowDispatch() {
+  const runId = github.context.runId;
+
+  // These are necessary to ensure the type checks and tests pass.
+  process.env["NFT_MINTER_PRIVATE_KEY"] = "";
+  process.env["NFT_CONTRACT_ADDRESS"] = "";
+  const env = Value.Decode(envSchema, process.env);
+
+  if (!env.EVM_NETWORK_ID) {
+    throw new Error("EVM_NETWORK_ID env not provided or empty");
+  }
+  if (!env.EVM_PRIVATE_KEY) {
+    throw new Error("EVM_PRIVATE_KEY env not provided or empty");
+  }
+  if (!env.EVM_TOKEN_ADDRESS) {
+    throw new Error("EVM_TOKEN_ADDRESS env not provided or empty");
+  }
+  if (!env.USERS_AMOUNTS) {
+    throw new Error("USERS_AMOUNTS env not provided or empty");
+  }
+
+  console.log(`Received: ${env.USERS_AMOUNTS}`);
+  const userAmounts = JSON.parse(env.USERS_AMOUNTS);
+
+  // Populate the permitRequests from the user_amounts payload
+
+  const permitRequests: PermitRequest[] = userAmounts.flatMap((userObj: { [key: string]: number }) =>
+    Object.entries(userObj).map(([user, amount]) => ({
+      type: "ERC20",
+      username: user,
+      amount: amount,
+      contributionType: "custom",
+      tokenAddress: env.EVM_TOKEN_ADDRESS,
+    }))
+  );
+
+  const config: PermitGenerationSettings = {
+    evmNetworkId: Number(env.EVM_NETWORK_ID),
+    evmPrivateEncrypted: env.EVM_PRIVATE_KEY,
+    permitRequests: permitRequests,
+    runId: runId,
+  };
+
+  const octokit = new Octokit({ auth: env.GITHUB_TOKEN });
+  const supabaseClient = createClient<Database>(env.SUPABASE_URL, env.SUPABASE_KEY);
+
+  const context: Context = {
+    eventName: "workflow_dispatch",
+    config: config,
+    octokit,
+    payload: userAmounts,
+    env,
+    logger: {
+      debug(message: unknown, ...optionalParams: unknown[]) {
+        console.debug(message, ...optionalParams);
+      },
+      info(message: unknown, ...optionalParams: unknown[]) {
+        console.log(message, ...optionalParams);
+      },
+      warn(message: unknown, ...optionalParams: unknown[]) {
+        console.warn(message, ...optionalParams);
+      },
+      error(message: unknown, ...optionalParams: unknown[]) {
+        console.error(message, ...optionalParams);
+      },
+      fatal(message: unknown, ...optionalParams: unknown[]) {
+        console.error(message, ...optionalParams);
+      },
+    },
+    adapters: {} as ReturnType<typeof createAdapters>,
+  };
+
+  context.adapters = createAdapters(supabaseClient, context);
+
+  const permits = await generatePayoutPermit(context, config.permitRequests);
+  await returnDataToKernel(env.GITHUB_TOKEN, "todo_state", permits);
+  const out = Buffer.from(JSON.stringify(permits)).toString("base64");
+  fs.writeFile(process.argv[2], out, (err) => {
+    if (err) {
+      throw err;
+    }
+  });
+}
+
+async function returnDataToKernel(repoToken: string, stateId: string, output: object) {
+  const octokit = new Octokit({ auth: repoToken });
+  await octokit.repos.createDispatchEvent({
+    owner: github.context.repo.owner,
+    repo: github.context.repo.repo,
+    event_type: "return_data_to_ubiquibot_kernel",
+    client_payload: {
+      state_id: stateId,
+      output: JSON.stringify(output),
+    },
+  });
+}
+generatePermitsFromGithubWorkflowDispatch()
+  .then((result) => console.log(`result: ${result}`))
+  .catch((error) => {
+    console.error(error);
+  });

src/adapters/supabase/helpers/wallet.ts

@@ -15,8 +15,11 @@ export class Wallet extends Super {
       throw error;
     }
 
-    console.info("Successfully fetched wallet", { userId, address: data.wallets?.address });
-    return data.wallets?.address;
+    // Check if wallets is an array, if so, return the first element's address
+    const address = Array.isArray(data.wallets) ? data.wallets[0]?.address : data.wallets?.address;
+
+    console.info("Successfully fetched wallet", { userId, address: address });
+    return address;
   }
 
   async upsertWallet(userId: number, address: string) {

src/handlers/generate-erc20-permit.ts

@@ -54,6 +54,8 @@ export async function generateErc20PermitSignature(
       issueNodeId = contextOrPayload.payload.issue.node_id;
     } else if ("pull_request" in contextOrPayload.payload) {
       issueNodeId = contextOrPayload.payload.pull_request.node_id;
+    } else if (contextOrPayload.config.runId) {
+      issueNodeId = contextOrPayload.config.runId.toString();
     } else {
       throw new Error("Issue Id is missing");
     }

src/types/env.ts

@@ -8,6 +8,10 @@ export const envSchema = T.Object({
   SUPABASE_KEY: T.String(),
   NFT_MINTER_PRIVATE_KEY: T.String(),
   NFT_CONTRACT_ADDRESS: T.String(),
+  EVM_NETWORK_ID: T.Optional(T.String()),
+  EVM_PRIVATE_KEY: T.Optional(T.String()),
+  EVM_TOKEN_ADDRESS: T.Optional(T.String()),
+  USERS_AMOUNTS: T.Optional(T.String()),
 });
 
 export type Env = StaticDecode<typeof envSchema>;

src/types/plugin-input.ts

@@ -25,6 +25,7 @@ export const permitGenerationSettingsSchema = T.Object({
   evmNetworkId: T.Number(),
   evmPrivateEncrypted: T.String(),
   permitRequests: T.Array(permitRequestSchema),
+  runId: T.Optional(T.Number()),
 });
 
 export type PermitGenerationSettings = StaticDecode<typeof permitGenerationSettingsSchema>;