iOS 负责：
1. 从后端拿 Apple Product ID
2. 用 StoreKit 向 Apple 发起购买
3. 购买成功后拿到 signedTransactionInfo
4. 把 signedTransactionInfo 发给 Java 后端
5. 后端确认发货成功后，再 finish transaction

Java 后端负责：
1. 验证 Apple 签名
2. 校验 Bundle ID / Product ID / Transaction ID / AppAccountToken
3. 做幂等
4. 给用户发放蛋饼或时长卡
5. 保存交易流水
6. 处理退款、重复回调、补单、异常订单

Type = Consumable

pyy_danbing_60
pyy_danbing_300
pyy_danbing_680

pyy_timecard_30m
pyy_timecard_60m
pyy_timecard_180m
pyy_timecard_600m

App Store Connect
→ 你的 App
→ Monetization / In-App Purchases
→ 创建 In-App Purchase

Type: Consumable
Reference Name: 内部备注，例如 60蛋饼
Product ID: pyy_danbing_60
Price: Apple 价格等级

App Store Connect
→ Users and Access
→ Integrations
→ In-App Purchase
→ Generate In-App Purchase Key

issuerId
keyId
privateKey .p8
bundleId
appAppleId

App Store Connect
→ 你的 App
→ App Information
→ App Store Server Notifications

Production Server URL:
https://api.yourdomain.com/apple/iap/notifications

Sandbox Server URL:
https://api.yourdomain.com/apple/iap/notifications/sandbox

Version 2

1. iOS 调后端 GET /api/iap/products
   ↓
2. 后端返回业务商品 + appleProductId
   ↓
3. iOS 用 Product.products(for:) 向 Apple 拉商品详情和价格
   ↓
4. 用户点击购买
   ↓
5. iOS 先调后端 POST /api/iap/orders 创建预订单
   ↓
6. 后端返回 orderNo + appAccountToken
   ↓
7. iOS 用 StoreKit purchase 发起购买，并带上 appAccountToken
   ↓
8. Apple 支付成功
   ↓
9. iOS 拿到 transaction.jwsRepresentation
   ↓
10. iOS 调 POST /api/iap/apple/verify
   ↓
11. Java 后端验签、校验、入库、发货
   ↓
12. 后端返回 GRANTED
   ↓
13. iOS 调 transaction.finish()
   ↓
14. iOS 刷新余额 / 时长

GET /api/iap/products
Authorization: Bearer <login_token>

{
  "products": [
    {
      "productCode": "DANBING_60",
      "appleProductId": "pyy_danbing_60",
      "assetType": "DANBING",
      "grantAmount": 60,
      "enabled": true,
      "sort": 1
    },
    {
      "productCode": "TIMECARD_60M",
      "appleProductId": "pyy_timecard_60m",
      "assetType": "TIME_MINUTES",
      "grantAmount": 60,
      "enabled": true,
      "sort": 2
    }
  ]
}

let products = try await Product.products(for: appleProductIds)

product.displayPrice

POST /api/iap/orders
Authorization: Bearer <login_token>
Content-Type: application/json

{
  "appleProductId": "pyy_danbing_60"
}

{
  "orderNo": "IAP202605250001",
  "appleProductId": "pyy_danbing_60",
  "appAccountToken": "550e8400-e29b-41d4-a716-446655440000"
}

let token = UUID(uuidString: appAccountToken)!
let result = try await product.purchase(options: [
    .appAccountToken(token)
])

POST /api/iap/apple/verify
Authorization: Bearer <login_token>
Content-Type: application/json

{
  "orderNo": "IAP202605250001",
  "signedTransactionInfo": "eyJhbGciOiJFUzI1NiIsImtpZCI6..."
}

{
  "status": "GRANTED",
  "transactionId": "2000000888888888",
  "appleProductId": "pyy_danbing_60",
  "assetType": "DANBING",
  "grantAmount": 60,
  "balance": {
    "danbing": 260,
    "timeMinutes": 120
  }
}

{
  "status": "ALREADY_GRANTED",
  "transactionId": "2000000888888888"
}

GET /api/wallet/balance
Authorization: Bearer <login_token>

{
  "danbing": 260,
  "timeMinutes": 120
}

POST /api/apple/iap/notifications
Content-Type: application/json

