@jolibox/implement 1.1.56 → 1.2.0-beta.9

package/dist/native/api/ads.d.ts

@@ -1 +1,5 @@
 import '../rewards';
+export declare const showGemSuccessToast: (params: {
+    quantity: number;
+    balance: number;
+}) => void;

package/dist/native/payment/payment-helper.d.ts

@@ -1,4 +1,4 @@
-export type PaymentType = 'JOLI_COIN' | 'JOLI_COIN_IAP';
+export type PaymentType = 'JOLI_COIN' | 'JOLI_COIN_IAP' | 'JOLI_GEM_IAP';
 import { StandardResponse } from '@jolibox/types';
 type PaymentResult = StandardResponse<void>;
 export interface PaymentHandlerMap {
@@ -7,6 +7,10 @@ export interface PaymentHandlerMap {
         productId: string;
         appStoreProductId: string;
     }) => Promise<PaymentResult>;
+    JOLI_GEM_IAP: (params: {
+        productId: string;
+        appStoreProductId: string;
+    }) => Promise<PaymentResult>;
 }
 export type PaymentHandler<T extends PaymentType> = PaymentHandlerMap[T];
 export declare function createPaymentHelper(): {

package/dist/native/rewards/check-frequency.d.ts

@@ -19,6 +19,30 @@ export declare const checkUnloginModalFrequency: (config: {
     canShow: boolean;
     isFirst: boolean;
 }>;
+export declare const checkUseModalFrequencyGem: (config: {
+    dailyMaxPopUps?: number;
+    minInterval?: number;
+}) => Promise<{
+    canShow: boolean;
+    isFirst: boolean;
+}>;
+export declare const checkPaymentFrequencyGem: (config: {
+    dailyMaxPopUps?: number;
+    minInterval?: number;
+}) => Promise<{
+    canShow: boolean;
+    isFirst: boolean;
+}>;
+export declare const checkUnloginModalFrequencyGem: (config: {
+    dailyMaxPopUps?: number;
+    minInterval?: number;
+}) => Promise<{
+    canShow: boolean;
+    isFirst: boolean;
+}>;
 export declare const updateUseModalFrequency: () => Promise<void>;
 export declare const updatePaymentFrequency: () => Promise<void>;
 export declare const updateUnloginModalFrequency: () => Promise<void>;
+export declare const updateUseModalFrequencyGem: () => Promise<void>;
+export declare const updatePaymentFrequencyGem: () => Promise<void>;
+export declare const updateUnloginModalFrequencyGem: () => Promise<void>;

package/dist/native/rewards/ui/utils.d.ts

@@ -3,4 +3,4 @@
  * @param enabled 是否启用自动扣费
  * @returns Promise 更新操作的Promise
  */
-export declare const updateAutoDeductConfig: (enabled: boolean) => Promise<void>;
+export declare const updateAutoDeductConfig: (enabled: boolean, api: string) => Promise<void>;

package/implement.build.log

@@ -1,9 +1,9 @@
 Invoking: npm run clean && npm run build:esm && tsc 
 
-> @jolibox/implement@1.1.56 clean
+> @jolibox/implement@1.2.0-beta.9 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.1.56 build:esm
+> @jolibox/implement@1.2.0-beta.9 build:esm
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=esm
 

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@jolibox/implement",
   "description": "This project is Jolibox JS-SDk implement for Native && H5",
-  "version": "1.1.56",
+  "version": "1.2.0-beta.9",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.1.56",
-    "@jolibox/types": "1.1.56",
-    "@jolibox/native-bridge": "1.1.56",
-    "@jolibox/ads": "1.1.56",
+    "@jolibox/common": "1.2.0-beta.9",
+    "@jolibox/types": "1.2.0-beta.9",
+    "@jolibox/native-bridge": "1.2.0-beta.9",
+    "@jolibox/ads": "1.2.0-beta.9",
     "localforage": "1.10.0",
     "@jolibox/ui": "1.0.0",
     "web-vitals": "4.2.4"

package/src/common/rewards/__tests__/can-use-jolicoin.test.ts

@@ -1,12 +1,13 @@
-import { IUnlockOptionType } from '../type';
-import { canUseJolicoin } from '../registers/utils';
+import { IUnlockOptionType, IGem } from '../type';
+import { canUseJolicoin, joliCoinIsEnough, canUseGem, gemIsEnough } from '../registers/utils';
 
 describe('canUseJolicoin', () => {
   it('should return true when joliCoin balance is sufficient and autoDeduct is enabled', () => {
     const unlockOptions = [
       {
         type: 'JOLI_COIN' as IUnlockOptionType,
-        joliCoinChoices: [{ joliCoinQuantity: 100 }]
+        joliCoinChoices: [{ joliCoinQuantity: 100 }],
+        joliGemChoice: null
       }
     ];
     const joliCoin = { balance: 100, enableAutoDeduct: true };
@@ -18,7 +19,8 @@ describe('canUseJolicoin', () => {
     const unlockOptions = [
       {
         type: 'JOLI_COIN' as IUnlockOptionType,
-        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+        joliCoinChoices: [{ joliCoinQuantity: 50 }],
+        joliGemChoice: null
       }
     ];
     const joliCoin = { balance: 100, enableAutoDeduct: true };
@@ -30,7 +32,8 @@ describe('canUseJolicoin', () => {
     const unlockOptions = [
       {
         type: 'JOLI_COIN' as IUnlockOptionType,
-        joliCoinChoices: [{ joliCoinQuantity: 150 }]
+        joliCoinChoices: [{ joliCoinQuantity: 150 }],
+        joliGemChoice: null
       }
     ];
     const joliCoin = { balance: 100, enableAutoDeduct: true };
@@ -42,7 +45,8 @@ describe('canUseJolicoin', () => {
     const unlockOptions = [
       {
         type: 'JOLI_COIN' as IUnlockOptionType,
-        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+        joliCoinChoices: [{ joliCoinQuantity: 50 }],
+        joliGemChoice: null
       }
     ];
     const joliCoin = { balance: 100, enableAutoDeduct: false };
@@ -54,7 +58,8 @@ describe('canUseJolicoin', () => {
     const unlockOptions = [
       {
         type: 'ADS' as IUnlockOptionType,
-        joliCoinChoices: []
+        joliCoinChoices: [],
+        joliGemChoice: null
       }
     ];
     const joliCoin = { balance: 100, enableAutoDeduct: true };
@@ -73,7 +78,8 @@ describe('canUseJolicoin', () => {
     const unlockOptions = [
       {
         type: 'JOLI_COIN' as IUnlockOptionType,
-        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+        joliCoinChoices: [{ joliCoinQuantity: 50 }],
+        joliGemChoice: null
       }
     ];
 
@@ -84,7 +90,8 @@ describe('canUseJolicoin', () => {
     const unlockOptions = [
       {
         type: 'JOLI_COIN' as IUnlockOptionType,
-        joliCoinChoices: [{ joliCoinQuantity: 200 }, { joliCoinQuantity: 50 }]
+        joliCoinChoices: [{ joliCoinQuantity: 200 }, { joliCoinQuantity: 50 }],
+        joliGemChoice: null
       }
     ];
     const joliCoin = { balance: 100, enableAutoDeduct: true };
@@ -92,3 +99,252 @@ describe('canUseJolicoin', () => {
     expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
   });
 });
+
+describe('joliCoinIsEnough', () => {
+  it('should return true when joliCoin balance is sufficient', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 100 }],
+        joliGemChoice: null
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: false }; // autoDeduct disabled but should still return true
+
+    expect(joliCoinIsEnough(unlockOptions, joliCoin)).toBe(true);
+  });
+
+  it('should return false when joliCoin balance is insufficient', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 150 }],
+        joliGemChoice: null
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(joliCoinIsEnough(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when there is no JOLI_COIN option', () => {
+    const unlockOptions = [
+      {
+        type: 'ADS' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: null
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(joliCoinIsEnough(unlockOptions, joliCoin)).toBe(false);
+  });
+});
+
+describe('canUseGem', () => {
+  it('should return true when gem balance is sufficient and autoDeduct is enabled', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 50 }
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(canUseGem(unlockOptions, gem)).toBe(true);
+  });
+
+  it('should return true when gem balance is more than required', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 25 }
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(canUseGem(unlockOptions, gem)).toBe(true);
+  });
+
+  it('should return false when gem balance is insufficient', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 75 }
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(canUseGem(unlockOptions, gem)).toBe(false);
+  });
+
+  it('should return false when autoDeduct is disabled', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 25 }
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: false };
+
+    expect(canUseGem(unlockOptions, gem)).toBe(false);
+  });
+
+  it('should return false when there is no JOLI_GEM option', () => {
+    const unlockOptions = [
+      {
+        type: 'ADS' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: null
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(canUseGem(unlockOptions, gem)).toBe(false);
+  });
+
+  it('should return false with empty unlockOptions', () => {
+    const unlockOptions: any[] = [];
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(canUseGem(unlockOptions, gem)).toBe(false);
+  });
+
+  it('should return false when gem is undefined', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 25 }
+      }
+    ];
+
+    expect(canUseGem(unlockOptions, undefined)).toBe(false);
+  });
+
+  it('should return true when at least one gem choice is valid', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 25 }
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(canUseGem(unlockOptions, gem)).toBe(true);
+  });
+});
+
+describe('gemIsEnough', () => {
+  it('should return true when gem balance is sufficient', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 50 }
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: false }; // autoDeduct disabled but should still return true
+
+    expect(gemIsEnough(unlockOptions, gem)).toBe(true);
+  });
+
+  it('should return false when gem balance is insufficient', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 75 }
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(gemIsEnough(unlockOptions, gem)).toBe(false);
+  });
+
+  it('should return false when there is no JOLI_GEM option', () => {
+    const unlockOptions = [
+      {
+        type: 'ADS' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: null
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(gemIsEnough(unlockOptions, gem)).toBe(false);
+  });
+
+  it('should return true when at least one gem choice has sufficient balance', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 24 }
+      }
+    ];
+    const gem = { balance: 50, enableAutoDeduct: false };
+
+    expect(gemIsEnough(unlockOptions, gem)).toBe(true);
+  });
+});
+
+describe('Mixed currency options', () => {
+  it('should work correctly with both JOLI_COIN and JOLI_GEM options', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 100 }],
+        joliGemChoice: null
+      },
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 50 }
+      }
+    ];
+
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+    expect(canUseGem(unlockOptions, gem)).toBe(true);
+    expect(joliCoinIsEnough(unlockOptions, joliCoin)).toBe(true);
+    expect(gemIsEnough(unlockOptions, gem)).toBe(true);
+  });
+
+  it('should return false for coin when only gem options available', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_GEM' as IUnlockOptionType,
+        joliCoinChoices: [],
+        joliGemChoice: { joliGemQuantity: 50 }
+      }
+    ];
+
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+    expect(joliCoinIsEnough(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false for gem when only coin options available', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 100 }],
+        joliGemChoice: null
+      }
+    ];
+
+    const gem = { balance: 50, enableAutoDeduct: true };
+
+    expect(canUseGem(unlockOptions, gem)).toBe(false);
+    expect(gemIsEnough(unlockOptions, gem)).toBe(false);
+  });
+});

