anchor-sdk 0.1.41-internal.6 → 0.1.42-beta.1

package/dist/AnchorApiClient.js

@@ -1,279 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnchorApiClient = void 0;
-const AnchorApiHttpClient_1 = require("./api/AnchorApiHttpClient");
-/**
- * Anchor API 客户端
- * 用于与 Anchor API 服务进行交互
- */
-class AnchorApiClient {
-    /**
-     * 创建 Anchor API 客户端
-     * @param config 客户端配置
-     */
-    constructor(config) {
-        this.network = config.network;
-        this.apiHttpClient = new AnchorApiHttpClient_1.AnchorApiHttpClient({
-            baseUrl: config.apiBaseUrl,
-            authToken: config.authToken,
-            projectId: config.projectId,
-            chainId: config.network.id.toString(),
-            onTokenExpired: config.onTokenExpired,
-        });
-    }
-    /**
-     * 设置认证令牌
-     * @param token 认证令牌
-     */
-    setAuthToken(token) {
-        this.apiHttpClient.setAuthToken(token);
-    }
-    /**
-     * 设置 Token 过期回调
-     * @param callback Token 过期回调函数
-     */
-    setTokenExpiredCallback(callback) {
-        this.apiHttpClient.setTokenExpiredCallback(callback);
-    }
-    /**
-     * 设置项目 ID
-     * @param projectId 项目 ID
-     */
-    setProjectId(projectId) {
-        this.apiHttpClient.setProjectId(projectId);
-    }
-    /**
-     * 设置链 ID
-     * @param chainId 链 ID
-     */
-    setChainId(chainId) {
-        this.apiHttpClient.setChainId(chainId);
-    }
-    // ==================== V2 API Methods ====================
-    /**
-     * 获取徽章系列列表
-     * @param status 系列状态过滤器
-     * @param group 系列组过滤器
-     * @param limit 每页项目数
-     * @param nextToken 分页令牌
-     * @returns 徽章系列响应
-     */
-    async getBadgeSeries(status, group, limit, nextToken) {
-        return this.apiHttpClient.getBadgeSeries(status, group, limit, nextToken);
-    }
-    /**
-     * 获取徽章系列详情
-     * @param seriesId 系列标识符
-     * @returns 徽章系列详情响应
-     */
-    async getBadgeSeriesDetail(seriesId) {
-        return this.apiHttpClient.getBadgeSeriesDetail(seriesId);
-    }
-    /**
-     * 获取用户徽章
-     * @param status 徽章状态过滤器
-     * @param strategy 返回策略
-     * @param series 徽章系列过滤器
-     * @param limit 每页项目数
-     * @param nextToken 分页令牌
-     * @returns 徽章响应
-     */
-    async getBadges(status, strategy, series, limit, nextToken) {
-        return this.apiHttpClient.getBadges(status, strategy, series, limit, nextToken);
-    }
-    /**
-     * 获取徽章详情
-     * @param badgeId 徽章标识符
-     * @returns 徽章详情响应
-     */
-    async getBadgeDetail(badgeId) {
-        return this.apiHttpClient.getBadgeDetail(badgeId);
-    }
-    /**
-     * 检查单个徽章可领取状态
-     * @param badgeId 徽章标识符
-     * @returns 徽章可领取响应
-     */
-    async checkSingleBadgeClaimable(badgeId) {
-        return this.apiHttpClient.checkSingleBadgeClaimable(badgeId);
-    }
-    /**
-     * 获取用户徽章资产
-     * @param status 徽章状态过滤器
-     * @param strategy 返回策略
-     * @param series 徽章系列过滤器
-     * @param limit 每页项目数
-     * @param nextToken 分页令牌
-     * @returns 徽章资产响应
-     */
-    async getUserBadgeAssets(status, strategy, series, limit, nextToken) {
-        return this.apiHttpClient.getUserBadgeAssets(status, strategy, series, limit, nextToken);
-    }
-    /**
-     * 检查用户可领取徽章
-     * @param data 徽章检查请求
-     * @returns 徽章检查响应
-     */
-    async checkUserClaimableBadges(data) {
-        return this.apiHttpClient.checkUserClaimableBadges(data);
-    }
-    /**
-     * 获取用户可领取徽章
-     * @param series 徽章系列过滤器
-     * @param limit 每页项目数
-     * @param nextToken 分页令牌
-     * @returns 徽章可领取列表响应
-     */
-    async getUserClaimableBadges(series, limit, nextToken) {
-        return this.apiHttpClient.getUserClaimableBadges(series, limit, nextToken);
-    }
-    /**
-     * 获取徽章领取签名
-     * @param customerAddress 客户钱包地址
-     * @param badgeIds 要领取的徽章 ID 列表
-     * @returns 徽章领取签名响应
-     */
-    async getBadgeClaimSignatures(customerAddress, badgeIds) {
-        const data = {
-            customerAddress,
-            badgeIds,
-        };
-        return this.apiHttpClient.getBadgeClaimSignatures(data);
-    }
-    /**
-     * 查询资产
-     * @param customerIds 用户 ID 列表
-     * @param status 资产状态
-     * @param strategy 返回策略
-     * @param limit 返回数量限制
-     * @returns 资产徽章响应
-     */
-    async getUserAssets(customerIds, status = "claimable", strategy = "all", limit = 100) {
-        return this.apiHttpClient.getUserAssets(customerIds, status, strategy, limit);
-    }
-    // ==================== Legacy V1 API Methods (Deprecated) ====================
-    /**
-     * 授予徽章 (Legacy)
-     * @param data 授予徽章请求数据
-     * @returns 授予徽章响应
-     */
-    async grantBadge(data) {
-        return this.apiHttpClient.grantBadge(data);
-    }
-    /**
-     * 查询用户可领取或已领取的徽章 (Legacy)
-     * @param customerId 客户 ID
-     * @param status NFT 状态，值(claimable、claimed)
-     * @param strategy 返回数据的策略(all：返回所有徽章, max：仅返回同系列等级最高的徽章)
-     * @returns 徽章响应
-     */
-    async getBadgeAssets(customerId, status, strategy) {
-        return this.apiHttpClient.badgeAssets(customerId, status, strategy);
-    }
-    /**
-     * 获取 NFT 系列 (Legacy)
-     * @returns NFT 系列响应
-     */
-    async getNftSeries() {
-        return this.apiHttpClient.nftSeries("badge");
-    }
-    /**
-     * 通过 ID 获取 NFT 系列 (Legacy)
-     * @param series NFT 系列
-     * @param customerId 用户 ID
-     * @returns NFT 系列详情响应
-     */
-    async getNftSeriesById(series, customerId) {
-        return this.apiHttpClient.getNftSeriesById("badge", series, customerId);
-    }
-    /**
-     * 检查徽章 (Legacy)
-     * @returns 检查响应
-     */
-    async checkBadge() {
-        return this.apiHttpClient.check("badge");
-    }
-    /**
-     * 获取徽章检查结果 (Legacy)
-     * @returns 检查结果响应
-     */
-    async getBadgeCheckResult() {
-        return this.apiHttpClient.getCheckResult("badge");
-    }
-    /**
-     * 处理用户操作哈希 (Legacy)
-     * @param userOperationHash 用户操作哈希
-     * @param processType 处理类型，默认为 ERC20_TRANSFER
-     * @returns 处理响应
-     */
-    async processUserOpHash(userOperationHash, processType = "ERC20_TRANSFER") {
-        const data = {
-            userOperationHash,
-            processType,
-        };
-        return this.apiHttpClient.processUserOpHash(data);
-    }
-    /**
-     * 加快交易处理 (Legacy)
-     * @param txHash 交易哈希
-     * @returns 处理响应
-     */
-    async processTransactionHash(txHash) {
-        return this.apiHttpClient.processTransactionHash(txHash);
-    }
-    // ==================== Deprecated Methods (Will be removed) ====================
-    /**
-     * @deprecated 使用 getBadgeClaimSignatures 替代
-     * 铸造徽章
-     * @param customerAddress 客户地址
-     * @param contractAddress NFT 地址
-     * @param claimableIds 可领取 ID 列表
-     * @returns NFT 铸造响应
-     */
-    async mintBadge(customerAddress, contractAddress, claimableIds) {
-        console.warn("mintBadge method is deprecated, use getBadgeClaimSignatures instead");
-        const mintRequest = {
-            customerAddress,
-            nftType: "badge",
-            contractAddress,
-            claimableIds,
-        };
-        return this.apiHttpClient.mint("badge", mintRequest);
-    }
-    /**
-     * @deprecated 使用 getBadgeClaimSignatures 替代
-     * 使用 V2 API 铸造徽章
-     * @param customerAddress 客户地址
-     * @param contractAddress NFT 地址
-     * @param claimableIds 可领取 ID 列表
-     * @returns 铸造响应
-     */
-    async mintBadgeV2(customerAddress, contractAddress, claimableIds) {
-        console.warn("mintBadgeV2 method is deprecated, use getBadgeClaimSignatures instead");
-        const mintRequest = {
-            customerAddress,
-            nftType: "badge",
-            contractAddress,
-            claimableIds,
-        };
-        return this.apiHttpClient.mintV2("badge", mintRequest);
-    }
-    /**
-     * @deprecated 使用 checkUserClaimableBadges 替代
-     * 批量铸造徽章（V2）
-     * @param customerAddress 客户地址
-     * @param contractAddress NFT 合约地址
-     * @param tokenIds 代币 ID 列表
-     * @returns 批量铸造响应
-     */
-    async batchMintBadge(customerAddress, contractAddress, tokenIds) {
-        console.warn("batchMintBadge method is deprecated, use checkUserClaimableBadges instead");
-        const batchMintRequest = {
-            customerAddress,
-            contractAddress,
-            tokenIds,
-        };
-        return this.apiHttpClient.batchMint("badge", batchMintRequest);
-    }
-}
-exports.AnchorApiClient = AnchorApiClient;

