desired balance
diff --git a/lib/validate.js b/lib/validate.js
index 96753c94..5e9b30c9 100644
--- a/lib/validate.js
+++ b/lib/validate.js
@@ -1,4 +1,4 @@
-import { string, ValidationError, number, object, array, addMethod, boolean, date } from 'yup'
+import { string, ValidationError, number, object, array, boolean, date } from './yup'
import {
BOOST_MIN, MAX_POLL_CHOICE_LENGTH, MAX_TITLE_LENGTH, MAX_POLL_NUM_CHOICES,
MIN_POLL_NUM_CHOICES, MAX_FORWARDS, BOOST_MULT, MAX_TERRITORY_DESC_LENGTH, POST_TYPES,
@@ -6,19 +6,16 @@ import {
} from './constants'
import { SUPPORTED_CURRENCIES } from './currency'
import { NOSTR_MAX_RELAY_NUM, NOSTR_PUBKEY_BECH32, NOSTR_PUBKEY_HEX } from './nostr'
-import { msatsToSats, numWithUnits, abbrNum, ensureB64, B64_URL_REGEX, HEX_REGEX } from './format'
+import { msatsToSats, numWithUnits, abbrNum } from './format'
import * as usersFragments from '@/fragments/users'
import * as subsFragments from '@/fragments/subs'
-import { isInvoicableMacaroon, isInvoiceMacaroon } from './macaroon'
-import { TOR_REGEXP, parseNwcUrl } from './url'
import { datePivot } from './time'
-import { decodeRune } from '@/lib/cln'
import bip39Words from './bip39-words'
const { SUB } = subsFragments
const { NAME_QUERY } = usersFragments
-export async function ssValidate (schema, data, args) {
+export async function validateSchema (schema, data, args) {
try {
if (typeof schema === 'function') {
return await schema(args).validate(data)
@@ -33,159 +30,6 @@ export async function ssValidate (schema, data, args) {
}
}
-export async function formikValidate (validate, data) {
- const result = await validate(data)
- if (Object.keys(result).length > 0) {
- const [key, message] = Object.entries(result)[0]
- throw new Error(`${key}: ${message}`)
- }
- return result
-}
-
-export async function walletValidate (walletDef, data) {
- if (typeof walletDef.fieldValidation === 'function') {
- return await formikValidate(walletDef.fieldValidation, data)
- } else {
- return await ssValidate(walletDef.fieldValidation, data)
- }
-}
-
-addMethod(string, 'or', function (schemas, msg) {
- return this.test({
- name: 'or',
- message: msg,
- test: value => {
- if (Array.isArray(schemas) && schemas.length > 1) {
- const resee = schemas.map(schema => schema.isValidSync(value))
- return resee.some(res => res)
- } else {
- throw new TypeError('Schemas is not correct array schema')
- }
- },
- exclusive: false
- })
-})
-
-addMethod(string, 'url', function (schemas, msg = 'invalid url') {
- return this.test({
- name: 'url',
- message: msg,
- test: value => {
- try {
- // eslint-disable-next-line no-new
- new URL(value)
- return true
- } catch (e) {
- try {
- // eslint-disable-next-line no-new
- new URL(`http://${value}`)
- return true
- } catch (e) {
- return false
- }
- }
- },
- exclusive: false
- })
-})
-
-addMethod(string, 'ws', function (schemas, msg = 'invalid websocket') {
- return this.test({
- name: 'ws',
- message: msg,
- test: value => {
- if (typeof value === 'undefined') return true
- try {
- const url = new URL(value)
- return url.protocol === 'ws:' || url.protocol === 'wss:'
- } catch (e) {
- return false
- }
- },
- exclusive: false
- })
-})
-
-addMethod(string, 'socket', function (schemas, msg = 'invalid socket') {
- return this.test({
- name: 'socket',
- message: msg,
- test: value => {
- try {
- const url = new URL(`http://${value}`)
- return url.hostname && url.port && !url.username && !url.password &&
- (!url.pathname || url.pathname === '/') && !url.search && !url.hash
- } catch (e) {
- return false
- }
- },
- exclusive: false
- })
-})
-
-addMethod(string, 'https', function () {
- return this.test({
- name: 'https',
- message: 'https required',
- test: (url) => {
- try {
- return new URL(url).protocol === 'https:'
- } catch {
- return false
- }
- }
- })
-})
-
-addMethod(string, 'wss', function (msg) {
- return this.test({
- name: 'wss',
- message: msg || 'wss required',
- test: (url) => {
- try {
- return new URL(url).protocol === 'wss:'
- } catch {
- return false
- }
- }
- })
-})
-
-addMethod(string, 'hex', function (msg) {
- return this.test({
- name: 'hex',
- message: msg || 'invalid hex encoding',
- test: (value) => !value || HEX_REGEX.test(value)
- })
-})
-
-addMethod(string, 'nwcUrl', function () {
- return this.test({
- test: async (nwcUrl, context) => {
- if (!nwcUrl) return true
-
- // run validation in sequence to control order of errors
- // inspired by https://github.com/jquense/yup/issues/851#issuecomment-1049705180
- try {
- await string().matches(/^nostr\+?walletconnect:\/\//, { message: 'must start with nostr+walletconnect://' }).validate(nwcUrl)
- let relayUrl, walletPubkey, secret
- try {
- ({ relayUrl, walletPubkey, secret } = parseNwcUrl(nwcUrl))
- } catch {
- // invalid URL error. handle as if pubkey validation failed to not confuse user.
- throw new Error('pubkey must be 64 hex chars')
- }
- await string().required('pubkey required').trim().matches(NOSTR_PUBKEY_HEX, 'pubkey must be 64 hex chars').validate(walletPubkey)
- await string().required('relay url required').trim().wss('relay must use wss://').validate(relayUrl)
- await string().required('secret required').trim().matches(/^[0-9a-fA-F]{64}$/, 'secret must be 64 hex chars').validate(secret)
- } catch (err) {
- return context.createError({ message: err.message })
- }
- return true
- }
- })
-})
-
const titleValidator = string().required('required').trim().max(
MAX_TITLE_LENGTH,
({ max, value }) => `-${Math.abs(max - value.length)} characters remaining`
@@ -203,32 +47,12 @@ const nameValidator = string()
const intValidator = number().typeError('must be a number').integer('must be whole')
const floatValidator = number().typeError('must be a number')
-const lightningAddressValidator = process.env.NODE_ENV === 'development'
+export const lightningAddressValidator = process.env.NODE_ENV === 'development'
? string().or(
[string().matches(/^[\w_]+@localhost:\d+$/), string().matches(/^[\w_]+@app:\d+$/), string().email()],
'address is no good')
: string().email('address is no good')
-const hexOrBase64Validator = string().test({
- name: 'hex-or-base64',
- message: 'invalid encoding',
- test: (val) => {
- if (typeof val === 'undefined') return true
- try {
- ensureB64(val)
- return true
- } catch {
- return false
- }
- }
-}).transform(val => {
- try {
- return ensureB64(val)
- } catch {
- return val
- }
-})
-
async function usernameExists (name, { client, models }) {
if (!client && !models) {
throw new Error('cannot check for user')
@@ -363,56 +187,59 @@ export function advSchema (args) {
})
}
-export const autowithdrawSchemaMembers = {
- enabled: boolean(),
- autoWithdrawThreshold: intValidator.required('required').min(0, 'must be at least 0').max(msatsToSats(BALANCE_LIMIT_MSATS), `must be at most ${abbrNum(msatsToSats(BALANCE_LIMIT_MSATS))}`),
- autoWithdrawMaxFeePercent: floatValidator.required('required').min(0, 'must be at least 0').max(50, 'must not exceed 50'),
- autoWithdrawMaxFeeTotal: intValidator.required('required').min(0, 'must be at least 0').max(1_000, 'must not exceed 1000')
-}
-
-export const lnAddrAutowithdrawSchema = object({
- address: lightningAddressValidator.required('required').test({
- name: 'address',
- test: addr => !addr.endsWith('@stacker.news'),
- message: 'automated withdrawals must be external'
- }),
- ...autowithdrawSchemaMembers
+export const autowithdrawSchemaMembers = object({
+ autoWithdrawThreshold: intValidator.required('required').min(0, 'must be at least 0').max(msatsToSats(BALANCE_LIMIT_MSATS), `must be at most ${abbrNum(msatsToSats(BALANCE_LIMIT_MSATS))}`).transform(Number),
+ autoWithdrawMaxFeePercent: floatValidator.required('required').min(0, 'must be at least 0').max(50, 'must not exceed 50').transform(Number),
+ autoWithdrawMaxFeeTotal: intValidator.required('required').min(0, 'must be at least 0').max(1_000, 'must not exceed 1000').transform(Number)
})
-export const LNDAutowithdrawSchema = object({
- socket: string().socket().required('required'),
- macaroon: hexOrBase64Validator.required('required').test({
- name: 'macaroon',
- test: v => isInvoiceMacaroon(v) || isInvoicableMacaroon(v),
- message: 'not an invoice macaroon or an invoicable macaroon'
- }),
- cert: hexOrBase64Validator,
- ...autowithdrawSchemaMembers
-})
+export const lnAddrSchema = ({ payerData, min, max, commentAllowed } = {}) =>
+ object({
+ addr: lightningAddressValidator.required('required'),
+ amount: (() => {
+ const schema = intValidator.required('required').positive('must be positive').min(
+ min || 1, `must be at least ${min || 1}`)
+ return max ? schema.max(max, `must be at most ${max}`) : schema
+ })(),
+ maxFee: intValidator.required('required').min(0, 'must be at least 0'),
+ comment: commentAllowed
+ ? string().max(commentAllowed, `must be less than ${commentAllowed}`)
+ : string()
+ }).concat(object().shape(Object.keys(payerData || {}).reduce((accum, key) => {
+ const entry = payerData[key]
+ if (key === 'email') {
+ accum[key] = string().email()
+ } else if (key === 'identifier') {
+ accum[key] = boolean()
+ } else {
+ accum[key] = string()
+ }
+ if (entry?.mandatory) {
+ accum[key] = accum[key].required()
+ }
+ return accum
+ }, {})))
-export const CLNAutowithdrawSchema = object({
- socket: string().socket().required('required'),
- rune: string().matches(B64_URL_REGEX, { message: 'invalid rune' }).required('required')
- .test({
- name: 'rune',
- test: (v, context) => {
- const decoded = decodeRune(v)
- if (!decoded) return context.createError({ message: 'invalid rune' })
- if (decoded.restrictions.length === 0) {
- return context.createError({ message: 'rune must be restricted to method=invoice' })
- }
- if (decoded.restrictions.length !== 1 || decoded.restrictions[0].alternatives.length !== 1) {
- return context.createError({ message: 'rune must be restricted to method=invoice only' })
- }
- if (decoded.restrictions[0].alternatives[0] !== 'method=invoice') {
- return context.createError({ message: 'rune must be restricted to method=invoice only' })
- }
- return true
- }
+export const phoenixdSchema = object().shape({
+ url: string().url().required('required').trim(),
+ primaryPassword: string().length(64).hex()
+ .when(['secondaryPassword'], ([secondary], schema) => {
+ if (!secondary) return schema.required('required if secondary password not set')
+ return schema.test({
+ test: primary => secondary !== primary,
+ message: 'primary password cannot be the same as secondary password'
+ })
+ }),
+ secondaryPassword: string().length(64).hex()
+ .when(['primaryPassword'], ([primary], schema) => {
+ if (!primary) return schema.required('required if primary password not set')
+ return schema.test({
+ test: secondary => primary !== secondary,
+ message: 'secondary password cannot be the same as primary password'
+ })
}),
- cert: hexOrBase64Validator,
...autowithdrawSchemaMembers
-})
+}, ['primaryPassword', 'secondaryPassword'])
export function bountySchema (args) {
return object({
@@ -663,146 +490,6 @@ export const withdrawlSchema = object({
maxFee: intValidator.required('required').min(0, 'must be at least 0')
})
-export const lnAddrSchema = ({ payerData, min, max, commentAllowed } = {}) =>
- object({
- addr: lightningAddressValidator.required('required'),
- amount: (() => {
- const schema = intValidator.required('required').positive('must be positive').min(
- min || 1, `must be at least ${min || 1}`)
- return max ? schema.max(max, `must be at most ${max}`) : schema
- })(),
- maxFee: intValidator.required('required').min(0, 'must be at least 0'),
- comment: commentAllowed
- ? string().max(commentAllowed, `must be less than ${commentAllowed}`)
- : string()
- }).concat(object().shape(Object.keys(payerData || {}).reduce((accum, key) => {
- const entry = payerData[key]
- if (key === 'email') {
- accum[key] = string().email()
- } else if (key === 'identifier') {
- accum[key] = boolean()
- } else {
- accum[key] = string()
- }
- if (entry?.mandatory) {
- accum[key] = accum[key].required()
- }
- return accum
- }, {})))
-
-export const lnbitsSchema = object().shape({
- url: process.env.NODE_ENV === 'development'
- ? string()
- .or([string().matches(/^(http:\/\/)?localhost:\d+$/), string().url()], 'invalid url')
- .required('required').trim()
- : string().url().required('required').trim()
- .test(async (url, context) => {
- if (TOR_REGEXP.test(url)) {
- // allow HTTP and HTTPS over Tor
- if (!/^https?:\/\//.test(url)) {
- return context.createError({ message: 'http or https required' })
- }
- return true
- }
- try {
- // force HTTPS over clearnet
- await string().https().validate(url)
- } catch (err) {
- return context.createError({ message: err.message })
- }
- return true
- }),
- adminKey: string().length(32).hex()
- .when(['invoiceKey'], ([invoiceKey], schema) => {
- if (!invoiceKey) return schema.required('required if invoice key not set')
- return schema.test({
- test: adminKey => adminKey !== invoiceKey,
- message: 'admin key cannot be the same as invoice key'
- })
- }),
- invoiceKey: string().length(32).hex()
- .when(['adminKey'], ([adminKey], schema) => {
- if (!adminKey) return schema.required('required if admin key not set')
- return schema.test({
- test: invoiceKey => adminKey !== invoiceKey,
- message: 'invoice key cannot be the same as admin key'
- })
- }),
- ...autowithdrawSchemaMembers
- // need to set order to avoid cyclic dependencies in Yup schema
- // see https://github.com/jquense/yup/issues/176#issuecomment-367352042
-}, ['adminKey', 'invoiceKey'])
-
-export const nwcSchema = object().shape({
- nwcUrl: string().nwcUrl().when(['nwcUrlRecv'], ([nwcUrlRecv], schema) => {
- if (!nwcUrlRecv) return schema.required('required if connection for receiving not set')
- return schema.test({
- test: nwcUrl => nwcUrl !== nwcUrlRecv,
- message: 'connection for sending cannot be the same as for receiving'
- })
- }),
- nwcUrlRecv: string().nwcUrl().when(['nwcUrl'], ([nwcUrl], schema) => {
- if (!nwcUrl) return schema.required('required if connection for sending not set')
- return schema.test({
- test: nwcUrlRecv => nwcUrlRecv !== nwcUrl,
- message: 'connection for receiving cannot be the same as for sending'
- })
- }),
- ...autowithdrawSchemaMembers
-}, ['nwcUrl', 'nwcUrlRecv'])
-
-export const blinkSchema = object({
- apiKey: string()
- .required('required')
- .matches(/^blink_[A-Za-z0-9]+$/, { message: 'must match pattern blink_A-Za-z0-9' }),
- currency: string()
- .transform(value => value ? value.toUpperCase() : 'BTC')
- .oneOf(['USD', 'BTC'], 'must be BTC or USD')
-})
-
-export const lncSchema = object({
- pairingPhrase: string()
- .test(async (value, context) => {
- const words = value ? value.trim().split(/[\s]+/) : []
- for (const w of words) {
- try {
- await string().oneOf(bip39Words).validate(w)
- } catch {
- return context.createError({ message: `'${w}' is not a valid pairing phrase word` })
- }
- }
- if (words.length < 2) {
- return context.createError({ message: 'needs at least two words' })
- }
- if (words.length > 10) {
- return context.createError({ message: 'max 10 words' })
- }
- return true
- })
- .required('required')
-})
-
-export const phoenixdSchema = object().shape({
- url: string().url().required('required').trim(),
- primaryPassword: string().length(64).hex()
- .when(['secondaryPassword'], ([secondary], schema) => {
- if (!secondary) return schema.required('required if secondary password not set')
- return schema.test({
- test: primary => secondary !== primary,
- message: 'primary password cannot be the same as secondary password'
- })
- }),
- secondaryPassword: string().length(64).hex()
- .when(['primaryPassword'], ([primary], schema) => {
- if (!primary) return schema.required('required if primary password not set')
- return schema.test({
- test: secondary => primary !== secondary,
- message: 'secondary password cannot be the same as primary password'
- })
- }),
- ...autowithdrawSchemaMembers
-}, ['primaryPassword', 'secondaryPassword'])
-
export const bioSchema = object({
text: string().required('required').trim()
})
diff --git a/lib/yup.js b/lib/yup.js
new file mode 100644
index 00000000..6102eae4
--- /dev/null
+++ b/lib/yup.js
@@ -0,0 +1,167 @@
+import { addMethod, string, mixed } from 'yup'
+import { parseNwcUrl } from './url'
+import { NOSTR_PUBKEY_HEX } from './nostr'
+import { ensureB64, HEX_REGEX } from './format'
+
+function orFunc (schemas, msg) {
+ return this.test({
+ name: 'or',
+ message: msg,
+ test: value => {
+ if (Array.isArray(schemas) && schemas.length > 1) {
+ const resee = schemas.map(schema => schema.isValidSync(value))
+ return resee.some(res => res)
+ } else {
+ throw new TypeError('Schemas is not correct array schema')
+ }
+ },
+ exclusive: false
+ })
+}
+
+addMethod(mixed, 'or', orFunc)
+addMethod(string, 'or', orFunc)
+
+addMethod(string, 'hexOrBase64', function (schemas, msg = 'invalid hex or base64 encoding') {
+ return this.test({
+ name: 'hex-or-base64',
+ message: 'invalid encoding',
+ test: (val) => {
+ if (typeof val === 'undefined') return true
+ try {
+ ensureB64(val)
+ return true
+ } catch {
+ return false
+ }
+ }
+ }).transform(val => {
+ try {
+ return ensureB64(val)
+ } catch {
+ return val
+ }
+ })
+})
+
+addMethod(string, 'url', function (schemas, msg = 'invalid url') {
+ return this.test({
+ name: 'url',
+ message: msg,
+ test: value => {
+ try {
+ // eslint-disable-next-line no-new
+ new URL(value)
+ return true
+ } catch (e) {
+ try {
+ // eslint-disable-next-line no-new
+ new URL(`http://${value}`)
+ return true
+ } catch (e) {
+ return false
+ }
+ }
+ },
+ exclusive: false
+ })
+})
+
+addMethod(string, 'ws', function (schemas, msg = 'invalid websocket') {
+ return this.test({
+ name: 'ws',
+ message: msg,
+ test: value => {
+ if (typeof value === 'undefined') return true
+ try {
+ const url = new URL(value)
+ return url.protocol === 'ws:' || url.protocol === 'wss:'
+ } catch (e) {
+ return false
+ }
+ },
+ exclusive: false
+ })
+})
+
+addMethod(string, 'socket', function (schemas, msg = 'invalid socket') {
+ return this.test({
+ name: 'socket',
+ message: msg,
+ test: value => {
+ try {
+ const url = new URL(`http://${value}`)
+ return url.hostname && url.port && !url.username && !url.password &&
+ (!url.pathname || url.pathname === '/') && !url.search && !url.hash
+ } catch (e) {
+ return false
+ }
+ },
+ exclusive: false
+ })
+})
+
+addMethod(string, 'https', function () {
+ return this.test({
+ name: 'https',
+ message: 'https required',
+ test: (url) => {
+ try {
+ return new URL(url).protocol === 'https:'
+ } catch {
+ return false
+ }
+ }
+ })
+})
+
+addMethod(string, 'wss', function (msg) {
+ return this.test({
+ name: 'wss',
+ message: msg || 'wss required',
+ test: (url) => {
+ try {
+ return new URL(url).protocol === 'wss:'
+ } catch {
+ return false
+ }
+ }
+ })
+})
+
+addMethod(string, 'hex', function (msg) {
+ return this.test({
+ name: 'hex',
+ message: msg || 'invalid hex encoding',
+ test: (value) => !value || HEX_REGEX.test(value)
+ })
+})
+
+addMethod(string, 'nwcUrl', function () {
+ return this.test({
+ test: async (nwcUrl, context) => {
+ if (!nwcUrl) return true
+
+ // run validation in sequence to control order of errors
+ // inspired by https://github.com/jquense/yup/issues/851#issuecomment-1049705180
+ try {
+ await string().matches(/^nostr\+?walletconnect:\/\//, { message: 'must start with nostr+walletconnect://' }).validate(nwcUrl)
+ let relayUrl, walletPubkey, secret
+ try {
+ ({ relayUrl, walletPubkey, secret } = parseNwcUrl(nwcUrl))
+ } catch {
+ // invalid URL error. handle as if pubkey validation failed to not confuse user.
+ throw new Error('pubkey must be 64 hex chars')
+ }
+ await string().required('pubkey required').trim().matches(NOSTR_PUBKEY_HEX, 'pubkey must be 64 hex chars').validate(walletPubkey)
+ await string().required('relay url required').trim().wss('relay must use wss://').validate(relayUrl)
+ await string().required('secret required').trim().matches(/^[0-9a-fA-F]{64}$/, 'secret must be 64 hex chars').validate(secret)
+ } catch (err) {
+ return context.createError({ message: err.message })
+ }
+ return true
+ }
+ })
+})
+
+export * from 'yup'
diff --git a/pages/api/lnurlp/[username]/pay.js b/pages/api/lnurlp/[username]/pay.js
index b153a2ee..6cfc9b44 100644
--- a/pages/api/lnurlp/[username]/pay.js
+++ b/pages/api/lnurlp/[username]/pay.js
@@ -7,7 +7,7 @@ import { schnorr } from '@noble/curves/secp256k1'
import { createHash } from 'crypto'
import { datePivot } from '@/lib/time'
import { BALANCE_LIMIT_MSATS, INV_PENDING_LIMIT, LNURLP_COMMENT_MAX_LENGTH, USER_IDS_BALANCE_NO_LIMIT } from '@/lib/constants'
-import { ssValidate, lud18PayerDataSchema } from '@/lib/validate'
+import { validateSchema, lud18PayerDataSchema } from '@/lib/validate'
import assertGofacYourself from '@/api/resolvers/ofac'
export default async ({ query: { username, amount, nostr, comment, payerdata: payerData }, headers }, res) => {
@@ -59,7 +59,7 @@ export default async ({ query: { username, amount, nostr, comment, payerdata: pa
}
try {
- await ssValidate(lud18PayerDataSchema, parsedPayerData)
+ await validateSchema(lud18PayerDataSchema, parsedPayerData)
} catch (err) {
console.error('error validating payer data', err)
return res.status(400).json({ status: 'ERROR', reason: err.toString() })
diff --git a/pages/settings/wallets/[wallet].js b/pages/settings/wallets/[wallet].js
index 95de9f61..f563b13c 100644
--- a/pages/settings/wallets/[wallet].js
+++ b/pages/settings/wallets/[wallet].js
@@ -9,12 +9,15 @@ import { useWallet } from '@/wallets/index'
import Info from '@/components/info'
import Text from '@/components/text'
import { autowithdrawInitial, AutowithdrawSettings } from '@/components/autowithdraw-shared'
-import { canSend, isConfigured } from '@/wallets/common'
+import { canReceive, canSend, isConfigured } from '@/wallets/common'
import { SSR } from '@/lib/constants'
import WalletButtonBar from '@/components/wallet-buttonbar'
import { useWalletConfigurator } from '@/wallets/config'
-import { useMemo } from 'react'
+import { useCallback, useMemo } from 'react'
import { useMe } from '@/components/me'
+import validateWallet from '@/wallets/validate'
+import { ValidationError } from 'yup'
+import { useFormikContext } from 'formik'
export const getServerSideProps = getGetServerSideProps({ authRequired: true })
@@ -47,10 +50,19 @@ export default function WalletSettings () {
}
}, [wallet, me])
- // check if wallet uses the form-level validation built into Formik or a Yup schema
- const validateProps = typeof wallet?.fieldValidation === 'function'
- ? { validate: wallet?.fieldValidation }
- : { schema: wallet?.fieldValidation }
+ const validate = useCallback(async (data) => {
+ try {
+ await validateWallet(wallet.def, data, { abortEarly: false, topLevel: false })
+ } catch (error) {
+ if (error instanceof ValidationError) {
+ return error.inner.reduce((acc, error) => {
+ acc[error.path] = error.message
+ return acc
+ }, {})
+ }
+ throw error
+ }
+ }, [wallet.def])
return (
@@ -60,7 +72,7 @@ export default function WalletSettings () {