package/src/common/rewards/fetch-reward.ts

@@ -14,15 +14,24 @@ import { hostEmitter } from '@jolibox/common';
 
 const priority = () => {
   return (a: RewardType, b: RewardType) => {
-    if (a === 'JOLI_COIN' && b === 'ADS') return -1;
-    if (a === 'ADS' && b === 'JOLI_COIN') return 1;
-    return 0;
+    // Priority order: GEM > JOLI_COIN > ADS
+    const priorityMap: Record<RewardType, number> = {
+      JOLI_GEM: 3,
+      JOLI_GEM_ONLY: 3,
+      JOLI_COIN: 2,
+      JOLI_COIN_ONLY: 2,
+      ADS: 1
+    };
+
+    return priorityMap[b] - priorityMap[a];
   };
 };
 
 const sortRewards = (rewardsTypes: RewardType[]): RewardType[] => {
   if (!rewardsTypes.length) return ['ADS'];
+  if (rewardsTypes.includes('JOLI_GEM') && rewardsTypes.length <= 1) return ['JOLI_GEM_ONLY'];
   if (rewardsTypes.includes('JOLI_COIN') && rewardsTypes.length <= 1) return ['JOLI_COIN_ONLY'];
+
   return rewardsTypes.sort(priority());
 };
 