{
  "signedPayload": "eyJhbGciOiJFUzI1NiIs..."
}

1. 验证 signedPayload
2. 解出 notificationType
3. 解出 signedTransactionInfo
4. 找到 transactionId / originalTransactionId / productId
5. 幂等处理通知事件
6. 如果是退款，更新交易状态并扣回权益

<dependency>
    <groupId>com.apple.itunes.storekit</groupId>
    <artifactId>app-store-server-library</artifactId>
    <version>5.2.0</version>
</dependency>

implementation 'com.apple.itunes.storekit:app-store-server-library:5.2.0'

apple:
  iap:
    bundle-id: com.bujingyun.pyydn
    app-apple-id: 1234567890
    issuer-id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    key-id: ABCDEFGHIJ
    private-key-path: /secure/apple/AuthKey_ABCDEFGHIJ.p8
    environment: PRODUCTION
    allow-sandbox-transactions: true
    root-ca-paths:
      - /secure/apple/AppleRootCA-G3.cer
      - /secure/apple/AppleRootCA-G2.cer

生产环境后端可以识别 Production 和 Sandbox
但要记录 environment

1. TestFlight / 审核阶段允许 Sandbox
2. 正式环境只允许 Apple 审核账号 / 内部测试账号使用 Sandbox
3. 普通线上用户只接受 Production

CREATE TABLE iap_product_config (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    product_code VARCHAR(64) NOT NULL UNIQUE,
    apple_product_id VARCHAR(128) NOT NULL UNIQUE,
    asset_type VARCHAR(32) NOT NULL COMMENT 'DANBING/TIME_MINUTES',
    grant_amount BIGINT NOT NULL,
    enabled TINYINT NOT NULL DEFAULT 1,
    sort_order INT NOT NULL DEFAULT 0,
    remark VARCHAR(255),
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL
);

INSERT INTO iap_product_config
(product_code, apple_product_id, asset_type, grant_amount, enabled, sort_order, created_at, updated_at)
VALUES
('DANBING_60', 'pyy_danbing_60', 'DANBING', 60, 1, 1, NOW(), NOW()),
('DANBING_300', 'pyy_danbing_300', 'DANBING', 300, 1, 2, NOW(), NOW()),
('TIMECARD_60M', 'pyy_timecard_60m', 'TIME_MINUTES', 60, 1, 3, NOW(), NOW());

CREATE TABLE iap_order (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    order_no VARCHAR(64) NOT NULL UNIQUE,
    user_id BIGINT NOT NULL,
    apple_product_id VARCHAR(128) NOT NULL,
    app_account_token VARCHAR(64) NOT NULL UNIQUE,
    status VARCHAR(32) NOT NULL COMMENT 'CREATED/VERIFYING/GRANTED/CANCELLED/FAILED',
    transaction_id VARCHAR(128),
    fail_reason VARCHAR(512),
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    INDEX idx_user_id (user_id),
    INDEX idx_status (status),
    INDEX idx_transaction_id (transaction_id)
);

CREATE TABLE apple_iap_transaction (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    transaction_id VARCHAR(128) NOT NULL UNIQUE,
    original_transaction_id VARCHAR(128),
    web_order_line_item_id VARCHAR(128),
    user_id BIGINT NOT NULL,
    order_no VARCHAR(64),
    apple_product_id VARCHAR(128) NOT NULL,
    app_account_token VARCHAR(64),
    bundle_id VARCHAR(255) NOT NULL,
    environment VARCHAR(32) NOT NULL COMMENT 'SANDBOX/PRODUCTION',
    transaction_reason VARCHAR(64),
    purchase_date DATETIME,
    signed_date DATETIME,
    quantity INT NOT NULL DEFAULT 1,
    revocation_date DATETIME NULL,
    revocation_reason VARCHAR(64),
    status VARCHAR(32) NOT NULL COMMENT 'VERIFIED/GRANTED/REVOKED/FAILED',
    raw_signed_transaction_info LONGTEXT NOT NULL,
    raw_decoded_payload JSON,
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    INDEX idx_user_id (user_id),
    INDEX idx_original_transaction_id (original_transaction_id),
    INDEX idx_product_id (apple_product_id),
    INDEX idx_environment (environment),
    INDEX idx_status (status)
);

transaction_id 必须唯一

