payment-kit 1.19.0 → 1.19.2

package/api/src/routes/meters.ts

@@ -0,0 +1,219 @@
+import { Router } from 'express';
+import Joi from 'joi';
+import pick from 'lodash/pick';
+
+import { Op } from 'sequelize';
+import { createListParamSchema, getOrder, getWhereFromKvQuery, MetadataSchema } from '../libs/api';
+import logger from '../libs/logger';
+import { authenticate } from '../libs/security';
+import { formatMetadata } from '../libs/util';
+import { Meter, PaymentCurrency, PaymentMethod } from '../store/models';
+
+const router = Router();
+const auth = authenticate<Meter>({ component: true, roles: ['owner', 'admin'] });
+
+const meterSchema = Joi.object({
+  name: Joi.string().max(64).required(),
+  event_name: Joi.string().max(64).required(),
+  aggregation_method: Joi.string().valid('sum', 'count', 'last').default('sum'),
+  unit: Joi.string().max(32).required(),
+  currency_id: Joi.string().max(40).optional(),
+  description: Joi.string().max(255).allow('').optional(),
+  metadata: MetadataSchema,
+  component_did: Joi.string().max(40).optional(),
+}).unknown(true);
+
+const updateMeterSchema = Joi.object({
+  name: Joi.string().max(64).optional(),
+  description: Joi.string().max(255).allow('').optional(),
+  status: Joi.string().valid('active', 'inactive').optional(),
+});
+
+const listSchema = createListParamSchema<{ event_name?: string }>({
+  event_name: Joi.string().empty(''),
+});
+
+router.get('/', auth, async (req, res) => {
+  try {
+    const { page, pageSize, ...query } = await listSchema.validateAsync(req.query, { stripUnknown: true });
+    const where = getWhereFromKvQuery(query.q);
+
+    if (typeof query.livemode === 'boolean') {
+      where.livemode = query.livemode;
+    }
+    if (query.event_name) {
+      where.event_name = query.event_name;
+    }
+
+    const { rows: list, count } = await Meter.findAndCountAll({
+      where,
+      order: getOrder(query, [['created_at', query.o === 'asc' ? 'ASC' : 'DESC']]),
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+    });
+
+    res.json({ count, list, paging: { page, pageSize } });
+  } catch (err) {
+    logger.error('Error listing meters', err);
+    res.status(400).json({ error: err?.message });
+  }
+});
+
+router.post('/', auth, async (req, res) => {
+  try {
+    const { error } = meterSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ error: `Meter create request invalid: ${error.message}` });
+    }
+
+    const existing = await Meter.findOne({
+      where: { event_name: req.body.event_name, livemode: !!req.livemode },
+    });
+    if (existing) {
+      return res.status(409).json({ error: `Meter with event_name "${req.body.event_name}" already exists` });
+    }
+
+    if (['count', 'last'].includes(req.body.aggregation_method)) {
+      return res.status(400).json({ error: 'Aggregation method is not supported' });
+    }
+
+    const meterData = {
+      ...pick(req.body, ['name', 'event_name', 'aggregation_method', 'unit', 'currency_id', 'description', 'metadata']),
+      livemode: !!req.livemode,
+      created_via: req.user?.via || 'api',
+      status: req.body.status || 'active',
+      metadata: formatMetadata(req.body.metadata),
+    };
+
+    if (!meterData.currency_id) {
+      const paymentMethod = await PaymentMethod.findOne({
+        where: {
+          livemode: !!req.livemode,
+          type: 'arcblock',
+        },
+      });
+      if (!paymentMethod) {
+        return res.status(400).json({ error: 'Payment method not found' });
+      }
+
+      const paymentCurrency = await PaymentCurrency.createForMeter(meterData, paymentMethod.id);
+      meterData.currency_id = paymentCurrency.id;
+    }
+
+    const meter = await Meter.create(meterData);
+
+    const result = await Meter.findByPk(meter.id, {
+      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+    });
+
+    logger.info('Meter created', { meterId: meter.id, eventName: meter.event_name });
+    return res.json(result);
+  } catch (err) {
+    logger.error('create meter failed', { error: err?.message, request: req.body });
+    return res.status(400).json({ error: err?.message });
+  }
+});
+
+router.get('/:id', auth, async (req, res) => {
+  try {
+    const meter = await Meter.findOne({
+      where: {
+        [Op.or]: [{ id: req.params.id }, { event_name: req.params.id }],
+      },
+      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+    });
+
+    if (!meter) {
+      return res.status(404).json({ error: 'Meter not found' });
+    }
+
+    return res.json(meter);
+  } catch (err) {
+    logger.error('get meter failed', { error: err?.message, meterId: req.params.id });
+    return res.status(400).json({ error: err?.message });
+  }
+});
+
+router.put('/:id', auth, async (req, res) => {
+  try {
+    const { error } = updateMeterSchema.validate(pick(req.body, ['name', 'description', 'status']));
+    if (error) {
+      return res.status(400).json({ error: `Meter update request invalid: ${error.message}` });
+    }
+
+    const meter = await Meter.findByPk(req.params.id, {
+      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+    });
+    if (!meter) {
+      return res.status(404).json({ error: 'Meter not found' });
+    }
+
+    const updateData: any = {
+      ...pick(req.body, ['name', 'description', 'status']),
+      updated_by: req.user?.did,
+    };
+
+    if (req.body.metadata) {
+      updateData.metadata = formatMetadata(req.body.metadata);
+    }
+
+    await meter.update(updateData);
+
+    return res.json(meter);
+  } catch (err) {
+    logger.error('update meter failed', { error: err?.message, meterId: req.params.id });
+    return res.status(400).json({ error: err?.message });
+  }
+});
+
+router.put('/:id/activate', auth, async (req, res) => {
+  try {
+    const meter = await Meter.findByPk(req.params.id, {
+      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+    });
+    if (!meter) {
+      return res.status(404).json({ error: 'Meter not found' });
+    }
+
+    if (meter.status === 'active') {
+      return res.status(400).json({ error: 'Meter is already active' });
+    }
+
+    await meter.update({
+      status: 'active',
+      updated_by: req.user?.did,
+    });
+    return res.json(meter);
+  } catch (err) {
+    logger.error('activate meter failed', { error: err?.message, meterId: req.params.id });
+    return res.status(400).json({ error: err?.message });
+  }
+});
+
+router.put('/:id/deactivate', auth, async (req, res) => {
+  try {
+    const meter = await Meter.findByPk(req.params.id, {
+      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+    });
+    if (!meter) {
+      return res.status(404).json({ error: 'Meter not found' });
+    }
+
+    if (meter.status === 'inactive') {
+      return res.status(400).json({ error: 'Meter is already inactive' });
+    }
+
+    await meter.update({
+      status: 'inactive',
+      updated_by: req.user?.did,
+    });
+
+    return res.json(meter);
+  } catch (err) {
+    logger.error('deactivate meter failed', { error: err?.message, meterId: req.params.id });
+    return res.status(400).json({ error: err?.message });
+  }
+});
+
+export default router;

