Fix mutation parameters when using Zod

packages/data-facade/src/facade.ts

@@ -32,11 +32,11 @@ function handlerQueryBuilder<TResolver extends ResolverFunc>(
 
 function buildUseMutation() {
   return <TResolver extends ResolverFunc>(resolver: TResolver) => ({
-    useMutation: (opts?: UseMutationOptions<Awaited<ReturnType<TResolver>>, Error, unknown, unknown>) => {
+    useMutation: (opts?: UseMutationOptions<Awaited<ReturnType<TResolver>>, Error, Parameters<TResolver>[0], unknown>) => {
       return useMutation<
         Awaited<ReturnType<TResolver>>,
         Error,
-        unknown,
+        Parameters<TResolver>[0],
         unknown
       >({
         ...opts,

packages/data-facade/src/types.ts

@@ -35,7 +35,9 @@ export type HandlerQueryBuilderReturn<TResolver extends ResolverFunc> = (
 type UseMutationType<
   TResolver extends ResolverFunc,
   TReturn = Awaited<ReturnType<TResolver>>,
-> = (opts?: UseMutationOptions<TReturn, Error, unknown, unknown>) => UseMutationResult<TReturn>;
+> = Parameters<TResolver>["length"] extends 0
+  ? (opts?: UseMutationOptions<TReturn, Error, null | undefined, unknown>) => UseMutationResult<TReturn>
+  : (opts?: UseMutationOptions<TReturn, Error, Parameters<TResolver>[0], unknown>) => UseMutationResult<TReturn>
 
 export type HandlerMutationBuilderReturn<TResolver extends ResolverFunc> =
   () => {

packages/ironfish-native-module/android/src/main/java/expo/modules/ironfishnativemodule/IronfishNativeModule.kt

@@ -1,7 +1,9 @@
 package expo.modules.ironfishnativemodule
 
+import expo.modules.kotlin.records.Field
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.records.Record
 
 class ExpoKey(
   @Field
@@ -28,7 +30,7 @@ class IronfishNativeModule : Module() {
     // The module will be accessible from `requireNativeModule('IronfishNativeModule')` in JavaScript.
     Name("IronfishNativeModule")
 
-    AsyncFunction("generateKey") { ->
+    Function("generateKey") { ->
       val k = uniffi.rust_lib.generateKey()
 
       ExpoKey(
@@ -41,25 +43,15 @@ class IronfishNativeModule : Module() {
       )
     }
 
-    Function("spendingKeyToWords") { privateKey: String, languageCode: Long ->
-      try {
-        return spendingKeyToWords(privateKey: privateKey, languageCode: languageCode)
-      } catch (error: Exception) {
-        error.printStackTrace()
-        throw error
-      }
+    Function("spendingKeyToWords") { privateKey: String, languageCode: Int ->
+      uniffi.rust_lib.spendingKeyToWords(privateKey, languageCode)
     }
 
-    Function("wordsToSpendingKey") { words: String, languageCode: Long ->
-      try {
-        return wordsToSpendingKey(words: words, languageCode: languageCode)
-      } catch (error: Exception) {
-        error.printStackTrace()
-        throw error
-      }
+    Function("wordsToSpendingKey") { words: String, languageCode: Int ->
+      uniffi.rust_lib.wordsToSpendingKey(words, languageCode)
     }
 
-    AsyncFunction("generateKeyFromPrivateKey") { privateKey: String ->
+    Function("generateKeyFromPrivateKey") { privateKey: String ->
       val k = uniffi.rust_lib.generateKeyFromPrivateKey(privateKey)
 
       ExpoKey(
@@ -73,12 +65,7 @@ class IronfishNativeModule : Module() {
     }
 
     Function("isValidPublicAddress") { hexAddress: String ->
-      try {
-        uniffi.rust_lib.isValidPublicAddress(hexAddress: hexAddress)
-      } catch (error: Exception) {
-        error.printStackTrace()
-        throw error
-      }
+      uniffi.rust_lib.isValidPublicAddress(hexAddress)
     }
   }
 }

packages/mobile-app/app/(tabs)/transact.tsx

@@ -2,6 +2,8 @@ import { View, Text, ScrollView, TextInput } from "react-native";
 import { useFacade } from "../../data/facades";
 import { Button } from "@ironfish/ui";
 import { useQueryClient } from "@tanstack/react-query";
+import React from "react";
+import { AccountFormat } from "@ironfish/sdk";
 
 export default function Transact() {
   const facade = useFacade();
@@ -15,8 +17,24 @@ export default function Transact() {
       })
     }
   });
+  const importAccount = facade.importAccount.useMutation({
+    onSuccess: () => {
+      qc.invalidateQueries({
+        queryKey: ['getAccounts']
+      })
+    }
+  });
+  const removeAccount = facade.removeAccount.useMutation({
+    onSuccess: () => {
+      qc.invalidateQueries({
+        queryKey: ['getAccounts']
+      })
+    }
+  });
   const exportAccount = facade.exportAccount.useMutation();
 
+  const [importAccountText, setImportAccountText] = React.useState('')
+
   return (
     <ScrollView>
       <Text>Accounts</Text>
@@ -25,7 +43,15 @@ export default function Transact() {
           <Text>{account.name}</Text>
           <Button
             onClick={async () => {
-              const otherResult = await exportAccount.mutateAsync({ name: account.name });
+              await removeAccount.mutateAsync({ name: account.name });
+              console.log('Removed Account', account.name)
+            }}
+          >
+          Remove Account
+          </Button>
+          <Button
+            onClick={async () => {
+              const otherResult = await exportAccount.mutateAsync({ name: account.name, format: AccountFormat.Base64Json });
               console.log('Exported Account:', otherResult)
             }}
           >
@@ -41,6 +67,15 @@ export default function Transact() {
       >
         Create Account
       </Button>
+      <TextInput value={importAccountText} onChangeText={setImportAccountText} placeholder="Import account"/>
+      <Button
+        onClick={async () => {
+          const otherResult = await importAccount.mutateAsync({ account: importAccountText });
+          console.log('Imported Account:', otherResult)
+        }}
+      >
+        Import Account
+      </Button>
     </ScrollView>
   );
 }

packages/mobile-app/data/facades/accounts/demoHandlers.ts

@@ -1,6 +1,7 @@
 import { f } from "data-facade";
 import { z } from "zod";
 import { AccountsMethods } from "./types";
+import { AccountFormat, LanguageKey } from "@ironfish/sdk";
 
 let ACCOUNTS = [
   { id: 0, name: "alice", viewOnlyAccount: "alice" },
@@ -14,11 +15,6 @@ async function getAccounts(limit: number) {
 }
 
 export const accountsHandlers = f.facade<AccountsMethods>({
-  getAccounts: f.handler.query(async () => {
-    const accounts = await getAccounts(ACCOUNTS.length);
-    console.log("getAccounts", accounts);
-    return accounts;
-  }),
   createAccount: f.handler
     .input(
       z.object({
@@ -35,17 +31,70 @@ export const accountsHandlers = f.facade<AccountsMethods>({
       ACCOUNTS.push(account);
       return account;
     }),
+  // The enums used when exporting are tricky to use with Zod 
   exportAccount: f.handler
+    .mutation(async ({ name }: { name: string, format: AccountFormat, language?: LanguageKey, viewOnly?: boolean }) => {
+      const account = ACCOUNTS.find((a) => a.name === name)
+      if (account === undefined) {
+        throw new Error(`No account found with name ${name}`);
+      }
+      return JSON.stringify(account);
+    }),
+  getAccount: f.handler.input(
+    z.object({
+      name: z.string(),
+    }),
+  ).query(async ({ name }) => {
+    const account = ACCOUNTS.find((a) => a.name === name);
+    if (account === undefined) {
+      throw new Error(`No account found with name ${name}`);
+    }
+    return account
+  }),
+  getAccounts: f.handler.query(async () => {
+      const accounts = await getAccounts(ACCOUNTS.length);
+      console.log("getAccounts", accounts);
+      return accounts;
+    }),
+  importAccount: f.handler
     .input(
       z.object({
+        account: z.string(),
         name: z.string(),
       }),
     )
-    .mutation(async ({ name }) => {
-      const account = ACCOUNTS.find((a) => a.name === name)
-      if (account === undefined) {
+    .mutation(async ({ account, name }) => {
+      const existingId = ACCOUNTS.at(-1)?.id
+      if (existingId === undefined) {
         throw new Error("No accounts found");
       }
-      return JSON.stringify(account);
+      const importedAccount = { id: existingId + 1, name, viewOnlyAccount: account }
+      console.log("createAccount", account);
+      ACCOUNTS.push(importedAccount);
+      return importedAccount;
+    }),
+  removeAccount: f.handler
+    .input(
+      z.object({
+        name: z.string(),
+      }),
+    )
+    .mutation(async ({ name }) => {
+      const accountIndex = ACCOUNTS.findIndex((a) => a.name === name);
+      ACCOUNTS.splice(accountIndex, 1);
+    }),
+  renameAccount: f.handler
+    .input(
+      z.object({
+        name: z.string(),
+        newName: z.string(),
+      }),
+    )
+    .mutation(async ({ name, newName }) => {
+      const account = ACCOUNTS.find((a) => a.name === name);
+      if (!account) {
+        throw new Error("No account found");
+      }
+      account.name = newName;
     }),
 });