import {
Address,
address,
bytesEqual,
MessageModifyingSigner,
SignableMessage,
SignatureBytes,
SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED,
SolanaError,
} from '@solana/kit';
import { getAbortablePromise } from '@solana/promises';
import type { UiWalletAccount } from '@wallet-standard/ui';
import { useMemo } from 'react';
import { useSignMessage } from './useSignMessage';
/**
* Use this to get a {@link MessageSigner} capable of signing messages with the private key of a
* {@link UiWalletAccount}
*
* @returns A {@link MessageModifyingSigner}. This is a conservative assumption based on the fact
* that your application can not control whether or not the wallet will modify the message before
* signing it. Otherwise this method could more specifically return a {@link MessageSigner} or a
* {@link MessagePartialSigner}.
*
* @example
* ```tsx
* import { useWalletAccountMessageSigner } from '@solana/react';
* import { createSignableMessage } from '@solana/kit';
*
* function SignMessageButton({ account, text }) {
* const messageSigner = useWalletAccountMessageSigner(account);
* return (
*
* );
* }
* ```
*/
export function useWalletAccountMessageSigner(
uiWalletAccount: TWalletAccount,
): MessageModifyingSigner {
const signMessage = useSignMessage(uiWalletAccount);
return useMemo(
() => ({
address: address(uiWalletAccount.address),
async modifyAndSignMessages(messages, config) {
config?.abortSignal?.throwIfAborted();
if (messages.length > 1) {
throw new SolanaError(SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED);
}
if (messages.length === 0) {
return messages;
}
const { content: originalMessage, signatures: originalSignatureMap } = messages[0];
const input = {
message: originalMessage,
};
const { signedMessage, signature } = await getAbortablePromise(signMessage(input), config?.abortSignal);
const messageWasModified =
originalMessage.length !== signedMessage.length ||
originalMessage.some((originalByte, ii) => originalByte !== signedMessage[ii]);
const originalSignature = originalSignatureMap[uiWalletAccount.address as Address] as
| SignatureBytes
| undefined;
const signatureIsNew = originalSignature === undefined || !bytesEqual(originalSignature, signature);
if (!signatureIsNew && !messageWasModified) {
// We already had this exact signature, and the message wasn't modified.
// Don't replace the existing message object.
return messages;
}
const nextSignatureMap = messageWasModified
? { [uiWalletAccount.address]: signature }
: { ...originalSignatureMap, [uiWalletAccount.address]: signature };
const outputMessages = Object.freeze([
Object.freeze({
content: signedMessage,
signatures: Object.freeze(nextSignatureMap),
}) as SignableMessage,
]);
return outputMessages;
},
}),
[uiWalletAccount, signMessage],
);
}