package/dist/AnchorApiClientV2.js

@@ -1,316 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnchorApiClientV2 = void 0;
-const Api_1 = require("./generated/Api");
-/**
- * Anchor API V2 客户端
- * 基于生成的 API 类型和端点，提供完整的 Anchor API 功能
- *
- * 这个客户端使用生成的 API 类型和端点，同时提供
- * 自动 header 注入和配置管理功能。
- */
-class AnchorApiClientV2 {
-    /**
-     * 创建 Anchor API V2 客户端
-     * @param config 客户端配置
-     */
-    constructor(config) {
-        this.network = config.network;
-        this.authToken = config.authToken;
-        this.projectId = config.projectId;
-        this.chainId = config.network.id.toString();
-        this.onTokenExpired = config.onTokenExpired;
-        // 初始化生成的 API
-        this.generatedApi = new Api_1.Api({
-            baseUrl: config.apiBaseUrl.endsWith("/")
-                ? config.apiBaseUrl.slice(0, -1)
-                : config.apiBaseUrl,
-        });
-    }
-    /**
-     * 设置认证令牌
-     * @param token 认证令牌
-     */
-    setAuthToken(token) {
-        this.authToken = token;
-    }
-    /**
-     * 设置 Token 过期回调
-     * @param callback Token 过期回调函数
-     */
-    setTokenExpiredCallback(callback) {
-        this.onTokenExpired = callback;
-    }
-    /**
-     * 设置项目 ID
-     * @param projectId 项目 ID
-     */
-    setProjectId(projectId) {
-        this.projectId = projectId;
-    }
-    /**
-     * 设置链 ID
-     * @param chainId 链 ID
-     */
-    setChainId(chainId) {
-        this.chainId = chainId;
-    }
-    /**
-     * 创建请求头
-     * @returns 请求头对象
-     */
-    createHeaders() {
-        const headers = {
-            "Content-Type": "application/json",
-        };
-        // 添加标准化的请求头
-        if (this.authToken) {
-            headers["Authorization"] = `Bearer ${this.authToken}`;
-            headers["jwt_token"] = `${this.authToken}`;
-        }
-        if (this.projectId) {
-            headers["X-Project-Id"] = this.projectId;
-            headers["saas_id"] = this.projectId;
-        }
-        if (this.chainId) {
-            headers["X-Chain-Id"] = this.chainId;
-            headers["chain_id"] = this.chainId;
-        }
-        return headers;
-    }
-    /**
-     * 获取请求参数（包含 headers）
-     * @returns 请求参数对象
-     */
-    getRequestParams() {
-        return {
-            headers: this.createHeaders(),
-        };
-    }
-    /**
-     * 处理 API 调用的错误和 token 过期
-     * @param apiCall API 调用函数
-     * @returns API 调用结果
-     */
-    async handleApiCall(apiCall) {
-        try {
-            const result = await apiCall();
-            // 检查响应体中的 token 过期信息
-            if (this.isTokenExpiredResponse(result)) {
-                console.log("Token expired: JWT token is invalid or expired");
-                const error = new Error("Token expired: JWT token is invalid or expired");
-                if (this.onTokenExpired) {
-                    this.onTokenExpired(error);
-                }
-                throw error;
-            }
-            return result;
-        }
-        catch (error) {
-            // 检查 HTTP 401 状态码的 token 过期
-            if (error?.status === 401) {
-                if (this.onTokenExpired) {
-                    this.onTokenExpired(error);
-                }
-            }
-            throw error;
-        }
-    }
-    /**
-     * 检查响应是否为 token 过期错误
-     * @param response API 响应
-     * @returns 是否为 token 过期错误
-     */
-    isTokenExpiredResponse(response) {
-        // 检查响应体中的 token 过期标识
-        // 优先检查：success 为 false 且 code 为 9101（标准 token 过期错误码）
-        if (response?.success === false && response?.code === "9101") {
-            return true;
-        }
-        // 检查 msgKey 是否为特定的 JWT 错误
-        if (response?.success === false &&
-            response?.msgKey === "params.jwt.check.invalid") {
-            return true;
-        }
-        return false;
-    }
-    // ==================== V2 API Methods ====================
-    /**
-     * 获取徽章验证器
-     * @route GET /v2/badges/verifiers
-     * @param platform 平台标识符
-     * @param type 条件类型
-     * @returns 徽章验证器响应
-     */
-    async getBadgeVerifiers(platform, type) {
-        return this.handleApiCall(async () => {
-            const query = { platform, type };
-            const response = await this.generatedApi.v2.getBadgeVerifiers(query, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * 获取用户可领取徽章
-     * @route GET /v2/badges/claimable
-     * @param params 查询参数
-     * @param params.series 徽章系列过滤器
-     * @param params.limit 每页项目数
-     * @param params.nextToken 分页令牌
-     * @returns 徽章可领取列表响应
-     */
-    async getUserClaimableBadges(params) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.getUserClaimableBadges(params, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * 获取用户徽章资产
-     * @route GET /v2/badges/assets
-     * @param params 查询参数
-     * @param params.includeClaimable 徽章状态是否包含可领取
-     * @param params.strategy 返回策略 BADGE_ALL/BADGE_MAX/BADGE_REWARD
-     * @param params.series 徽章系列过滤器
-     * @param params.limit 每页项目数
-     * @param params.nextToken 分页令牌
-     * @returns 徽章资产响应
-     */
-    async getUserBadgeAssets(params) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.getUserBadgeAssets(params, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * 获取徽章系列详情
-     * @route GET /v2/badges/series/{seriesId}
-     * @param seriesId 系列标识符
-     * @param params 查询参数
-     * @param params.status 状态过滤器
-     * @param params.businessType 业务类型过滤器
-     * @returns 徽章系列详情响应
-     */
-    async getBadgeSeriesDetail(seriesId, params) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.getBadgeSeriesDetail(seriesId, params, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * 获取徽章详情
-     * @route GET /v2/badges/{badgeId}
-     * @param badgeId 徽章标识符
-     * @returns 徽章详情响应
-     */
-    async getBadgeDetail(badgeId) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.getBadgeDetail(badgeId, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * 检查单个徽章可领取状态
-     * @route POST /v2/badges/{badgeId}
-     * @param badgeId 徽章标识符
-     * @param data 徽章检查请求数据
-     * @returns 徽章可领取响应
-     */
-    async checkSingleBadgeClaimable(badgeId, data) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.checkSingleBadgeClaimable(badgeId, data, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * 检查用户可领取徽章
-     * @route POST /v2/badges
-     * @param data 徽章检查请求
-     * @returns 徽章检查响应
-     */
-    async checkUserClaimableBadges(data) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.checkUserClaimableBadges(data, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * 获取徽章领取签名
-     * @route POST /v2/badges/signatures
-     * @param data 徽章领取签名请求
-     * @returns 徽章领取签名响应
-     */
-    async getBadgeClaimSignatures(data) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.getBadgeClaimSignatures(data, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * 获取徽章系列列表
-     * @route GET /v2/badges/series
-     * @param params 查询参数
-     * @param params.includeBadges 是否包含徽章
-     * @param params.status 状态过滤器
-     * @param params.businessType 业务类型过滤器
-     * @param params.limit 每页数量
-     * @returns 徽章系列响应
-     */
-    async getBadgeSeries(params) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.getBadgeSeries(params, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * Anchor 铸造
-     * @route POST /v2/mint/{type}
-     * @param type 铸造类型
-     * @param data 铸造请求数据
-     * @returns 铸造响应
-     */
-    async mint(type, data) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.mint(type, data, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * Anchor 批量铸造
-     * @route POST /v2/batch/mint/{type}
-     * @param type 铸造类型
-     * @param data 批量铸造请求数据
-     * @returns 批量铸造响应
-     */
-    async batchMint(type, data) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v2.batchMint(type, data, this.getRequestParams());
-            return response.data;
-        });
-    }
-    // ==================== Transaction Methods ====================
-    /**
-     * 处理交易哈希（加速交易处理）
-     * @route POST /v1/transaction/process/{txHash}
-     * @param txHash 交易哈希
-     * @returns 交易哈希处理响应
-     */
-    async transactionHashProcess(txHash) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v1.transactionHashProcess(txHash, this.getRequestParams());
-            return response.data;
-        });
-    }
-    /**
-     * 处理用户操作哈希
-     * @route POST /v1/transaction/process/userOpHash
-     * @param data 用户操作哈希处理请求
-     * @returns 用户操作哈希处理响应
-     */
-    async userOpHashProcess(data) {
-        return this.handleApiCall(async () => {
-            const response = await this.generatedApi.v1.userOpHashProcess(data, this.getRequestParams());
-            return response.data;
-        });
-    }
-}
-exports.AnchorApiClientV2 = AnchorApiClientV2;