@@ -34,11 +43,17 @@ export const createRewardFetcher = (rewardsHelper: RewardsHelper) => {
       if (res.code !== 'SUCCESS') {
         return defaultRewards;
       }
+
+      console.log('-----res fetch reward-----', res);
       rewardsEmitter.emit(UnlockOptionsEventName, {
         options: res.data?.unlockOptions || [],
         userJoliCoin: res.extra?.joliCoin || {
           balance: 0,
           enableAutoDeduct: false
+        },
+        userGem: res.extra?.joliGem || {
+          balance: 0,
+          enableAutoDeduct: false
         }
       });
 

package/src/common/rewards/index.ts

@@ -8,3 +8,5 @@ createRewardFrequencyConfigFetcher(rewardsHelper);
 export * from './registers/use-ads';
 export * from './registers/use-jolicoin';
 export * from './registers/use-jolicoin-only';
+export * from './registers/use-gem';
+export * from './registers/use-gem-only';

package/src/common/rewards/registers/use-gem-only.ts

@@ -0,0 +1,58 @@
+import { IHttpClient } from '@/common/http';
+import { IAdBreakParams } from '@/common/ads';
+import { createCommonGemRewardHandler } from './utils/coins/joligem/gem-handler';
+import { unlockOptionsHandler } from './utils/common';
+import {
+  createShowUnlockWithCurrencyModal,
+  createInitiateAndAwaitPayment,
+  createShowUnloginModal
+} from './utils/coins/commands';
+
+export type GemOnlyRewardsHandler = (params: IAdBreakParams) => Promise<boolean>;
+export const createGemOnlyRewardHandler = (
+  httpClient: IHttpClient,
+  {
+    onUnlockSuccess,
+    onUnlockFailed
+  }: {
+    onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
+    onUnlockFailed?: () => void;
+  }
+): GemOnlyRewardsHandler => {
+  const handleUnlockFailed = (() => (params: IAdBreakParams) => {
+    onUnlockFailed?.();
+    params.adBreakDone?.({
+      breakType: params.type,
+      breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
+      breakStatus: 'noAdPreloaded'
+    });
+  })();
+
+  const showUnlockWithGemModal = createShowUnlockWithCurrencyModal('JOLI_GEM', {
+    confirmButtonText: 'joligem.useJolicoin', // TODO: change key
+    cancelButtonText: 'jolicoin.noThanks'
+  });
+
+  const initiateAndAwaitPayment = createInitiateAndAwaitPayment('JOLI_GEM', {
+    confirmButtonText: 'jolicoin.payAndUnlock',
+    cancelButtonText: 'jolicoin.noThanks'
+  });
+
+  const showUnloginModal = createShowUnloginModal('JOLI_GEM', {
+    confirmButtonText: 'loginGuide.login',
+    cancelButtonText: 'loginGuide.noThanks'
+  });
+
+  const gemOnlyRewardHandler = createCommonGemRewardHandler('JOLI_GEM', httpClient, {
+    handlers: {
+      handleUnlockSuccess: onUnlockSuccess,
+      handleUnlockFailed,
+      unlockOptionsHandler,
+      initiateAndAwaitPayment,
+      showUnlockWithCurrencyModal: showUnlockWithGemModal,
+      showUnloginModal
+    }
+  });
+
+  return gemOnlyRewardHandler;
+};

package/src/common/rewards/registers/use-gem.ts

@@ -0,0 +1,53 @@
+import { IHttpClient } from '@/common/http';
+import { IAdBreakParams } from '@/common/ads';
+import { unlockOptionsHandler } from './utils/common';
+import { createCommonGemRewardHandler } from './utils/coins/joligem/gem-handler';
+import {
+  createShowUnlockWithCurrencyModal,
+  createInitiateAndAwaitPayment,
+  createShowUnloginModal
+} from './utils/coins/commands';
+
+export type GemRewardsHandler = (params: IAdBreakParams) => Promise<boolean>;
+export const createGemRewardHandler = (
+  httpClient: IHttpClient,
+  {
+    onUnlockSuccess,
+    onUnlockFailed
+  }: {
+    onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
+    onUnlockFailed?: () => void;
+  }
+): GemRewardsHandler => {
+  const handleUnlockFailed = () => {
+    onUnlockFailed?.();
+  };
+
+  const showUnlockWithGemModal = createShowUnlockWithCurrencyModal('ADS-JOLI_GEM', {
+    confirmButtonText: 'joligem.useJolicoin', // TODO: change key
+    cancelButtonText: 'jolicoin.noWatchAds'
+  });
+
+  const initiateAndAwaitPayment = createInitiateAndAwaitPayment('ADS-JOLI_GEM', {
+    confirmButtonText: 'jolicoin.payAndUnlock', // 复用文案
+    cancelButtonText: 'jolicoin.noWatchAds'
+  });
+
+  const showUnloginModal = createShowUnloginModal('ADS-JOLI_GEM', {
+    confirmButtonText: 'loginGuide.login',
+    cancelButtonText: 'loginGuide.noWatchAds'
+  });
+
+  const gemRewardHandler = createCommonGemRewardHandler('ADS-JOLI_GEM', httpClient, {
+    handlers: {
+      handleUnlockSuccess: onUnlockSuccess,
+      handleUnlockFailed,
+      unlockOptionsHandler,
+      initiateAndAwaitPayment,
+      showUnlockWithCurrencyModal: showUnlockWithGemModal,
+      showUnloginModal
+    }
+  });
+
+  return gemRewardHandler;
+};

package/src/common/rewards/registers/use-jolicoin-only.ts

@@ -1,9 +1,9 @@
 import { IHttpClient } from '@/common/http';
 import { IAdBreakParams } from '@/common/ads';
-import { createCommonJolicoinRewardHandler } from './utils/coins';
+import { createCommonJolicoinRewardHandler } from './utils/coins/jolicoin/jolicoin-handler';
 import { unlockOptionsHandler } from './utils/common';
 import {
-  createShowUnlockWithJolicoinModal,
+  createShowUnlockWithCurrencyModal,
   createInitiateAndAwaitPayment,
   createShowUnloginModal
 } from './utils/coins/commands';
@@ -28,7 +28,7 @@ export const createJolicoinOnlyRewardHandler = (
     });
   })();
 