CREATE TABLE user_asset_account (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL,
    asset_type VARCHAR(32) NOT NULL COMMENT 'DANBING/TIME_MINUTES',
    balance BIGINT NOT NULL DEFAULT 0,
    version BIGINT NOT NULL DEFAULT 0,
    created_at DATETIME NOT NULL,
    updated_at DATETIME NOT NULL,
    UNIQUE KEY uk_user_asset (user_id, asset_type)
);

蛋饼：整数
时长：分钟数整数

CREATE TABLE user_asset_ledger (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL,
    asset_type VARCHAR(32) NOT NULL,
    direction VARCHAR(16) NOT NULL COMMENT 'IN/OUT',
    amount BIGINT NOT NULL,
    balance_after BIGINT NOT NULL,
    source_type VARCHAR(64) NOT NULL COMMENT 'APPLE_IAP/APPLE_REFUND/CLOUD_USAGE/ADMIN',
    source_id VARCHAR(128) NOT NULL,
    remark VARCHAR(255),
    created_at DATETIME NOT NULL,
    UNIQUE KEY uk_source_once (source_type, source_id, asset_type, direction),
    INDEX idx_user_asset (user_id, asset_type),
    INDEX idx_created_at (created_at)
);

CREATE TABLE apple_iap_notification_event (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    notification_uuid VARCHAR(128) NOT NULL UNIQUE,
    notification_type VARCHAR(128),
    subtype VARCHAR(128),
    environment VARCHAR(32),
    transaction_id VARCHAR(128),
    original_transaction_id VARCHAR(128),
    signed_payload LONGTEXT NOT NULL,
    decoded_payload JSON,
    process_status VARCHAR(32) NOT NULL COMMENT 'PENDING/PROCESSED/FAILED',
    fail_reason VARCHAR(512),
    received_at DATETIME NOT NULL,
    processed_at DATETIME NULL,
    INDEX idx_transaction_id (transaction_id),
    INDEX idx_status (process_status)
);

import com.apple.itunes.storekit.model.Environment;
import com.apple.itunes.storekit.verification.SignedDataVerifier;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Set;

public class AppleVerifierFactory {

    public SignedDataVerifier createVerifier(
            String bundleId,
            Long appAppleId,
            Environment environment,
            Set<String> rootCaPaths
    ) throws Exception {

        Set<InputStream> rootCAs = new java.util.HashSet<>();
        for (String path : rootCaPaths) {
            rootCAs.add(new FileInputStream(path));
        }

        boolean enableOnlineChecks = true;

        return new SignedDataVerifier(
                rootCAs,
                bundleId,
                appAppleId,
                environment,
                enableOnlineChecks
        );
    }
}

productionVerifier
sandboxVerifier

import com.apple.itunes.storekit.model.Environment;
import com.apple.itunes.storekit.model.JWSTransactionDecodedPayload;
import com.apple.itunes.storekit.verification.SignedDataVerifier;
import com.apple.itunes.storekit.verification.VerificationException;

public class AppleIapVerifyService {

    private final SignedDataVerifier productionVerifier;
    private final SignedDataVerifier sandboxVerifier;
    private final IapOrderRepository orderRepository;
    private final IapProductRepository productRepository;
    private final AppleTransactionRepository transactionRepository;
    private final UserAssetService userAssetService;

    public VerifyResult verifyAndGrant(Long loginUserId, String orderNo, String signedTransactionInfo) {
        DecodedTransaction decoded = verifySignedTransaction(signedTransactionInfo);

        JWSTransactionDecodedPayload payload = decoded.payload();

        String transactionId = payload.getTransactionId();
        String productId = payload.getProductId();

        if (transactionId == null || transactionId.isBlank()) {
            throw new BizException("APPLE_TRANSACTION_ID_EMPTY");
        }

        if (productId == null || productId.isBlank()) {
            throw new BizException("APPLE_PRODUCT_ID_EMPTY");
        }

        IapProductConfig product = productRepository.findEnabledByAppleProductId(productId)
                .orElseThrow(() -> new BizException("UNKNOWN_APPLE_PRODUCT_ID"));

        IapOrder order = orderRepository.findByOrderNo(orderNo)
                .orElseThrow(() -> new BizException("ORDER_NOT_FOUND"));

        if (!order.getUserId().equals(loginUserId)) {
            throw new BizException("ORDER_USER_MISMATCH");
        }

        if (!order.getAppleProductId().equals(productId)) {
            throw new BizException("ORDER_PRODUCT_MISMATCH");
        }

        String appAccountToken = payload.getAppAccountToken() == null
                ? null
                : payload.getAppAccountToken().toString();

        if (appAccountToken != null && !appAccountToken.equalsIgnoreCase(order.getAppAccountToken())) {
            throw new BizException("APP_ACCOUNT_TOKEN_MISMATCH");
        }

        if (payload.getRevocationDate() != null) {
            throw new BizException("TRANSACTION_ALREADY_REVOKED");
        }

        return grantIdempotently(loginUserId, order, product, decoded, signedTransactionInfo);
    }

