371e7417ce
* wip: Use uniform interface for wallets * Fix import error * Update wallet logging + other stuff * add canPay and canSend to wallet definition * rename 'default payment method' to 'enabled' and add enable + disable method * Set canPay, canReceive in useWallet * Enable wallet if just configured * Don't pass logger to sendPayment * Add logging to attach & detach * Add schema to wallet def * Add NWC wallet * Fix unused isDefault saved in config * Fix enableWallet * wrong storage key was used * broke if wallets with no configs existed * Run validation during save * Use INFO level for 'wallet disabled' message * Pass config with spread operator * Support help, optional, hint in wallet fields * wip: Add LNC * Fix 20s page load for /settings/wallets.json?nodata=true For some reason, if nodata is passed (which is the case if going back), the page takes 20s to load. * Fix extremely slow page load for LNC import I noticed that the combination of ``` import { Form, PasswordInput, SubmitButton } from '@/components/form' ``` in components/wallet/lnc.js and the dynamic import via `await import` in components/wallet/index.js caused extremely slow page loads. * Use normal imports * Revert "Fix 20s page load for /settings/wallets.json?nodata=true" This reverts commit deb476b3a966569fefcfdf4082d6b64f90fbd0a2. Not using the dynamic import for LNC fixed the slow page load with ?nodata=true. * Remove follow and show recent logs first * Fix position of log start marker * Add FIXMEs for LNC I can't get LNC to connect. It just hangs forever on lnc.connect(). See FIXMEs. * Remove logger.error since already handled in useWallet * Don't require destructuring to pass props to input * wip: Add LND autowithdrawals * receiving wallets need to export 'server' object field * don't print macaroon error stack * fix missing wallet logs order update * mark autowithdrawl settings as required * fix server wallet logs deletion * remove canPay and canReceive since it was confusing where it is available TODO * also use numeric priority for sending wallets to be consistent with how status for receiving wallets is determined * define createInvoice function in wallet definition * consistent wallet logs: sending wallets use 'wallet attached'+'wallet enabled/disabled' whereas receiving wallets use 'wallet created/updated' * see FIXMEs * Fix TypeError * Fix sendPayment called with empty config * removed useEffect such that config is available on first render * fix hydration error using dynamic import without SSR * Fix confusing UX around enabled * Remove FIXMEs Rebase on master seemed to have fixed these, weird * Use same error format in toast and wallet log * Fix usage of conditional hooks in useConfig * Fix isConfigured * Fix delete wallet logs on server * Fix wallet logs refetch onError does not exist on client.mutate * Fix TypeError in isConfigured if no enabled wallet found * Only include local/server config if required * Fix another hydration error * Fix server config not updated after save or detach * Also use 'enabled' for server wallets * Fix wallet logs not updated after server delete * Consistent logs between local and server wallets * 'wallet attached' on create * 'wallet updated' on config updates * 'wallet enabled' and 'wallet disabled' if checkbox changed * 'wallet detached' on delete * Also enable server wallets on create * Disable checkbox if not configured yet * Move all validation schema into lib/validate * Implement drag & drop w/o persistence * Use dynamic import for WalletCard This fixes a lot of issues with hydration * Save order as priority * Fix autowithdrawSettings not applied Form requires config in flat format but mutation requires autowithdraw settings in a separate 'settings' field. I have decided that config will be in flat form format. It will be transformed into mutation format during save. * Save dedicated enabled flag for server wallets * wallet table now contains boolean column 'enabled' * 'priority' is now a number everywhere * use consistent order between how autowithdrawals are attempted and server wallets cards * Fix onCanceled missing * Fix typo * Fix noisy changes in lib/validate I moved the schema for lnbits, nwc and lnc out of lib/validate only to put them back in there later. This commit should make the changeset cleaner by removing noise. * Split arguments into [value,] config, context * Run lnbits url.replace in validate and sendPayment * Remove unnecessary WALLETS_QUERY * Generate wallet mutation from fields * Generate wallet resolver from fields * Fix import inconsistency between app and worker * Use wallet.createInvoice for autowithdrawals * Fix success autowithdrawal log * Fix wallet security banner shown for server wallets * Add autowithdrawal to lightning address * Add optional wallet short name for logging * Fix draggable * Fix autowithdraw loop * Add missing hints * Add CLN autowithdrawal * Detach wallets and delete logs on logout * Remove Wallet in lib/constants * Use inject function for resolvers and typeDefs * Fix priority ignored when fetching enabled wallet * Fix draggable false on first page load due to SSR * Use touches instead of dnd on mobile Browsers don't support drag events for touch devices. To have a consistent implementation for desktop and mobile, we would need to use mousedown/touchstart, mouseup/touchend and mousemove/touchmove. For now, this commit makes changing the order possible on touch devices with simple touches. * Fix duplicate CLN error * Fix autowithdraw priority order * Fix error per invalid bip39 word * Update LNC code * remove LNC FIXMEs Mhh, I guess the TURN server was down or something? It now magically works. Or maybe it only works once per mnemonic? * also removed the lnc.lnd.lightning.getInfo() call since we don't ask and need permission for this RPC for payments. * setting a password does not work though. It fails with 'The password provided is not valid' which is triggered at https://github.com/lightninglabs/lnc-web/blob/main/lib/util/credentialStore.ts#L81. * Fix order if wallet with no priority exists * Use common sort * Add link to lnbits.com * Add example wallet def * Remove TODOs TODO in components/wallet-logger.js was handled. I don't see a need for the TODO in lib/wallet.js anymore. This function will only be called with the wallet of type LIGHTNING_ADDRESS anyway. * Remove console.log * Toast priority save errors * Fix leaking relay connections * Remove 'tor or clearnet' hint for LN addresses * Remove React dependency from wallet definitions * Generate resolver name from walletField * Move wallets into top level directory wallet/ * Put wallets into own folder * Fix generateMutation * remove resolverName property from wallet defs * move function into lib/wallet * use function in generateMutation on client to fix wrongly generated mutation * Separate client and server imports by files * wallets now consist of an index.js, a client.js and a server.js file * client.js is imported on the client and contains the client portion * server.js is imported on the server and contains the server porition * both reexport index.js so everything in index.js can be shared by client and server * every wallet contains a client.js file since they are all imported on the client to show the cards * client.js of every wallet is reexported as an array in wallets/client.js * server.js of every wallet is reexported as an array in wallets/server.js FIXME: for some reason, worker does not properly import the default export of wallets/server.js * Fix worker import of wallets/server * Fix wallet.server usage * I removed wallet.server in a previous commit * the client couldn't determine which wallet was stored on the server since all server specific fields were set in server.js * walletType and walletField are now set in index.js * walletType is now used to determine if a wallet is stored on the server * also included some formatting changes * Fix w.default usage Since package.json with { "type": "module" } was added, this is no longer needed. * Fix id access in walletPrioritySort * Fix autowithdrawal error log * Generate validation schema for LNbits * Generate validation schema for NWC * Rename to torAllowed * Generate validation schema for LNC * Generate validation schema for LND * Generate validation schema for LnAddr * Remove stringTypes * Generate validation schema for CLN * Make clear that message belongs to test * validate.message was used in tandem with validate.test * it might be confused as the message if the validation for validate.type failed * now validate.test can be a function or an object of { test, message } shape which matches Yup.test * Remove validate.schema as a trap door * make lnc work * Return null if no wallet was found * Revert code around schema generation * Transform autowithdrawSchemaMembers into an object * Rename schema to yupSchema * Fix missing required for LNbits adminKey * Support formik form-level validation * Fix missing addWalletLog import * Fix missing space after = * fix merge conflict resolution mistake * remove non-custodial* badges * create guides for attaching wallets in sndev * Use built-in formik validation or Yup schema but not both * Rename: validate -> testConnectClient, testConnect -> testConnectServer * make lnaddr autowithdraw work in dev * move ATTACH docs to ./wallets and add lnaddr doc * Fix missing rename: yupSchema -> fieldValidation * Remove unused context * Add documentation how to add wallets --------- Co-authored-by: keyan <keyan.kousha+huumn@gmail.com> Co-authored-by: Keyan <34140557+huumn@users.noreply.github.com>
252 lines
7.5 KiB
JavaScript
252 lines
7.5 KiB
JavaScript
import { useCallback, useMemo } from 'react'
|
|
import { useMe } from './me'
|
|
import { gql, useApolloClient, useMutation } from '@apollo/client'
|
|
import { useWallet } from 'wallets'
|
|
import { FAST_POLL_INTERVAL, JIT_INVOICE_TIMEOUT_MS } from '@/lib/constants'
|
|
import { INVOICE } from '@/fragments/wallet'
|
|
import Invoice from '@/components/invoice'
|
|
import { useFeeButton } from './fee-button'
|
|
import { useShowModal } from './modal'
|
|
|
|
export class InvoiceCanceledError extends Error {
|
|
constructor (hash, actionError) {
|
|
super(actionError ?? `invoice canceled: ${hash}`)
|
|
this.name = 'InvoiceCanceledError'
|
|
this.hash = hash
|
|
this.actionError = actionError
|
|
}
|
|
}
|
|
|
|
export class NoAttachedWalletError extends Error {
|
|
constructor () {
|
|
super('no attached wallet found')
|
|
this.name = 'NoAttachedWalletError'
|
|
}
|
|
}
|
|
|
|
export class InvoiceExpiredError extends Error {
|
|
constructor (hash) {
|
|
super(`invoice expired: ${hash}`)
|
|
this.name = 'InvoiceExpiredError'
|
|
}
|
|
}
|
|
|
|
export const useInvoice = () => {
|
|
const client = useApolloClient()
|
|
|
|
const [createInvoice] = useMutation(gql`
|
|
mutation createInvoice($amount: Int!, $expireSecs: Int!) {
|
|
createInvoice(amount: $amount, hodlInvoice: true, expireSecs: $expireSecs) {
|
|
id
|
|
bolt11
|
|
hash
|
|
hmac
|
|
expiresAt
|
|
satsRequested
|
|
}
|
|
}`)
|
|
const [cancelInvoice] = useMutation(gql`
|
|
mutation cancelInvoice($hash: String!, $hmac: String!) {
|
|
cancelInvoice(hash: $hash, hmac: $hmac) {
|
|
id
|
|
}
|
|
}
|
|
`)
|
|
|
|
const create = useCallback(async amount => {
|
|
const { data, error } = await createInvoice({ variables: { amount, expireSecs: JIT_INVOICE_TIMEOUT_MS / 1000 } })
|
|
if (error) {
|
|
throw error
|
|
}
|
|
const invoice = data.createInvoice
|
|
return invoice
|
|
}, [createInvoice])
|
|
|
|
const isInvoice = useCallback(async ({ id }, that) => {
|
|
const { data, error } = await client.query({ query: INVOICE, fetchPolicy: 'network-only', variables: { id } })
|
|
if (error) {
|
|
throw error
|
|
}
|
|
const { hash, cancelled, actionError } = data.invoice
|
|
|
|
if (cancelled || actionError) {
|
|
throw new InvoiceCanceledError(hash, actionError)
|
|
}
|
|
|
|
return that(data.invoice)
|
|
}, [client])
|
|
|
|
const waitController = useMemo(() => {
|
|
const controller = new AbortController()
|
|
const signal = controller.signal
|
|
controller.wait = async ({ id }, waitFor = inv => (inv.satsReceived > 0)) => {
|
|
return await new Promise((resolve, reject) => {
|
|
const interval = setInterval(async () => {
|
|
try {
|
|
const paid = await isInvoice({ id }, waitFor)
|
|
if (paid) {
|
|
resolve()
|
|
clearInterval(interval)
|
|
signal.removeEventListener('abort', abort)
|
|
} else {
|
|
console.info(`invoice #${id}: waiting for payment ...`)
|
|
}
|
|
} catch (err) {
|
|
reject(err)
|
|
clearInterval(interval)
|
|
signal.removeEventListener('abort', abort)
|
|
}
|
|
}, FAST_POLL_INTERVAL)
|
|
|
|
const abort = () => {
|
|
console.info(`invoice #${id}: stopped waiting`)
|
|
resolve()
|
|
clearInterval(interval)
|
|
signal.removeEventListener('abort', abort)
|
|
}
|
|
signal.addEventListener('abort', abort)
|
|
})
|
|
}
|
|
|
|
controller.stop = () => controller.abort()
|
|
|
|
return controller
|
|
}, [isInvoice])
|
|
|
|
const cancel = useCallback(async ({ hash, hmac }) => {
|
|
if (!hash || !hmac) {
|
|
throw new Error('missing hash or hmac')
|
|
}
|
|
|
|
console.log('canceling invoice:', hash)
|
|
const inv = await cancelInvoice({ variables: { hash, hmac } })
|
|
return inv
|
|
}, [cancelInvoice])
|
|
|
|
return { create, waitUntilPaid: waitController.wait, stopWaiting: waitController.stop, cancel }
|
|
}
|
|
|
|
export const useWalletPayment = () => {
|
|
const invoice = useInvoice()
|
|
const wallet = useWallet()
|
|
|
|
const waitForWalletPayment = useCallback(async ({ id, bolt11 }, waitFor) => {
|
|
if (!wallet) {
|
|
throw new NoAttachedWalletError()
|
|
}
|
|
try {
|
|
return await new Promise((resolve, reject) => {
|
|
// can't use await here since we might pay JIT invoices and sendPaymentAsync is not supported yet.
|
|
// see https://www.webln.guide/building-lightning-apps/webln-reference/webln.sendpaymentasync
|
|
wallet.sendPayment(bolt11)
|
|
// JIT invoice payments will never resolve here
|
|
// since they only get resolved after settlement which can't happen here
|
|
.then(resolve)
|
|
.catch(reject)
|
|
invoice.waitUntilPaid({ id }, waitFor)
|
|
.then(resolve)
|
|
.catch(reject)
|
|
})
|
|
} catch (err) {
|
|
console.error('payment failed:', err)
|
|
throw err
|
|
} finally {
|
|
invoice.stopWaiting()
|
|
}
|
|
}, [wallet, invoice])
|
|
|
|
return waitForWalletPayment
|
|
}
|
|
|
|
export const useQrPayment = () => {
|
|
const invoice = useInvoice()
|
|
const showModal = useShowModal()
|
|
|
|
const waitForQrPayment = useCallback(async (inv, walletError,
|
|
{
|
|
keepOpen = true,
|
|
cancelOnClose = true,
|
|
persistOnNavigate = false,
|
|
waitFor = inv => inv?.satsReceived > 0
|
|
} = {}
|
|
) => {
|
|
return await new Promise((resolve, reject) => {
|
|
let paid
|
|
const cancelAndReject = async (onClose) => {
|
|
if (!paid && cancelOnClose) {
|
|
await invoice.cancel(inv).catch(console.error)
|
|
reject(new InvoiceCanceledError(inv?.hash))
|
|
}
|
|
resolve()
|
|
}
|
|
showModal(onClose =>
|
|
<Invoice
|
|
id={inv.id}
|
|
modal
|
|
description
|
|
status='loading'
|
|
successVerb='received'
|
|
useWallet={false}
|
|
walletError={walletError}
|
|
waitFor={waitFor}
|
|
onCanceled={inv => { onClose(); reject(new InvoiceCanceledError(inv?.hash, inv?.actionError)) }}
|
|
onPayment={() => { paid = true; onClose(); resolve() }}
|
|
poll
|
|
/>,
|
|
{ keepOpen, persistOnNavigate, onClose: cancelAndReject })
|
|
})
|
|
}, [invoice])
|
|
|
|
return waitForQrPayment
|
|
}
|
|
|
|
export const usePayment = () => {
|
|
const me = useMe()
|
|
const feeButton = useFeeButton()
|
|
const invoice = useInvoice()
|
|
const waitForWalletPayment = useWalletPayment()
|
|
const waitForQrPayment = useQrPayment()
|
|
|
|
const waitForPayment = useCallback(async (invoice) => {
|
|
let walletError
|
|
try {
|
|
return await waitForWalletPayment(invoice)
|
|
} catch (err) {
|
|
if (err instanceof InvoiceCanceledError || err instanceof InvoiceExpiredError) {
|
|
// bail since qr code payment will also fail
|
|
throw err
|
|
}
|
|
walletError = err
|
|
}
|
|
return await waitForQrPayment(invoice, walletError)
|
|
}, [waitForWalletPayment, waitForQrPayment])
|
|
|
|
const request = useCallback(async (amount) => {
|
|
amount ??= feeButton?.total
|
|
const free = feeButton?.free
|
|
const balance = me ? me.privates.sats : 0
|
|
|
|
// if user has enough funds in their custodial wallet or action is free, never prompt for payment
|
|
// XXX this will probably not work as intended for deposits < balance
|
|
// which means you can't always fund your custodial wallet with attached wallets ...
|
|
// but should this even be the case?
|
|
const insufficientFunds = balance < amount
|
|
if (free || !insufficientFunds) return [{ hash: null, hmac: null }, null]
|
|
|
|
const inv = await invoice.create(amount)
|
|
|
|
await waitForPayment(inv)
|
|
|
|
const cancel = () => invoice.cancel(inv).catch(console.error)
|
|
return [inv, cancel]
|
|
}, [me, feeButton?.total, invoice, waitForPayment])
|
|
|
|
const cancel = useCallback(({ hash, hmac }) => {
|
|
if (hash && hmac) {
|
|
invoice.cancel({ hash, hmac }).catch(console.error)
|
|
}
|
|
}, [invoice])
|
|
|
|
return { request, cancel }
|
|
}
|