-  const showUnlockWithJolicoinModal = createShowUnlockWithJolicoinModal('JOLI_COIN', {
+  const showUnlockWithJolicoinModal = createShowUnlockWithCurrencyModal('JOLI_COIN', {
     confirmButtonText: 'jolicoin.useJolicoin',
     cancelButtonText: 'jolicoin.noThanks'
   });
@@ -49,7 +49,7 @@ export const createJolicoinOnlyRewardHandler = (
       handleUnlockFailed,
       unlockOptionsHandler,
       initiateAndAwaitPayment,
-      showUnlockWithJolicoinModal,
+      showUnlockWithCurrencyModal: showUnlockWithJolicoinModal,
       showUnloginModal
     }
   });

package/src/common/rewards/registers/use-jolicoin.ts

@@ -1,9 +1,9 @@
 import { IHttpClient } from '@/common/http';
 import { IAdBreakParams } from '@/common/ads';
 import { unlockOptionsHandler } from './utils/common';
-import { createCommonJolicoinRewardHandler } from './utils/coins';
+import { createCommonJolicoinRewardHandler } from './utils/coins/jolicoin/jolicoin-handler';
 import {
-  createShowUnlockWithJolicoinModal,
+  createShowUnlockWithCurrencyModal,
   createInitiateAndAwaitPayment,
   createShowUnloginModal
 } from './utils/coins/commands';
@@ -23,7 +23,7 @@ export const createJolicoinRewardHandler = (
     onUnlockFailed?.();
   };
 
-  const showUnlockWithJolicoinModal = createShowUnlockWithJolicoinModal('ADS-JOLI_COIN', {
+  const showUnlockWithJolicoinModal = createShowUnlockWithCurrencyModal('ADS-JOLI_COIN', {
     confirmButtonText: 'jolicoin.useJolicoin',
     cancelButtonText: 'jolicoin.noWatchAds'
   });
@@ -44,7 +44,7 @@ export const createJolicoinRewardHandler = (
       handleUnlockFailed,
       unlockOptionsHandler,
       initiateAndAwaitPayment,
-      showUnlockWithJolicoinModal,
+      showUnlockWithCurrencyModal: showUnlockWithJolicoinModal,
       showUnloginModal
     }
   });