Adds Owner Invoker (#106)

* Adds Owner Invoker

* invoker test

Author: sungoki

programs/smart-wallet/src/lib.rs

@@ -275,6 +275,36 @@ pub mod smart_wallet {
         ]];
         do_execute_transaction(ctx, wallet_seeds)
     }
+
+    /// Invokes an arbitrary instruction as a PDA derived from the owner,
+    /// i.e. as an "Owner Invoker".
+    ///
+    /// This is useful for using the multisig as a whitelist or as a council,
+    /// e.g. a whitelist of approved owners.
+    #[access_control(ctx.accounts.validate())]
+    pub fn owner_invoke_instruction(
+        ctx: Context<OwnerInvokeInstruction>,
+        index: u64,
+        bump: u8,
+        ix: TXInstruction,
+    ) -> ProgramResult {
+        let smart_wallet = &ctx.accounts.smart_wallet;
+        // Execute the transaction signed by the smart_wallet.
+        let invoker_seeds: &[&[&[u8]]] = &[&[
+            b"GokiSmartWalletOwnerInvoker" as &[u8],
+            &smart_wallet.key().to_bytes(),
+            &index.to_le_bytes(),
+            &[bump],
+        ]];
+
+        solana_program::program::invoke_signed(
+            &(&ix).into(),
+            ctx.remaining_accounts,
+            invoker_seeds,
+        )?;
+
+        Ok(())
+    }
 }
 
 /// Accounts for [smart_wallet::create_smart_wallet].
@@ -365,6 +395,15 @@ pub struct ExecuteTransaction<'info> {
     pub owner: Signer<'info>,
 }
 
+/// Accounts for [smart_wallet::owner_invoke_instruction].
+#[derive(Accounts)]
+pub struct OwnerInvokeInstruction<'info> {
+    /// The [SmartWallet].
+    pub smart_wallet: Account<'info, SmartWallet>,
+    /// An owner of the [SmartWallet].
+    pub owner: Signer<'info>,
+}
+
 fn do_execute_transaction(ctx: Context<ExecuteTransaction>, seeds: &[&[&[u8]]]) -> ProgramResult {
     for ix in ctx.accounts.transaction.instructions.iter() {
         solana_program::program::invoke_signed(&(ix).into(), ctx.remaining_accounts, seeds)?;

programs/smart-wallet/src/validators.rs

@@ -84,3 +84,10 @@ impl<'info> Validate<'info> for ExecuteTransaction<'info> {
         Ok(())
     }
 }
+
+impl<'info> Validate<'info> for OwnerInvokeInstruction<'info> {
+    fn validate(&self) -> ProgramResult {
+        self.smart_wallet.owner_index(self.owner.key())?;
+        Ok(())
+    }
+}

src/wrappers/smartWallet/index.ts

@@ -10,7 +10,11 @@ import type {
   SmartWalletTransactionData,
 } from "../../programs";
 import type { GokiSDK } from "../../sdk";
