@paxeer-network/paxeer-bridge 0.0.2

package/src/resources/rewards/rewards.ts

@@ -0,0 +1,262 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as RewardsAPI from './rewards';
+import * as ReferralAPI from './referral';
+import {
+  Referral,
+  ReferralApplyCodeParams,
+  ReferralApplyCodeResponse,
+  ReferralRetrieveLeaderboardParams,
+  ReferralRetrieveLeaderboardResponse,
+  ReferralRetrieveStatisticsResponse,
+} from './referral';
+import * as StakingAPI from './staking';
+import {
+  Staking,
+  StakingCreatePositionParams,
+  StakingCreatePositionResponse,
+  StakingRetrievePoolsParams,
+  StakingRetrievePoolsResponse,
+  StakingRetrievePositionsResponse,
+  StakingUnstakePositionParams,
+  StakingUnstakePositionResponse,
+} from './staking';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Rewards extends APIResource {
+  referral: ReferralAPI.Referral = new ReferralAPI.Referral(this._client);
+  staking: StakingAPI.Staking = new StakingAPI.Staking(this._client);
+
+  /**
+   * Retrieve current rewards system configuration including rates, tiers, and
+   * bonuses
+   *
+   * @example
+   * ```ts
+   * const response = await client.rewards.retrieveConfig();
+   * ```
+   */
+  retrieveConfig(options?: RequestOptions): APIPromise<RewardRetrieveConfigResponse> {
+    return this._client.get('/rewards/config', options);
+  }
+
+  /**
+   * Retrieve comprehensive rewards information for a user including:
+   *
+   * - Total points and current tier
+   * - Pending and distributed rewards
+   * - Bridge volume and transaction count
+   * - Tier progress and next tier requirements
+   *
+   * @example
+   * ```ts
+   * const response = await client.rewards.retrieveDashboard(
+   *   '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+   * );
+   * ```
+   */
+  retrieveDashboard(address: string, options?: RequestOptions): APIPromise<RewardRetrieveDashboardResponse> {
+    return this._client.get(path`/rewards/dashboard/${address}`, options);
+  }
+
+  /**
+   * Retrieve top users by volume or points
+   *
+   * @example
+   * ```ts
+   * const response = await client.rewards.retrieveLeaderboard();
+   * ```
+   */
+  retrieveLeaderboard(
+    query: RewardRetrieveLeaderboardParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<RewardRetrieveLeaderboardResponse> {
+    return this._client.get('/rewards/leaderboard', { query, ...options });
+  }
+}
+
+export interface Reward {
+  id?: number;
+
+  amount?: string;
+
+  createdAt?: number;
+
+  distributedAt?: number | null;
+
+  rewardType?: 'bridge' | 'referral' | 'staking';
+
+  status?: 'pending' | 'queued' | 'distributed';
+
+  tokenSymbol?: string;
+
+  usdValue?: string;
+
+  userAddress?: string;
+}
+
+export interface RewardRetrieveConfigResponse {
+  data?: RewardRetrieveConfigResponse.Data;
+
+  success?: boolean;
+}
+
+export namespace RewardRetrieveConfigResponse {
+  export interface Data {
+    /**
+     * PXR tokens rewarded per USD bridged
+     */
+    bridgeRewardRate?: number;
+
+    earlyBirdEndsAt?: number;
+
+    earlyBirdMultiplier?: number;
+
+    isEarlyBird?: boolean;
+
+    /**
+     * Points earned per USD bridged
+     */
+    pointsPerUsd?: number;
+
+    refereeBonus?: number;
+
+    referralRewardRate?: number;
+
+    tiers?: { [key: string]: Data.Tiers };
+  }
+
+  export namespace Data {
+    export interface Tiers {
+      minVolume?: number;
+
+      name?: string;
+
+      pointsMultiplier?: number;
+
+      rewardBonus?: number;
+    }
+  }
+}
+
+export interface RewardRetrieveDashboardResponse {
+  data?: RewardRetrieveDashboardResponse.Data;
+
+  success?: boolean;
+}
+
+export namespace RewardRetrieveDashboardResponse {
+  export interface Data {
+    rewards?: Data.Rewards;
+
+    tierProgress?: Data.TierProgress;
+
+    user?: Data.User;
+  }
+
+  export namespace Data {
+    export interface Rewards {
+      distributed?: Array<RewardsAPI.Reward>;
+
+      pending?: Array<RewardsAPI.Reward>;
+
+      totalDistributed?: string;
+
+      totalPending?: string;
+    }
+
+    export interface TierProgress {
+      currentTier?: string;
+
+      nextTier?: string | null;
+
+      volumeProgress?: string;
+
+      volumeRequired?: string | null;
+    }
+
+    export interface User {
+      address?: string;
+
+      referralCode?: string;
+
+      referredBy?: string | null;
+
+      tier?: 'bronze' | 'silver' | 'gold' | 'platinum' | 'diamond';
+
+      totalBridgeCount?: number;
+
+      totalBridgeVolume?: string;
+
+      totalPoints?: number;
+    }
+  }
+}
+
+export interface RewardRetrieveLeaderboardResponse {
+  data?: Array<RewardRetrieveLeaderboardResponse.Data>;
+
+  success?: boolean;
+}
+
+export namespace RewardRetrieveLeaderboardResponse {
+  export interface Data {
+    address?: string;
+
+    rank?: number;
+
+    tier?: string;
+
+    totalBridgeVolume?: string;
+
+    totalPoints?: number;
+  }
+}
+
+export interface RewardRetrieveLeaderboardParams {
+  /**
+   * Number of users to return
+   */
+  limit?: number;
+
+  /**
+   * Leaderboard type
+   */
+  type?: 'volume' | 'points';
+}
+
+Rewards.Referral = Referral;
+Rewards.Staking = Staking;
+
+export declare namespace Rewards {
+  export {
+    type Reward as Reward,
+    type RewardRetrieveConfigResponse as RewardRetrieveConfigResponse,
+    type RewardRetrieveDashboardResponse as RewardRetrieveDashboardResponse,
+    type RewardRetrieveLeaderboardResponse as RewardRetrieveLeaderboardResponse,
+    type RewardRetrieveLeaderboardParams as RewardRetrieveLeaderboardParams,
+  };
+
+  export {
+    Referral as Referral,
+    type ReferralApplyCodeResponse as ReferralApplyCodeResponse,
+    type ReferralRetrieveLeaderboardResponse as ReferralRetrieveLeaderboardResponse,
+    type ReferralRetrieveStatisticsResponse as ReferralRetrieveStatisticsResponse,
+    type ReferralApplyCodeParams as ReferralApplyCodeParams,
+    type ReferralRetrieveLeaderboardParams as ReferralRetrieveLeaderboardParams,
+  };
+
+  export {
+    Staking as Staking,
+    type StakingCreatePositionResponse as StakingCreatePositionResponse,
+    type StakingRetrievePoolsResponse as StakingRetrievePoolsResponse,
+    type StakingRetrievePositionsResponse as StakingRetrievePositionsResponse,
+    type StakingUnstakePositionResponse as StakingUnstakePositionResponse,
+    type StakingCreatePositionParams as StakingCreatePositionParams,
+    type StakingRetrievePoolsParams as StakingRetrievePoolsParams,
+    type StakingUnstakePositionParams as StakingUnstakePositionParams,
+  };
+}

package/src/resources/rewards/staking.ts

@@ -0,0 +1,274 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Staking extends APIResource {
+  /**
+   * Stake tokens with optional lock period for higher APY
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.rewards.staking.createPosition({
+   *     amount: '1000',
+   *     tokenSymbol: 'PXR',
+   *     userAddress:
+   *       '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+   *     lockPeriodDays: 90,
+   *   });
+   * ```
+   */
+  createPosition(
+    body: StakingCreatePositionParams,
+    options?: RequestOptions,
+  ): APIPromise<StakingCreatePositionResponse> {
+    return this._client.post('/rewards/staking/stake', { body, ...options });
+  }
+
+  /**
+   * Retrieve available staking pools with APY and lock period options
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.rewards.staking.retrievePools();
+   * ```
+   */
+  retrievePools(
+    query: StakingRetrievePoolsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<StakingRetrievePoolsResponse> {
+    return this._client.get('/rewards/staking/pools', { query, ...options });
+  }
+
+  /**
+   * Retrieve all staking positions for a user with rewards
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.rewards.staking.retrievePositions(
+   *     '0x2c02efDd09B3BA1AEaDd3dCAa7aC7A37C1CBDA8A',
+   *   );
+   * ```
+   */
+  retrievePositions(address: string, options?: RequestOptions): APIPromise<StakingRetrievePositionsResponse> {
+    return this._client.get(path`/rewards/staking/${address}`, options);
+  }
+
+  /**
+   * Unstake tokens from a position. Early unstaking (before lock period ends) incurs
+   * penalties:
+   *
+   * - 10% penalty on principal
+   * - 50% penalty on accrued rewards
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.rewards.staking.unstakePosition({
+   *     positionId: 123,
+   *     userAddress:
+   *       '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+   *   });
+   * ```
+   */
+  unstakePosition(
+    body: StakingUnstakePositionParams,
+    options?: RequestOptions,
+  ): APIPromise<StakingUnstakePositionResponse> {
+    return this._client.post('/rewards/staking/unstake', { body, ...options });
+  }
+}
+
+export interface StakingCreatePositionResponse {
+  data?: StakingCreatePositionResponse.Data;
+
+  success?: boolean;
+}
+
+export namespace StakingCreatePositionResponse {
+  export interface Data {
+    amount?: string;
+
+    apy?: number;
+
+    estimatedRewards?: string;
+
+    lockPeriod?: number;
+
+    positionId?: number;
+
+    tokenSymbol?: string;
+
+    unlocksAt?: number | null;
+  }
+}
+
+export interface StakingRetrievePoolsResponse {
+  data?: Array<StakingRetrievePoolsResponse.Data>;
+
+  success?: boolean;
+}
+
+export namespace StakingRetrievePoolsResponse {
+  export interface Data {
+    enabled?: boolean;
+
+    lockPeriods?: { [key: string]: Data.LockPeriods };
+
+    minStake?: number;
+
+    tokenSymbol?: string;
+
+    userTierBonus?: number | null;
+  }
+
+  export namespace Data {
+    export interface LockPeriods {
+      apy?: number;
+
+      days?: number;
+    }
+  }
+}
+
+export interface StakingRetrievePositionsResponse {
+  data?: StakingRetrievePositionsResponse.Data;
+
+  success?: boolean;
+}
+
+export namespace StakingRetrievePositionsResponse {
+  export interface Data {
+    positions?: Array<Data.Position>;
+
+    summary?: { [key: string]: Data.Summary };
+
+    totalRewards?: string;
+
+    totalStaked?: string;
+  }
+
+  export namespace Data {
+    export interface Position {
+      id?: number;
+
+      accruedRewards?: string;
+
+      amount?: string;
+
+      apy?: number;
+
+      canUnstake?: boolean;
+
+      earlyUnstakePenalty?: Position.EarlyUnstakePenalty | null;
+
+      isLocked?: boolean;
+
+      lockPeriod?: number;
+
+      stakedAt?: number;
+
+      tokenSymbol?: string;
+
+      unlocksAt?: number | null;
+    }
+
+    export namespace Position {
+      export interface EarlyUnstakePenalty {
+        principalPenalty?: string;
+
+        rewardsPenalty?: string;
+      }
+    }
+
+    export interface Summary {
+      count?: number;
+
+      rewards?: string;
+
+      staked?: string;
+    }
+  }
+}
+
+export interface StakingUnstakePositionResponse {
+  data?: StakingUnstakePositionResponse.Data;
+
+  success?: boolean;
+}
+
+export namespace StakingUnstakePositionResponse {
+  export interface Data {
+    message?: string;
+
+    netAmount?: string;
+
+    penalty?: Data.Penalty | null;
+
+    positionId?: number;
+
+    principal?: string;
+
+    rewards?: string;
+  }
+
+  export namespace Data {
+    export interface Penalty {
+      principalPenalty?: string;
+
+      rewardsPenalty?: string;
+    }
+  }
+}
+
+export interface StakingCreatePositionParams {
+  /**
+   * Amount to stake
+   */
+  amount: string;
+
+  /**
+   * Token to stake
+   */
+  tokenSymbol: string;
+
+  userAddress: string;
+
+  /**
+   * Lock period in days (0 for flexible, or 30/90/180/365)
+   */
+  lockPeriodDays?: 0 | 30 | 90 | 180 | 365;
+}
+
+export interface StakingRetrievePoolsParams {
+  /**
+   * Optional user address for personalized APY calculation
+   */
+  userAddress?: string;
+}
+
+export interface StakingUnstakePositionParams {
+  /**
+   * Staking position ID to unstake
+   */
+  positionId: number;
+
+  userAddress: string;
+}
+
+export declare namespace Staking {
+  export {
+    type StakingCreatePositionResponse as StakingCreatePositionResponse,
+    type StakingRetrievePoolsResponse as StakingRetrievePoolsResponse,
+    type StakingRetrievePositionsResponse as StakingRetrievePositionsResponse,
+    type StakingUnstakePositionResponse as StakingUnstakePositionResponse,
+    type StakingCreatePositionParams as StakingCreatePositionParams,
+    type StakingRetrievePoolsParams as StakingRetrievePoolsParams,
+    type StakingUnstakePositionParams as StakingUnstakePositionParams,
+  };
+}

package/src/resources/rewards.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './rewards/index';

package/src/resources.ts

@@ -0,0 +1 @@
+export * from './resources/index';

package/src/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  // this config is included in the published src directory to prevent TS errors
+  // from appearing when users go to source, and VSCode opens the source .ts file
+  // via declaration maps
+  "include": ["index.ts"],
+  "compilerOptions": {
+    "target": "ES2015",
+    "lib": ["DOM", "DOM.Iterable", "ES2018"],
+    "moduleResolution": "node"
+  }
+}

package/src/uploads.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/uploads instead */
+export * from './core/uploads';

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '0.0.2'; // x-release-please-version

package/uploads.d.mts

@@ -0,0 +1,2 @@
+export * from "./core/uploads.mjs";
+//# sourceMappingURL=uploads.d.mts.map

package/uploads.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.d.mts","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""}