    private DecodedTransaction verifySignedTransaction(String signedTransactionInfo) {
        try {
            JWSTransactionDecodedPayload payload =
                    productionVerifier.verifyAndDecodeTransaction(signedTransactionInfo);
            return new DecodedTransaction(payload, Environment.PRODUCTION);
        } catch (VerificationException productionError) {
            try {
                JWSTransactionDecodedPayload payload =
                        sandboxVerifier.verifyAndDecodeTransaction(signedTransactionInfo);
                return new DecodedTransaction(payload, Environment.SANDBOX);
            } catch (VerificationException sandboxError) {
                throw new BizException("APPLE_TRANSACTION_VERIFY_FAILED");
            }
        }
    }
}

1. 插入 apple_iap_transaction
2. 判断 transaction_id 是否已存在
3. 更新用户资产余额
4. 写 user_asset_ledger
5. 更新订单状态
6. 提交事务

@Transactional
public VerifyResult grantIdempotently(
        Long userId,
        IapOrder order,
        IapProductConfig product,
        DecodedTransaction decoded,
        String rawSignedTransactionInfo
) {
    String transactionId = decoded.payload().getTransactionId();

    Optional<AppleIapTransaction> existing =
            transactionRepository.findByTransactionId(transactionId);

    if (existing.isPresent()) {
        AppleIapTransaction tx = existing.get();

        if (!tx.getUserId().equals(userId)) {
            // 同一 Apple 交易被不同用户提交，属于高危风险
            throw new BizException("TRANSACTION_ALREADY_BOUND_TO_OTHER_USER");
        }

        if ("GRANTED".equals(tx.getStatus())) {
            return VerifyResult.alreadyGranted(transactionId);
        }

        // 如果之前验证过但发货失败，可以进入补发逻辑
        return retryGrant(tx, product);
    }

    AppleIapTransaction tx = transactionRepository.insertVerifiedTransaction(
            userId,
            order.getOrderNo(),
            transactionId,
            decoded.payload(),
            decoded.environment(),
            rawSignedTransactionInfo
    );

    long quantity = decoded.payload().getQuantity() == null
            ? 1
            : decoded.payload().getQuantity();

    long grantAmount = product.getGrantAmount() * quantity;

    userAssetService.increaseBalance(
            userId,
            product.getAssetType(),
            grantAmount,
            "APPLE_IAP",
            transactionId,
            "Apple 内购发货：" + product.getAppleProductId()
    );

    transactionRepository.markGranted(transactionId);
    orderRepository.markGranted(order.getOrderNo(), transactionId);

    return VerifyResult.granted(
            transactionId,
            product.getAppleProductId(),
            product.getAssetType(),
            grantAmount
    );
}

同一个 transactionId 只发货一次

Apple purchase success
↓
拿到 transaction.jwsRepresentation
↓
提交给后端 verify
↓
后端返回 GRANTED / ALREADY_GRANTED
↓
iOS 再 transaction.finish()

不要 finish

func buy(product: Product, order: IapOrder) async throws {
    let appAccountToken = UUID(uuidString: order.appAccountToken)!

    let result = try await product.purchase(options: [
        .appAccountToken(appAccountToken)
    ])

    switch result {
    case .success(let verification):
        let transaction = try checkVerified(verification)

        let response = try await api.verifyApplePurchase(
            orderNo: order.orderNo,
            signedTransactionInfo: transaction.jwsRepresentation
        )

        if response.status == "GRANTED" || response.status == "ALREADY_GRANTED" {
            await transaction.finish()
            await refreshBalance()
        }

    case .userCancelled:
        break

    case .pending:
        // 家庭共享/家长批准等场景，等待 Transaction.updates
        break

    @unknown default:
        break
    }
}