package/api/src/routes/payment-currencies.ts

@@ -3,6 +3,7 @@ import { Router } from 'express';
 import { InferAttributes, Op, WhereOptions } from 'sequelize';
 
 import Joi from 'joi';
+import pick from 'lodash/pick';
 import { fetchErc20Meta } from '../integrations/ethereum/token';
 import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
@@ -19,9 +20,18 @@ const router = Router();
 
 const auth = authenticate<PaymentCurrency>({ component: true, roles: ['owner', 'admin'] });
 const authOwner = authenticate<PaymentCurrency>({ component: true, roles: ['owner'] });
+const paymentCurrencyCreateSchema = Joi.object({
+  name: Joi.string().max(32).required(),
+  description: Joi.string().max(255).required(),
+}).unknown(true);
 router.post('/', auth, async (req, res) => {
   const raw: Partial<TPaymentCurrency> = req.body;
 
+  const { error } = paymentCurrencyCreateSchema.validate(pick(req.body, ['name', 'description']));
+  if (error) {
+    return res.status(400).json({ error: error.message });
+  }
+
   if (!raw.payment_method_id) {
     return res.status(400).json({ error: 'payment_method_id is required' });
   }
@@ -73,6 +83,7 @@ router.post('/', auth, async (req, res) => {
         logo: raw.logo,
         symbol: info.symbol,
         decimal: info.decimal,
+        type: 'standard',
 
         // FIXME: make these configurable
         minimum_payment_amount: fromTokenToUnit(0.000001, info.decimal).toString(),
@@ -109,6 +120,7 @@ router.post('/', auth, async (req, res) => {
         logo: raw.logo,
         symbol: state.symbol,
         decimal: state.decimal,
+        type: 'standard',
 
         // FIXME: make these configurable
         minimum_payment_amount: fromTokenToUnit(0.000001, state.decimal).toString(),
@@ -136,6 +148,12 @@ router.get('/', auth, async (req, res) => {
   if (typeof query.livemode === 'string') {
     where.livemode = JSON.parse(query.livemode);
   }
+  where.type = 'standard';
+  if (query.credit) {
+    where.type = {
+      [Op.in]: ['standard', 'credit'],
+    };
+  }
   const list = await PaymentCurrency.findAll({
     where,
     order: [['created_at', 'DESC']],
@@ -283,8 +301,8 @@ router.put('/:id/vault-config', authOwner, async (req, res) => {
 });
 
 const updateCurrencySchema = Joi.object({
-  name: Joi.string().empty('').optional(),
-  description: Joi.string().empty('').optional(),
+  name: Joi.string().empty('').max(32).optional(),
+  description: Joi.string().empty('').max(255).optional(),
   logo: Joi.string().empty('').optional(),
 }).unknown(true);
 router.put('/:id', auth, async (req, res) => {

package/api/src/routes/payment-links.ts

@@ -132,7 +132,7 @@ export async function createPaymentLink(payload: any) {
   }
 
   const items = await Price.expand(raw.line_items);
-  if (items.find((x) => x.price.custom_unit_amount) && items.length > 1) {
+  if (items.find((x) => x.price?.custom_unit_amount) && items.length > 1) {
     throw new Error('Multiple items with custom unit amount are not supported in payment link');
   }
 

package/api/src/routes/payment-methods.ts

@@ -21,12 +21,21 @@ const router = Router();
 
 const auth = authenticate<PaymentMethod>({ component: true, roles: ['owner', 'admin'] });
 
+const paymentMethodCreateSchema = Joi.object({
+  name: Joi.string().max(32).required(),
+  description: Joi.string().max(255).required(),
+}).unknown(true);
+
 router.post('/', auth, async (req, res) => {
   const raw: Partial<TPaymentMethod> = req.body;
 
   raw.livemode = req.livemode;
   raw.locked = false;
   raw.active = true;
+  const { error } = paymentMethodCreateSchema.validate(pick(req.body, ['name', 'description']));
+  if (error) {
+    return res.status(400).json({ error: error.message });
+  }
 
   if (!raw.name) {
     return res.status(400).json({ error: 'payment method name is required' });
@@ -77,12 +86,14 @@ router.post('/', auth, async (req, res) => {
       locked: true,
       is_base_currency: false,
       payment_method_id: method.id,
+      type: 'standard',
 
       name: 'Dollar',
       description: 'US Dollar',
       logo: getUrl('/currencies/dollar.png'),
       symbol: 'USD', // same currency code as stripe
       decimal: 2,
+      maximum_precision: 2,
 
       minimum_payment_amount: '1', // cent
       maximum_payment_amount: '100000000000', // billion
@@ -153,6 +164,7 @@ router.post('/', auth, async (req, res) => {
       locked: true,
       is_base_currency: false,
       payment_method_id: method.id,
+      type: 'standard',
 
       name: symbol,
       description: symbol,
@@ -285,8 +297,8 @@ router.put('/:id/settings', auth, async (req, res) => {
 });
 
 const updateMethodSchema = Joi.object({
-  name: Joi.string().empty('').optional(),
-  description: Joi.string().empty('').optional(),
+  name: Joi.string().empty('').max(32).optional(),
+  description: Joi.string().empty('').max(255).optional(),
   logo: Joi.string().empty('').optional(),
 }).unknown(true);
 router.put('/:id', auth, async (req, res) => {

package/api/src/routes/prices.ts

@@ -12,11 +12,21 @@ import { PaymentCurrency } from '../store/models/payment-currency';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
 import { checkCurrencySupportRecurring } from '../libs/product';
+import { Meter } from '../store/models';
 
 const router = Router();
 
 const auth = authenticate<Price>({ component: true, roles: ['owner', 'admin'] });
 
+const CreditConfigSchema = Joi.object({
+  valid_duration_value: Joi.number().default(0).optional(),
+  valid_duration_unit: Joi.string().valid('hours', 'days', 'weeks', 'months', 'years').default('days').optional(),
+  priority: Joi.number().min(0).max(100).default(50).optional(),
+  applicable_prices: Joi.array().items(Joi.string()).default([]).optional(),
+  credit_amount: Joi.number().greater(0).required(),
+  currency_id: Joi.string().required(),
+});
+
 export async function getExpandedPrice(id: string) {
   const price = await Price.findByPkOrLookupKey(id, {
     include: [
@@ -37,6 +47,10 @@ export async function getExpandedPrice(id: string) {
       }
     }
 
+    if (doc.recurring?.meter_id) {
+      // @ts-ignore
+      doc.meter = await Meter.findByPk(doc.recurring?.meter_id);
+    }
     return doc;
   }
 
@@ -143,6 +157,18 @@ export async function createPrice(payload: any) {
     throw new Error(`product ${raw.product_id} not found for price`);
   }
 
+  if (product.type === 'credit') {
+    const creditConfig = raw.metadata.credit_config;
+    if (!creditConfig) {
+      throw new Error('credit_config is required');
+    }
+    const { error, value: creditConfigValue } = CreditConfigSchema.validate(creditConfig);
+    if (error) {
+      throw new Error(`credit_config is invalid: ${error.message}`);
+    }
+    raw.metadata.credit_config = creditConfigValue;
+  }
+
   const currencies = await PaymentCurrency.findAll({ where: { active: true } });
   const currency = currencies.find((x) => x.id === raw.currency_id);
   if (!currency) {
@@ -296,6 +322,11 @@ router.put('/:id', auth, async (req, res) => {
     return res.status(404).json({ error: 'price not found' });
   }
 
+  const product = await Product.findByPk(doc.product_id);
+  if (!product) {
+    return res.status(404).json({ error: 'product not found' });
+  }
+
   if (doc.active === false) {
     return res.status(403).json({ error: 'price archived' });
   }
@@ -326,6 +357,18 @@ router.put('/:id', auth, async (req, res) => {
     }
   }
 
+  if (product.type === 'credit' && updates.metadata) {
+    const creditConfig = updates.metadata.credit_config;
+    if (!creditConfig) {
+      return res.status(400).json({ error: 'credit_config is required' });
+    }
+    const { error: creditConfigError, value: creditConfigValue } = CreditConfigSchema.validate(creditConfig);
+    if (creditConfigError) {
+      return res.status(400).json({ error: `credit_config is invalid: ${creditConfigError.message}` });
+    }
+    updates.metadata.credit_config = creditConfigValue;
+  }
+
   const currencies = await PaymentCurrency.findAll({ where: { active: true } });
   const currency =
     currencies.find((x) => x.id === updates?.currency_id || '') || currencies.find((x) => x.id === doc.currency_id);

package/api/src/routes/pricing-table.ts

@@ -11,7 +11,7 @@ import { checkPassportForPricingTable } from '../integrations/blocklet/passport'
 import { createListParamSchema, getOrder, MetadataSchema } from '../libs/api';
 import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
-import { getBillingThreshold, getMinStakeAmount, isLineItemCurrencyAligned } from '../libs/session';
+import { getBillingThreshold, getMinStakeAmount, isCreditMetered, isLineItemCurrencyAligned } from '../libs/session';
 import { getDaysUntilCancel, getDaysUntilDue } from '../libs/subscription';
 import { getDataObjectFromQuery } from '../libs/util';
 import { CheckoutSession } from '../store/models/checkout-session';
@@ -292,13 +292,18 @@ router.post('/:id/checkout/:priceId', async (req, res) => {
     return res.status(403).json({ error: 'pricing table locked' });
   }
 
-  const price = await doc.items.find((x) => x.price_id === req.params.priceId);
-  if (!price) {
+  const lineItem = await doc.items.find((x) => x.price_id === req.params.priceId);
+  if (!lineItem) {
     return res.status(403).json({ error: 'pricing table item not valid' });
   }
 
+  const price = await Price.findByPk(lineItem.price_id);
+  if (!price) {
+    return res.status(403).json({ error: 'price not found' });
+  }
+
   const raw: Partial<CheckoutSession> = await formatCheckoutSession({
-    line_items: [{ price_id: price.price_id, quantity: 1, adjustable_quantity: price.adjustable_quantity }],
+    line_items: [{ price_id: lineItem.price_id, quantity: 1, adjustable_quantity: lineItem.adjustable_quantity }],
     ...pick(price, [
       'allow_promotion_codes',
       'consent_collection',
@@ -311,9 +316,10 @@ router.post('/:id/checkout/:priceId', async (req, res) => {
       'cross_sell_behavior',
       'nft_mint_settings',
     ]),
-    subscription_data: merge(price.subscription_data || {}, getDataObjectFromQuery(req.query, 'subscription_data'), {
-      billing_threshold_amount: getBillingThreshold(price.subscription_data),
-      min_stake_amount: getMinStakeAmount(price.subscription_data),
+    subscription_data: merge(lineItem.subscription_data || {}, getDataObjectFromQuery(req.query, 'subscription_data'), {
+      billing_threshold_amount: getBillingThreshold(lineItem.subscription_data),
+      min_stake_amount: getMinStakeAmount(lineItem.subscription_data),
+      no_stake: isCreditMetered(price),
     }),
     metadata: {
       ...doc.metadata,

package/api/src/routes/products.ts

@@ -21,7 +21,7 @@ const auth = authenticate<Product>({ component: true, roles: ['owner', 'admin']
 
 const ProductAndPriceSchema = Joi.object({
   name: Joi.string().max(64).empty('').optional(),
-  type: Joi.string().valid('service', 'good').empty('').optional(),
+  type: Joi.string().valid('service', 'good', 'credit').empty('').optional(),
   description: Joi.string().max(250).empty('').optional(),
   images: Joi.any().optional(),
   metadata: MetadataSchema,
@@ -57,6 +57,15 @@ const ProductAndPriceSchema = Joi.object({
     .optional(),
 }).unknown(true);
 
+const CreditConfigSchema = Joi.object({
+  valid_duration_value: Joi.number().default(0).optional(),
+  valid_duration_unit: Joi.string().valid('hours', 'days', 'weeks', 'months', 'years').default('days').optional(),
+  priority: Joi.number().min(0).max(100).default(50).optional(),
+  applicable_prices: Joi.array().items(Joi.string()).default([]).optional(),
+  credit_amount: Joi.number().greater(0).required(),
+  currency_id: Joi.string().required(),
+});
+
 export async function createProductAndPrices(payload: any) {
   // 1. 准备 product 数据
   const raw: Partial<Product> = pick(payload, [
@@ -96,6 +105,18 @@ export async function createProductAndPrices(payload: any) {
         throw new Error(`currency ${newPrice.currency_id} used in price not found or inactive`);
       }
 
+      if (raw.type === 'credit') {
+        const creditConfig = newPrice.metadata.credit_config;
+        if (!creditConfig) {
+          throw new Error('credit_config is required');
+        }
+        const { error, value: creditConfigValue } = CreditConfigSchema.validate(creditConfig);
+        if (error) {
+          throw new Error(`credit_config is invalid: ${error.message}`);
+        }
+        newPrice.metadata.credit_config = creditConfigValue;
+      }
+
       if (newPrice.custom_unit_amount) {
         // @ts-ignore
         ['preset', 'maximum', 'minimum'].forEach((key: keyof CustomUnitAmount) => {
@@ -213,12 +234,16 @@ const paginationSchema = createListParamSchema<{
   name?: string;
   description?: string;
   donation?: string;
+  meter_id?: string;
+  type?: string;
 }>({
   active: Joi.boolean().empty(''),
   status: Joi.string().empty(''),
   name: Joi.string().empty(''),
   description: Joi.string().empty(''),
   donation: Joi.string().empty(''),
+  meter_id: Joi.string().empty(''),
+  type: Joi.string().empty(''),
 });
 router.get('/', auth, async (req, res) => {
   const { page, pageSize, active, livemode, name, description, ...query } = await paginationSchema.validateAsync(
@@ -247,7 +272,6 @@ router.get('/', auth, async (req, res) => {
   if (query.donation === 'hide') {
     where.created_via = { [Op.not]: 'donation' };
   }
-
   Object.keys(query)
     .filter((x) => x.startsWith('metadata.'))
     .forEach((key: string) => {
@@ -255,14 +279,49 @@ router.get('/', auth, async (req, res) => {
       where[key] = query[key];
     });
 
-  const { rows: list, count } = await Product.findAndCountAll({
+  if (query.type === 'credit') {
+    where.type = 'credit';
+  }
+  const findOptions: any = {
     where,
     order: getOrder(req.query, [['created_at', query.o === 'asc' ? 'ASC' : 'DESC']]),
     offset: (page - 1) * pageSize,
     limit: pageSize,
     include: [{ model: Price, as: 'prices' }],
     distinct: true,
-  });
+  };
+
+  if (query.type !== 'credit' && query.meter_id) {
+    findOptions.include = [
+      {
+        model: Price,
+        as: 'prices',
+        where: {
+          recurring: {
+            meter_id: query.meter_id,
+          },
+        },
+        required: true,
+      },
+    ];
+  }
+
+  if (query.type === 'credit' && query.meter_id) {
+    findOptions.include = [
+      {
+        model: Price,
+        as: 'prices',
+        where: {
+          metadata: {
+            meter_id: query.meter_id,
+          },
+        },
+        required: true,
+      },
+    ];
+  }
+
+  const { rows: list, count } = await Product.findAndCountAll(findOptions);
 
   res.json({ count, list, paging: { page, pageSize } });
 });

package/api/src/routes/settings.ts

@@ -14,7 +14,7 @@ import { createListParamSchema, getOrder, getWhereFromKvQuery } from '../libs/ap
 const router = Router();
 const authAdmin = authenticate<Setting>({ component: true, roles: ['owner', 'admin'] });
 router.get('/', async (req, res) => {
-  const attributes = ['id', 'name', 'symbol', 'decimal', 'logo', 'payment_method_id', 'maximum_precision'];
+  const attributes = ['id', 'name', 'symbol', 'decimal', 'logo', 'payment_method_id', 'maximum_precision', 'type'];
   const where: WhereOptions<PaymentMethod> = { livemode: req.livemode, active: true };
 
   const methods = await PaymentMethod.findAll({

package/api/src/routes/subscriptions.ts

@@ -249,10 +249,14 @@ router.get('/:id', authPortal, async (req, res) => {
 
     if (doc) {
       const json = doc.toJSON();
+      const isConsumesCredit = await doc.isConsumesCredit();
+      const serviceType = isConsumesCredit ? 'credit' : 'standard';
       const products = (await Product.findAll()).map((x) => x.toJSON());
       const prices = (await Price.findAll()).map((x) => x.toJSON());
       // @ts-ignore
       expandLineItems(json.items, products, prices);
+      // @ts-ignore
+      json.serviceType = serviceType;
       res.json(json);
     } else {
       res.status(404).json(null);

package/api/src/routes/webhook-endpoints.ts

@@ -43,9 +43,6 @@ router.get('/', auth, async (req, res) => {
   const { page, pageSize, status, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
   const where: WhereOptions<WebhookEndpoint> = {};
 
-  if (typeof query.livemode === 'boolean') {
-    where.livemode = query.livemode;
-  }
   if (status) {
     where.status = status
       .split(',')

package/api/src/store/migrations/20250610-billing-credit.ts

@@ -0,0 +1,43 @@
+import { DataTypes } from 'sequelize';
+
+import { safeApplyColumnChanges, type Migration } from '../migrate';
+import models from '../models';
+
+export const up: Migration = async ({ context }) => {
+  await context.createTable('meters', models.Meter.GENESIS_ATTRIBUTES);
+  await context.createTable('meter_events', models.MeterEvent.GENESIS_ATTRIBUTES);
+  await context.createTable('credit_grants', models.CreditGrant.GENESIS_ATTRIBUTES);
+  await context.createTable('credit_transactions', models.CreditTransaction.GENESIS_ATTRIBUTES);
+
+  await safeApplyColumnChanges(context, {
+    payment_currencies: [
+      {
+        name: 'type',
+        field: {
+          type: DataTypes.ENUM('standard', 'credit'),
+          defaultValue: 'standard',
+          allowNull: false,
+        },
+      },
+    ],
+  });
+  await context.sequelize.query(`
+    UPDATE payment_currencies SET maximum_precision = 2 WHERE type = 'standard';
+  `);
+
+  await context.sequelize.query(`
+    UPDATE payment_currencies 
+    SET maximum_precision = decimal 
+    WHERE payment_method_id IN (
+      SELECT id FROM payment_methods WHERE type = 'stripe'
+    );
+  `);
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('payment_currencies', 'type');
+  await context.dropTable('credit_transactions');
+  await context.dropTable('credit_grants');
+  await context.dropTable('meter_events');
+  await context.dropTable('meters');
+};