package/uploads.d.ts

@@ -0,0 +1,2 @@
+export * from "./core/uploads.js";
+//# sourceMappingURL=uploads.d.ts.map

package/uploads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.d.ts","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""}

package/uploads.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("./internal/tslib.js");
+/** @deprecated Import from ./core/uploads instead */
+tslib_1.__exportStar(require("./core/uploads.js"), exports);
+//# sourceMappingURL=uploads.js.map

package/uploads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.js","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":";;;AAAA,qDAAqD;AACrD,4DAA+B"}

package/uploads.mjs

@@ -0,0 +1,2 @@
+export * from "./core/uploads.mjs";
+//# sourceMappingURL=uploads.mjs.map

package/uploads.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.mjs","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""}

package/version.d.mts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.0.2";
+//# sourceMappingURL=version.d.mts.map

package/version.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.mts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.0.2";
+//# sourceMappingURL=version.d.ts.map

package/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = '0.0.2'; // x-release-please-version
+//# sourceMappingURL=version.js.map

package/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,OAAO,CAAC,CAAC,2BAA2B"}

package/version.mjs

@@ -0,0 +1,2 @@
+export const VERSION = '0.0.2'; // x-release-please-version
+//# sourceMappingURL=version.mjs.map

package/version.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.mjs","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,2BAA2B"}