Task.detached {
    for await result in Transaction.updates {
        do {
            let transaction = try checkVerified(result)

            let response = try await api.verifyApplePurchase(
                orderNo: findOrderNoIfPossible(transaction),
                signedTransactionInfo: transaction.jwsRepresentation
            )

            if response.status == "GRANTED" || response.status == "ALREADY_GRANTED" {
                await transaction.finish()
            }
        } catch {
            // 记录日志，稍后重试
        }
    }
}

POST /api/iap/apple/verify-without-order

用户登录账号
↓
App 调 GET /api/wallet/balance
↓
后端返回蛋饼余额和时长余额

1. 验证通知 signedPayload
2. 解出 transactionId
3. 找到原交易
4. 将交易状态改为 REVOKED
5. 写退款流水
6. 扣回对应资产

原来买了 60 蛋饼
当前余额 >= 60
直接扣回 60

扣到 0 + 记录 debtAmount + 标记风控

revocation_date
revocation_reason
refund_status
refund_processed_at

source_type = APPLE_REFUND
source_id = transactionId
direction = OUT

import com.apple.itunes.storekit.model.ResponseBodyV2DecodedPayload;

public void handleNotification(String signedPayload) {
    ResponseBodyV2DecodedPayload payload =
            signedPayloadVerifier.verifyAndDecodeNotification(signedPayload);

    String notificationUUID = payload.getNotificationUUID();
    String notificationType = payload.getNotificationType().getValue();
    String subtype = payload.getSubtype() == null ? null : payload.getSubtype().getValue();

    // 先落库，保证幂等
    saveNotificationEventIfAbsent(notificationUUID, notificationType, subtype, signedPayload);

    // 再按类型处理
}

REFUND
CONSUMPTION_REQUEST

1. 该 transactionId 是否发货成功
2. 发放的蛋饼/时长是否已使用
3. 使用比例多少
4. 用户是否存在异常退款历史

收到 CONSUMPTION_REQUEST 后落库 + 告警

监听 Transaction.updates
检查未 finish 的 transaction
重新提交后端 verify

iap_order.status IN ('CREATED', 'VERIFYING')
且 created_at 超过 10 分钟

重试发货

按 userId 查询订单
按 transactionId 查询交易
按 orderNo 查询订单
手动重试发货
查看 Apple 原始 payload
查看资产流水

高危，拒绝发货，记录安全日志

拒绝发货

拒绝发货

拒绝发货

正式环境普通用户不要随便接受 Sandbox 交易

review_user_ids
internal_test_user_ids

refund_count_30d
refund_amount_30d

限制购买
限制使用云电脑
进入人工审核

购买 60 蛋饼
后端发货
余额增加
交易流水存在
iOS finish

同一个 signedTransactionInfo 连续提交 5 次
只能发货一次
后续返回 ALREADY_GRANTED

Apple 支付成功后断网
iOS 不 finish
恢复网络后 Transaction.updates 补单
后端发货一次

order 是 pyy_danbing_60
transaction 是 pyy_timecard_60m
后端拒绝发货

A 用户订单
B 用户提交
后端拒绝

Apple 退款通知
交易状态变 REVOKED
扣回蛋饼/时长
产生 APPLE_REFUND 流水

沙盒账号购买
TestFlight 购买
审核账号购买
后端能识别 environment

com.pyy.iap
├── controller
│   ├── IapProductController
│   ├── IapOrderController
│   ├── AppleIapVerifyController
│   └── AppleNotificationController
├── service
│   ├── AppleIapVerifyService
│   ├── IapOrderService
│   ├── IapProductService
│   ├── UserAssetService
│   └── AppleNotificationService
├── repository
│   ├── IapProductRepository
│   ├── IapOrderRepository
│   ├── AppleTransactionRepository
│   ├── UserAssetRepository
│   └── UserAssetLedgerRepository
├── model
│   ├── IapProductConfig
│   ├── IapOrder
│   ├── AppleIapTransaction
│   ├── UserAssetAccount
│   └── UserAssetLedger
└── config
    ├── AppleIapProperties
    └── AppleVerifierConfig