-import { findTransactionAddress, findWalletDerivedAddress } from "./pda";
+import {
+  findOwnerInvokerAddress,
+  findTransactionAddress,
+  findWalletDerivedAddress,
+} from "./pda";
 import type {
   InitSmartWalletWrapperArgs,
   NewTransactionArgs,
@@ -173,6 +177,15 @@ export class SmartWalletWrapper {
     return await findWalletDerivedAddress(this.key, index);
   }
 
+  /**
+   * Finds the owner invoker address and bump of a given index.
+   * @param index
+   * @returns
+   */
+  async findOwnerInvokerAddress(index: number): Promise<[PublicKey, number]> {
+    return await findOwnerInvokerAddress(this.key, index);
+  }
+
   private async _fetchExecuteTransactionContext({
     transactionKey,
     owner = this.provider.wallet.publicKey,
@@ -238,6 +251,51 @@ export class SmartWalletWrapper {
     return new TransactionEnvelope(this.provider, [ix]);
   }
 
+  /**
+   * Executes a transaction using an owner invoker address.
+   */
+  async ownerInvokeInstruction({
+    instruction,
+    index,
+    owner = this.provider.wallet.publicKey,
+  }: {
+    instruction: TransactionInstruction;
+    index: number;
+    owner?: PublicKey;
+  }): Promise<TransactionEnvelope> {
+    const [invokerAddress, invokerBump] = await this.findOwnerInvokerAddress(
+      index
+    );
+    const ix = this.program.instruction.ownerInvokeInstruction(
+      new BN(index),
+      invokerBump,
+      instruction,
+      {
+        accounts: {
+          smartWallet: this.key,
+          owner,
+        },
+        remainingAccounts: [
+          {
+            pubkey: instruction.programId,
+            isSigner: false,
+            isWritable: false,
+          },
+          ...instruction.keys.map((k) => {
+            if (k.isSigner && invokerAddress.equals(k.pubkey)) {
+              return {
+                ...k,
+                isSigner: false,
+              };
+            }
+            return k;
+          }),
+        ],
+      }
+    );
+    return new TransactionEnvelope(this.provider, [ix]);
+  }
+
   /**
    * setOwners
    */

src/wrappers/smartWallet/pda.ts

@@ -46,3 +46,23 @@ export const findWalletDerivedAddress = async (
     GOKI_ADDRESSES.SmartWallet
   );
 };
+
+/**
+ * Finds an Owner Invoker address of a Smart Wallet.
+ * @param smartWallet
+ * @param index
+ * @returns
+ */
+export const findOwnerInvokerAddress = async (
+  smartWallet: PublicKey,
+  index: number
+): Promise<[PublicKey, number]> => {
+  return await PublicKey.findProgramAddress(
+    [
+      utils.bytes.utf8.encode("GokiSmartWalletOwnerInvoker"),
+      smartWallet.toBuffer(),
+      new u64(index).toBuffer(),
+    ],
+    GOKI_ADDRESSES.SmartWallet
+  );
+};

tests/smartWallet.spec.ts

@@ -2,7 +2,10 @@ import "chai-bn";
 
 import * as anchor from "@project-serum/anchor";
 import { expectTX } from "@saberhq/chai-solana";
-import { TransactionEnvelope } from "@saberhq/solana-contrib";
+import {
+  PendingTransaction,
+  TransactionEnvelope,
+} from "@saberhq/solana-contrib";
 import { sleep, u64 } from "@saberhq/token-utils";
 import {
   Keypair,
@@ -437,4 +440,52 @@ describe("smartWallet", () => {
       );
     });
   });
+
+  describe("owner invoker", () => {
+    const { provider } = sdk;
+    const ownerA = web3.Keypair.generate();
+    const ownerB = web3.Keypair.generate();
+
+    const owners = [
+      ownerA.publicKey,
+      ownerB.publicKey,
+      provider.wallet.publicKey,
+    ];
+    let smartWalletWrapper: SmartWalletWrapper;
+
+    beforeEach(async () => {
+      const { smartWalletWrapper: wrapperInner, tx } = await sdk.newSmartWallet(
+        {
+          numOwners: owners.length,
+          owners,
+          threshold: new BN(1),
+        }
+      );
+      await expectTX(tx, "create new smartWallet").to.be.fulfilled;
+      smartWalletWrapper = wrapperInner;
+    });
+
+    it("should invoke 1 of N", async () => {
+      const index = 5;
+      const [invokerKey] = await smartWalletWrapper.findOwnerInvokerAddress(
+        index
+      );
+
+      await new PendingTransaction(
+        provider.connection,
+        await provider.connection.requestAirdrop(invokerKey, LAMPORTS_PER_SOL)
+      ).wait();
+
+      const invokeTX = await smartWalletWrapper.ownerInvokeInstruction({
+        index,
+        instruction: SystemProgram.transfer({
+          fromPubkey: invokerKey,
+          toPubkey: provider.wallet.publicKey,
+          lamports: LAMPORTS_PER_SOL,
+        }),
+      });
+      await expectTX(invokeTX, "transfer lamports to smart wallet").to.be
+        .fulfilled;
+    });
+  });
 });