feat: Add signTransaction() and signDelegateAction() to BaseWalletBehaviour interface

packages/core/src/lib/services/wallet-modules/wallet-modules.service.ts

@@ -301,6 +301,8 @@ export class WalletModules {
  const _signIn = wallet.signIn;
  const _signOut = wallet.signOut;
  const _signMessage = wallet.signMessage;
+ const _signTransaction = wallet.signTransaction;
+ const _signDelegateAction = wallet.signDelegateAction;
 
  wallet.signIn = async (params: never) => {
  const accounts = await _signIn(params);
@@ -332,6 +334,42 @@ export class WalletModules {
  return await _signMessage(params);
  };
 
+ wallet.signTransaction = async (params: never) => {
+ if (_signTransaction === undefined) {
+ throw new Error(
+ `The signTransaction method is not supported by ${wallet.metadata.name}`
+ );
+ }
+
+ try {
+ return await _signTransaction(params);
+ } catch (error) {
+ throw new Error(
+ `Failed to sign transaction: ${
+ error instanceof Error ? error.message : String(error)
+ }`
+ );
+ }
+ };
+
+ wallet.signDelegateAction = async (params: never) => {
+ if (_signDelegateAction === undefined) {
+ throw new Error(
+ `The signDelegateAction method is not supported by ${wallet.metadata.name}`
+ );
+ }
+
+ try {
+ return await _signDelegateAction(params);
+ } catch (error) {
+ throw new Error(
+ `Failed to sign delegate action: ${
+ error instanceof Error ? error.message : String(error)
+ }`
+ );
+ }
+ };
+
  return wallet;
  }
 

packages/core/src/lib/wallet/wallet.types.ts

@@ -10,6 +10,13 @@ import type { ReadOnlyStore } from "../store.types";
 import type { Transaction, Action } from "./transactions.types";
 import type { Modify, Optional } from "../utils.types";
 import type { FinalExecutionOutcome } from "near-api-js/lib/providers";
+import type {
+ SignedTransaction,
+ Transaction as Tx,
+ Signature,
+} from "near-api-js/lib/transaction";
+import type { Signer } from "near-api-js/lib/signer";
+import type { PublicKey } from "near-api-js/lib/utils";
 
 interface BaseWalletMetadata {
  /**
@@ -121,6 +128,112 @@ interface SignAndSendTransactionsParams {
  transactions: Array<Optional<Transaction, "signerId">>;
 }
 
+interface SignTransactionParams {
+ /**
+ * The Transaction object to sign
+ */
+ transaction: Tx;
+ /**
+ * The {Signer} object that assists with signing keys
+ */
+ signer: Signer;
+ /**
+ * The human-readable NEAR account name
+ */
+ accountId?: string;
+ /**
+ * The targeted network. (ex. default, betanet, etc…)
+ */
+ networkId?: string;
+}
+
+interface SignTransactionActionsParams {
+ /**
+ * The NEAR account ID of the transaction receiver.
+ */
+ receiverId: string;
+ /**
+ * Tx nonce.
+ */
+ nonce: bigint;
+ /**
+ * NEAR Action(s) to sign and send to the network (e.g. `FunctionCall`). You can find more information on `Action` {@link https:/near/wallet-selector/blob/main/packages/core/docs/api/transactions.md | here}.
+ */
+ actions: Array<Action>;
+ /**
+ * Block hash
+ */
+ blockHash: Uint8Array;
+ /**
+ * The {Signer} object that assists with signing keys
+ */
+ signer: Signer;
+ /**
+ * The human-readable NEAR account name
+ */
+ accountId?: string;
+ /**
+ * The targeted network. (ex. default, betanet, etc…)
+ */
+ networkId?: string;
+}
+
+interface MessageSigner {
+ sign(message: Uint8Array): Promise<Uint8Array>;
+}
+
+interface DelegateAction {
+ /**
+ * Account ID for the intended signer of the delegate action
+ */
+ senderId: string;
+ /**
+ * The set of actions to be included in the meta transaction
+ */
+ actions: Array<Action>;
+ /**
+ * Number of blocks past the current block height for which the SignedDelegate action may be included in a meta transaction
+ */
+ blockHeightTtl: number;
+ /**
+ * Account ID for the intended receiver of the meta transaction
+ */
+ receiverId: string;
+ /**
+ * Current nonce on the access key used to sign the delegate action
+ */
+ nonce: bigint;
+ /**
+ * The maximum block height for which this action can be executed as part of a transaction
+ */
+ maxBlockHeight: bigint;
+ /**
+ * Public key for the access key used to sign the delegate action
+ */
+ publicKey: PublicKey;
+}
+
+interface SignDelegateOptions {
+ /**
+ * Delegate action to be signed by the meta transaction sender
+ */
+ delegateAction: DelegateAction;
+ /**
+ * Signer instance for the meta transaction sender
+ */
+ signer: MessageSigner;
+}
+
+interface SignedDelegate {
+ delegateAction: DelegateAction;
+ signature: Signature;
+}
+
+interface SignedDelegateWithHash {
+ hash: Uint8Array;
+ signedDelegateAction: SignedDelegate;
+}
+
 interface BaseWalletBehaviour {
  /**
  * Programmatically sign in. Hardware wallets (e.g. Ledger) require `derivationPaths` to validate access key permissions.
@@ -155,6 +268,19 @@ interface BaseWalletBehaviour {
  params: SignAndSendTransactionsParams
  ): Promise<Array<providers.FinalExecutionOutcome>>;
  signMessage?(params: SignMessageParams): Promise<SignedMessage | void>;
+ /**
+ * Signs one or more NEAR Actions which can be broadcasted to the network.
+ * The user must be signed in to call this method.
+ */
+ signTransaction?(
+ params: SignTransactionParams | SignTransactionActionsParams
+ ): Promise<[Uint8Array, SignedTransaction]>;
+ /**
+ * Composes and signs a SignedDelegate action to be executed in a transaction
+ */
+ signDelegateAction?(
+ params: SignDelegateOptions
+ ): Promise<SignedDelegateWithHash>;
 }
 
 type BaseWallet<