@RestController
@RequestMapping("/api/iap/apple")
public class AppleIapVerifyController {

    private final AppleIapVerifyService appleIapVerifyService;

    public AppleIapVerifyController(AppleIapVerifyService appleIapVerifyService) {
        this.appleIapVerifyService = appleIapVerifyService;
    }

    @PostMapping("/verify")
    public ApiResponse<VerifyResult> verify(
            @AuthenticationPrincipal LoginUser loginUser,
            @RequestBody AppleVerifyRequest request
    ) {
        VerifyResult result = appleIapVerifyService.verifyAndGrant(
                loginUser.getUserId(),
                request.getOrderNo(),
                request.getSignedTransactionInfo()
        );

        return ApiResponse.success(result);
    }
}

public class AppleVerifyRequest {
    private String orderNo;
    private String signedTransactionInfo;

    public String getOrderNo() {
        return orderNo;
    }

    public String getSignedTransactionInfo() {
        return signedTransactionInfo;
    }
}

@RestController
@RequestMapping("/api/apple/iap")
public class AppleNotificationController {

    private final AppleNotificationService appleNotificationService;

    public AppleNotificationController(AppleNotificationService appleNotificationService) {
        this.appleNotificationService = appleNotificationService;
    }

    @PostMapping("/notifications")
    public ResponseEntity<Void> handle(@RequestBody AppleNotificationRequest request) {
        appleNotificationService.handle(request.getSignedPayload());
        return ResponseEntity.ok().build();
    }
}

public class AppleNotificationRequest {
    private String signedPayload;

    public String getSignedPayload() {
        return signedPayload;
    }
}

signedPayload 验签

IP 访问日志
速率限制
告警

@Transactional
public void consumeTime(Long userId, long minutes, String sessionId) {
    UserAssetAccount account = assetRepository.lockByUserIdAndAssetType(
            userId,
            "TIME_MINUTES"
    );

    if (account.getBalance() < minutes) {
        throw new BizException("TIME_NOT_ENOUGH");
    }

    long newBalance = account.getBalance() - minutes;

    assetRepository.updateBalance(account.getId(), newBalance, account.getVersion());

    ledgerRepository.insert(
            userId,
            "TIME_MINUTES",
            "OUT",
            minutes,
            newBalance,
            "CLOUD_USAGE",
            sessionId,
            "云电脑使用扣减"
    );
}

资产扣减也要写流水

iOS purchase success
→ iOS 本地加蛋饼

{
  "productId": "pyy_danbing_999999"
}

1. App Store Connect 创建 Consumable 商品
2. 后端配置 SANDBOX verifier
3. iOS 沙盒账号购买
4. 验证发货
5. 测重复提交和网络中断

1. 上传 TestFlight
2. 后端允许 Sandbox environment
3. 内部测试购买
4. 确认 Apple 通知能到后端

1. 给审核账号准备测试账号
2. 让审核能看到购买入口
3. 后端允许审核账号 Sandbox 交易
4. 确保购买后能看到蛋饼/时长到账

1. 开启 Production verifier
2. 保留 Sandbox 兼容策略
3. 开启通知告警
4. 开启交易异常告警
5. 每日对账

1. 统计 Apple 交易表
2. 统计资产流水
3. 统计订单表
4. 找出已支付未发货
5. 找出已退款未扣回
6. 找出交易和流水金额不一致

transaction_id
user_id
apple_product_id
order_no
status
grant_status
refund_status

1. 展示商品
2. 调 Apple StoreKit 购买
3. 拿 signedTransactionInfo
4. 调后端 verify
5. 后端成功后 finish
6. 展示后端余额

1. 商品配置
2. 创建预订单
3. 验签 Apple 交易
4. 幂等发货
5. 保存交易和流水
6. 处理退款通知
7. 提供余额查询
8. 提供客服补单能力

1. 维护 Apple 商品
2. 维护价格
3. 维护 Server Notification URL
4. 维护 In-App Purchase Key

Apple 交易 = 支付凭证
Java 验签 = 确认凭证有效
transactionId 幂等 = 防止重复发货
资产流水 = 解释每一次蛋饼/时长变化
Server Notifications = 处理退款和后续状态