payment-kit 1.13.214 → 1.13.216

package/api/src/crons/index.ts

@@ -1,6 +1,6 @@
 import Cron from '@abtnode/cron';
 
-import { checkStakeRevokeTx } from '../integrations/blockchain/stake';
+import { checkStakeRevokeTx } from '../integrations/arcblock/stake';
 import {
   batchHandleStripeInvoices,
   batchHandleStripePayments,

package/api/src/index.ts

@@ -10,7 +10,7 @@ import express, { ErrorRequestHandler, Request, Response } from 'express';
 import morgan from 'morgan';
 
 import crons from './crons/index';
-import { ensureStakedForGas } from './integrations/blockchain/stake';
+import { ensureStakedForGas } from './integrations/arcblock/stake';
 import { initResourceHandler } from './integrations/blocklet/resource';
 import { ensureWebhookRegistered } from './integrations/stripe/setup';
 import { handlers } from './libs/auth';

package/api/src/integrations/{blockchain → arcblock}/stake.ts

@@ -185,11 +185,12 @@ export async function getStakeSummaryByDid(did: string, livemode: boolean): Prom
   const address = toStakeAddress(did, wallet.address);
   const results: GroupedBN = {};
   await Promise.all(
-    methods.map(async (method: any) => {
+    methods.map(async (method: PaymentMethod) => {
       const client = method.getOcapClient();
       const { state } = await client.getStakeState({ address });
       (state?.tokens || []).forEach((t: any) => {
-        const currency = method.payment_currencies.find((c: any) => t.address === c.contract);
+        // @ts-ignore
+        const currency = method.payment_currencies.find((c: PaymentCurrency) => t.address === c.contract);
         if (currency) {
           results[currency.id] = t.value;
         }
@@ -202,7 +203,7 @@ export async function getStakeSummaryByDid(did: string, livemode: boolean): Prom
 
 export async function getTokenSummaryByDid(did: string, livemode: boolean): Promise<GroupedBN> {
   const methods = await PaymentMethod.findAll({
-    where: { type: 'arcblock', livemode },
+    where: { type: ['arcblock', 'ethereum'], livemode },
     include: [{ model: PaymentCurrency, as: 'payment_currencies' }],
   });
   if (methods.length === 0) {
@@ -211,15 +212,21 @@ export async function getTokenSummaryByDid(did: string, livemode: boolean): Prom
 
   const results: GroupedBN = {};
   await Promise.all(
-    methods.map(async (method: any) => {
-      const client = method.getOcapClient();
-      const { tokens } = await client.getAccountTokens({ address: did });
-      (tokens || []).forEach((t: any) => {
-        const currency = method.payment_currencies.find((c: any) => t.address === c.contract);
-        if (currency) {
-          results[currency.id] = t.balance;
-        }
-      });
+    methods.map(async (method: PaymentMethod) => {
+      if (method.type === 'arcblock') {
+        const client = method.getOcapClient();
+        const { tokens } = await client.getAccountTokens({ address: did });
+        (tokens || []).forEach((t: any) => {
+          // @ts-ignore
+          const currency = method.payment_currencies.find((c: PaymentCurrency) => t.address === c.contract);
+          if (currency) {
+            results[currency.id] = t.balance;
+          }
+        });
+      }
+      if (method.type === 'ethereum') {
+        // FIXME: how do we get balance for ethereum
+      }
     })
   );
 

package/api/src/integrations/ethereum/token.ts

@@ -0,0 +1,141 @@
+import erc20Abi from 'erc-20-abi';
+import { JsonRpcProvider, TransactionReceipt, ethers } from 'ethers';
+
+import { ethWallet } from '../../libs/auth';
+import type { PaymentMethod } from '../../store/models/payment-method';
+import { waitForEvmTxReceipt } from './tx';
+
+export async function fetchErc20Meta(provider: JsonRpcProvider, contractAddress: string) {
+  const contract = new ethers.Contract(contractAddress, erc20Abi, provider);
+
+  // @ts-ignore
+  const [name, symbol, decimal] = await Promise.all([contract.name(), contract.symbol(), contract.decimals()]);
+
+  return { name, symbol, decimal: decimal.toNumber() };
+}
+
+export async function fetchErc20Balance(provider: JsonRpcProvider, contractAddress: string, account: string) {
+  const contract = new ethers.Contract(contractAddress, erc20Abi, provider);
+
+  // @ts-ignore
+  const balance = await contract.balanceOf(account);
+  return balance.toString();
+}
+
+export async function fetchErc20Allowance(
+  provider: JsonRpcProvider,
+  contractAddress: string,
+  owner: string,
+  spender: string
+) {
+  const contract = new ethers.Contract(contractAddress, erc20Abi, provider);
+
+  // @ts-ignore
+  const allowance = await contract.allowance(owner, spender);
+  return allowance.toString();
+}
+
+export async function fetchEtherBalance(provider: JsonRpcProvider, account: string) {
+  const balance = await provider.getBalance(account);
+  return balance.toString();
+}
+
+export function encodeErc20Transfer(to: string, amount: string) {
+  const iface = new ethers.Interface(erc20Abi);
+  return iface.encodeFunctionData('transfer', [to, amount]);
+}
+
+export function encodeErc20Approve(spender: string, allowance: string) {
+  const iface = new ethers.Interface(erc20Abi);
+  return iface.encodeFunctionData('approve', [spender, allowance] as any);
+}
+
+export function encodeTransferItx(to: string, amount: string, contract?: string) {
+  // Sending ERC20
+  if (contract) {
+    return {
+      to: contract,
+      value: '0',
+      gasLimit: '120000',
+      data: encodeErc20Transfer(to, amount),
+    };
+  }
+
+  // Sending Ether
+  return {
+    to,
+    value: amount,
+    gasLimit: '21000',
+    data: '',
+  };
+}
+
+export function encodeApproveItx(spender: string, allowance: string, contract: string) {
+  return {
+    to: contract,
+    value: '0',
+    gasLimit: '120000', // FIXME: make me dynamic
+    data: encodeErc20Approve(spender, allowance),
+  };
+}
+
+// capture payments
+export async function transferErc20FromUser(
+  provider: JsonRpcProvider,
+  contractAddress: string,
+  user: string,
+  amount: string
+): Promise<TransactionReceipt> {
+  const wallet = new ethers.Wallet(ethWallet.secretKey);
+  const signer = wallet.connect(provider);
+  const contract = new ethers.Contract(contractAddress, erc20Abi, signer);
+
+  // @ts-ignore
+  const res = await contract.transferFrom(user, wallet.address, amount);
+
+  // Wait for the transaction to be mined
+  const receipt = await res.wait();
+  return receipt;
+}
+
+// do refunds
+export async function sendErc20ToUser(
+  provider: JsonRpcProvider,
+  contractAddress: string,
+  user: string,
+  amount: string
+): Promise<TransactionReceipt> {
+  const wallet = new ethers.Wallet(ethWallet.secretKey);
+  const signer = wallet.connect(provider);
+  const contract = new ethers.Contract(contractAddress, erc20Abi, signer);
+
+  // @ts-ignore
+  const res = await contract.transfer(user, amount);
+
+  // Wait for the transaction to be mined
+  const receipt = await res.wait();
+  return receipt;
+}
+
+export async function executeEvmTransactions(
+  type: string,
+  userDid: string,
+  claims: any[],
+  paymentMethod: PaymentMethod
+) {
+  const client = paymentMethod.getEvmClient();
+  const claim = claims.find((x) => x.type === 'signature');
+  const receipt = await waitForEvmTxReceipt(client, claim.hash);
+  if (!receipt.status) {
+    throw new Error(`EVM Transaction failed: ${claim.hash}`);
+  }
+
+  return {
+    type,
+    tx_hash: claim.hash,
+    payer: userDid,
+    block_height: receipt.blockNumber.toString(),
+    gas_used: receipt.gasUsed.toString(),
+    gas_price: receipt.gasPrice.toString(),
+  };
+}

package/api/src/integrations/ethereum/tx.ts

@@ -0,0 +1,32 @@
+import type { JsonRpcProvider, TransactionReceipt, TransactionResponse } from 'ethers';
+import waitFor from 'p-wait-for';
+
+import logger from '../../libs/logger';
+
+export async function waitForEvmTxReceipt(provider: JsonRpcProvider, txHash: string) {
+  let minted: TransactionResponse;
+  let receipt: TransactionReceipt;
+
+  await waitFor(
+    async () => {
+      // @ts-ignore
+      minted = await provider.getTransaction(txHash);
+      logger.info('waitForTxReceipt.mintCheck', minted);
+      return !!minted?.blockNumber;
+    },
+    { interval: 3000, timeout: 30 * 60 * 1000 }
+  );
+
+  await waitFor(
+    async () => {
+      // @ts-ignore
+      receipt = await provider.getTransactionReceipt(txHash);
+      logger.info('waitForTxReceipt.receiptCheck', receipt);
+      return !!receipt;
+    },
+    { interval: 1000, timeout: 60 * 1000 }
+  );
+
+  // @ts-ignore
+  return receipt;
+}

package/api/src/libs/auth.ts

@@ -11,6 +11,7 @@ import type { LiteralUnion } from 'type-fest';
 import env from './env';
 
 export const wallet = getWallet();
+export const ethWallet = getWallet('ethereum');
 export const authenticator = new WalletAuthenticator();
 export const handlers = new WalletHandler({
   authenticator,

package/api/src/libs/payment.ts

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/indent */
+import { isEthereumDid } from '@arcblock/did';
 import { toDelegateAddress } from '@arcblock/did-util';
 import { sign } from '@arcblock/jwt';
 import { getWalletDid } from '@blocklet/sdk/lib/did';
@@ -8,9 +9,10 @@ import { BN, fromUnitToToken } from '@ocap/util';
 import cloneDeep from 'lodash/cloneDeep';
 import type { LiteralUnion } from 'type-fest';
 
+import { fetchErc20Allowance, fetchErc20Balance, fetchEtherBalance } from '../integrations/ethereum/token';
 import { Invoice, PaymentCurrency, PaymentIntent, PaymentMethod, TCustomer, TLineItemExpanded } from '../store/models';
 import type { TPaymentCurrency } from '../store/models/payment-currency';
-import { blocklet, wallet } from './auth';
+import { blocklet, ethWallet, wallet } from './auth';
 import { OCAP_PAYMENT_TX_TYPE } from './util';
 
 export interface SufficientForPaymentResult {
@@ -101,6 +103,28 @@ export async function isDelegationSufficientForPayment(args: {
     return { sufficient: false, reason: 'NOT_SUPPORTED' };
   }
 
+  if (paymentMethod.type === 'ethereum') {
+    if (!paymentCurrency.contract) {
+      return { sufficient: false, reason: 'NOT_SUPPORTED' };
+    }
+    if (isEthereumDid(userDid) === false) {
+      return { sufficient: false, reason: 'NOT_SUPPORTED' };
+    }
+
+    const provider = paymentMethod.getEvmClient();
+    const balance = await fetchErc20Balance(provider, paymentCurrency.contract, userDid);
+    if (new BN(balance).lt(new BN(amount))) {
+      return { sufficient: false, reason: 'NO_ENOUGH_TOKEN' };
+    }
+
+    const allowance = await fetchErc20Allowance(provider, paymentCurrency.contract, userDid, ethWallet.address);
+    if (new BN(allowance).lt(new BN(amount))) {
+      return { sufficient: false, reason: 'NO_ENOUGH_ALLOWANCE' };
+    }
+
+    return { sufficient: true };
+  }
+
   throw new Error(`Payment method ${paymentMethod.type} not supported`);
 }
 
@@ -207,9 +231,6 @@ export async function getTokenLimitsForDelegation(
   address: string,
   amount: string
 ): Promise<TokenLimit[]> {
-  const client = paymentMethod.getOcapClient();
-  const { state } = await client.getDelegateState({ address });
-
   const hasMetered = items.some((x) => x.price.recurring?.usage_type === 'metered');
   const allowance = hasMetered ? '0' : amount;
 
@@ -223,40 +244,53 @@ export async function getTokenLimitsForDelegation(
     validUntil: 0,
   };
 
-  // If we never delegated before
-  if (!state) {
-    return [entry];
-  }
+  if (paymentMethod.type === 'arcblock') {
+    const client = paymentMethod.getOcapClient();
+    const { state } = await client.getDelegateState({ address });
 
-  // If we have metered items, we should not limit tx allowance(set to 0)
-  if (hasMetered) {
-    return [entry];
-  }
+    // If we never delegated before
+    if (!state) {
+      return [entry];
+    }
+
+    // If we have metered items, we should not limit tx allowance(set to 0)
+    if (hasMetered) {
+      return [entry];
+    }
 
-  const op = (state as DelegateState).ops.find((x) => x.key === OCAP_PAYMENT_TX_TYPE);
-  if (op && Array.isArray(op.value.limit?.tokens) && op.value.limit.tokens.length > 0) {
-    const tokenLimits = cloneDeep(op.value.limit.tokens);
-    const index = op.value.limit.tokens.findIndex((x) => x.address === paymentCurrency.contract);
-    // we are updating an existing token limit
-    if (index > -1) {
-      const limit = op.value.limit.tokens[index] as TokenLimit;
-      // If we have a previous delegation and the txAllowance is smaller than requested amount
-      // If txAllowance is 0 (unlimited), we should not update it
-      if (limit.txAllowance !== '0' && new BN(limit.txAllowance).lt(new BN(amount))) {
-        tokenLimits[index] = entry;
+    const op = (state as DelegateState).ops.find((x) => x.key === OCAP_PAYMENT_TX_TYPE);
+    if (op && Array.isArray(op.value.limit?.tokens) && op.value.limit.tokens.length > 0) {
+      const tokenLimits = cloneDeep(op.value.limit.tokens);
+      const index = op.value.limit.tokens.findIndex((x) => x.address === paymentCurrency.contract);
+      // we are updating an existing token limit
+      if (index > -1) {
+        const limit = op.value.limit.tokens[index] as TokenLimit;
+        // If we have a previous delegation and the txAllowance is smaller than requested amount
+        // If txAllowance is 0 (unlimited), we should not update it
+        if (limit.txAllowance !== '0' && new BN(limit.txAllowance).lt(new BN(amount))) {
+          tokenLimits[index] = entry;
+        }
+      } else {
+        // we are adding a new token limit
+        tokenLimits.push(entry);
       }
-    } else {
-      // we are adding a new token limit
-      tokenLimits.push(entry);
+
+      return tokenLimits;
     }
 
-    return tokenLimits;
+    return [entry];
   }
 
-  return [entry];
+  if (paymentMethod.type === 'ethereum') {
+    // FIXME: @wangshijun better control from customer.token_limits
+    entry.totalAllowance = new BN(amount).mul(new BN(12)).toString();
+    return [entry];
+  }
+
+  throw new Error(`getTokenLimitsForDelegation: Payment method ${paymentMethod.type} not supported`);
 }
 
-export async function isBalanceSufficientForPayment(args: {
+export async function isBalanceSufficientForRefund(args: {
   paymentMethod: PaymentMethod;
   paymentCurrency: TPaymentCurrency;
   amount: string;
@@ -278,9 +312,21 @@ export async function isBalanceSufficientForPayment(args: {
     return { sufficient: true, token };
   }
 
+  if (paymentMethod.type === 'ethereum') {
+    const provider = paymentMethod.getEvmClient();
+    const balance = paymentCurrency.contract
+      ? await fetchErc20Balance(provider, paymentCurrency.contract, ethWallet.address)
+      : await fetchEtherBalance(provider, ethWallet.address);
+    if (new BN(balance).lt(new BN(amount))) {
+      return { sufficient: false, reason: 'NO_ENOUGH_TOKEN' };
+    }
+
+    return { sufficient: true };
+  }
+
   if (paymentMethod.type === 'stripe') {
     return { sufficient: false, reason: 'NOT_SUPPORTED' };
   }
 
-  throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  throw new Error(`isBalanceSufficientForRefund: Payment method ${paymentMethod.type} not supported`);
 }

package/api/src/queues/checkout-session.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-await-in-loop */
 import { Op } from 'sequelize';
 
-import { mintNftForCheckoutSession } from '../integrations/blockchain/nft';
+import { mintNftForCheckoutSession } from '../integrations/arcblock/nft';
 import { ensurePassportIssued } from '../integrations/blocklet/passport';
 import dayjs from '../libs/dayjs';
 import { events } from '../libs/event';

package/api/src/queues/payment.ts

@@ -1,6 +1,7 @@
 import isEmpty from 'lodash/isEmpty';
 
-import { ensureStakedForGas } from '../integrations/blockchain/stake';
+import { ensureStakedForGas } from '../integrations/arcblock/stake';
+import { transferErc20FromUser } from '../integrations/ethereum/token';
 import { createEvent } from '../libs/audit';
 import { blocklet, wallet } from '../libs/auth';
 import dayjs from '../libs/dayjs';
@@ -415,69 +416,113 @@ export const handlePayment = async (job: PaymentJob) => {
   }
 
   // try payment capture and reschedule on error
-  logger.info('PaymentIntent capture attempt', { id: paymentIntent.id });
+  logger.info('PaymentIntent capture attempt', { id: paymentIntent.id, attempt: invoice?.attempt_count });
   let result;
   try {
     await paymentIntent.update({ status: 'processing', last_payment_error: null });
+    if (paymentMethod.type === 'arcblock') {
+      const client = paymentMethod.getOcapClient();
+      const payer = paymentSettings?.payment_method_options.arcblock?.payer;
+
+      // check balance before capture with transaction
+      result = await isDelegationSufficientForPayment({
+        paymentMethod,
+        paymentCurrency,
+        userDid: payer as string,
+        amount: paymentIntent.amount,
+      });
+      if (result.sufficient === false) {
+        logger.error('PaymentIntent capture aborted on preCheck', { id: paymentIntent.id, result });
+        throw new CustomError(result.reason, 'payer balance or delegation not sufficient for this payment');
+      }
 
-    const client = paymentMethod.getOcapClient();
-    const payer = paymentSettings?.payment_method_options.arcblock?.payer;
+      // do the capture
+      const signed = await client.signTransferV2Tx({
+        tx: {
+          itx: {
+            to: wallet.address,
+            value: '0',
+            assets: [],
+            tokens: [{ address: paymentCurrency.contract, value: paymentIntent.amount }],
+            data: {
+              typeUrl: 'json',
+              // @ts-ignore
+              value: {
+                appId: wallet.address,
+                reason: invoice ? invoice.billing_reason : 'payment',
+                paymentIntentId: paymentIntent.id,
+              },
+            },
+          },
+        },
+        wallet,
+        delegator: payer,
+      });
+      // @ts-ignore
+      const { buffer } = await client.encodeTransferV2Tx({ tx: signed });
+      // @ts-ignore
+      const txHash = await client.sendTransferV2Tx({ tx: signed, wallet, delegator: payer }, getGasPayerExtra(buffer));
+
+      logger.info('PaymentIntent capture done', { id: paymentIntent.id, txHash });
+
+      await paymentIntent.update({
+        status: 'succeeded',
+        last_payment_error: null,
+        amount_received: paymentIntent.amount,
+        payment_details: {
+          arcblock: {
+            tx_hash: txHash,
+            payer: payer as string,
+            type: 'transfer',
+          },
+        },
+      });
 
-    // check balance before capture with transaction
-    result = await isDelegationSufficientForPayment({
-      paymentMethod,
-      paymentCurrency,
-      userDid: payer as string,
-      amount: paymentIntent.amount,
-    });
-    if (result.sufficient === false) {
-      logger.error('PaymentIntent capture aborted on preCheck', { id: paymentIntent.id, result });
-      throw new CustomError(result.reason, 'payer balance or delegation not sufficient for this payment');
+      await handlePaymentSucceed(paymentIntent);
     }
 
-    // do the capture
-    const signed = await client.signTransferV2Tx({
-      tx: {
-        itx: {
-          to: wallet.address,
-          value: '0',
-          assets: [],
-          tokens: [{ address: paymentCurrency.contract, value: paymentIntent.amount }],
-          data: {
-            typeUrl: 'json',
-            // @ts-ignore
-            value: {
-              appId: wallet.address,
-              reason: invoice ? invoice.billing_reason : 'payment',
-              paymentIntentId: paymentIntent.id,
-            },
+    if (paymentMethod.type === 'ethereum') {
+      if (!paymentCurrency.contract) {
+        throw new Error('Payment capture not supported for ethereum payment currencies without contract');
+      }
+
+      const client = paymentMethod.getEvmClient();
+      const payer = paymentSettings?.payment_method_options.ethereum?.payer as string;
+
+      // check balance before capture with transaction
+      result = await isDelegationSufficientForPayment({
+        paymentMethod,
+        paymentCurrency,
+        userDid: payer as string,
+        amount: paymentIntent.amount,
+      });
+      if (result.sufficient === false) {
+        logger.error('PaymentIntent capture aborted on preCheck', { id: paymentIntent.id, result });
+        throw new CustomError(result.reason, 'payer balance or delegation not sufficient for this payment');
+      }
+
+      // do the capture
+      const receipt = await transferErc20FromUser(client, paymentCurrency.contract, payer, paymentIntent.amount);
+      logger.info('PaymentIntent capture done', { id: paymentIntent.id, txHash: receipt.hash });
+
+      await paymentIntent.update({
+        status: 'succeeded',
+        last_payment_error: null,
+        amount_received: paymentIntent.amount,
+        payment_details: {
+          ethereum: {
+            tx_hash: receipt.hash,
+            payer: payer as string,
+            block_height: receipt.blockNumber.toString(),
+            gas_used: receipt.gasUsed.toString(),
+            gas_price: receipt.gasPrice.toString(),
+            type: 'transfer',
           },
         },
-      },
-      wallet,
-      delegator: payer,
-    });
-    // @ts-ignore
-    const { buffer } = await client.encodeTransferV2Tx({ tx: signed });
-    // @ts-ignore
-    const txHash = await client.sendTransferV2Tx({ tx: signed, wallet, delegator: payer }, getGasPayerExtra(buffer));
-
-    logger.info('PaymentIntent capture done', { id: paymentIntent.id, txHash });
-
-    await paymentIntent.update({
-      status: 'succeeded',
-      last_payment_error: null,
-      amount_received: paymentIntent.amount,
-      payment_details: {
-        arcblock: {
-          tx_hash: txHash,
-          payer: payer as string,
-          type: 'transfer',
-        },
-      },
-    });
+      });
 
-    await handlePaymentSucceed(paymentIntent);
+      await handlePaymentSucceed(paymentIntent);
+    }
   } catch (err) {
     logger.error('PaymentIntent capture failed', { error: err, id: paymentIntent.id });