@subwallet/extension-base 1.3.46-0 → 1.3.47-0

package/strategy/api-request-strategy-v2/index.js

@@ -0,0 +1,128 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { BASE_MINUTE_INTERVAL } from '@subwallet/extension-base/constants';
+import { Md5 } from 'ts-md5';
+export class BaseApiRequestStrategyV2 {
+  nextId = 0;
+  groupId = 0;
+  isRunning = false;
+  requestMap = {};
+  processInterval = undefined;
+  canceledGroupIds = new Set();
+  cacheMap = new Map();
+  getId() {
+    return this.nextId++;
+  }
+  constructor(context) {
+    this.context = context;
+  }
+  getGroupId() {
+    return this.groupId++;
+  }
+  createKeyHash(keys) {
+    return Md5.hashStr(JSON.stringify([this.constructor.name, ...keys]));
+  }
+  addRequest(run, ordinal, _groupId, keyHash) {
+    const newId = this.getId();
+    const groupId = _groupId !== null && _groupId !== void 0 ? _groupId : this.getGroupId();
+    if (this.canceledGroupIds.has(groupId)) {
+      return Promise.reject(new SWError('CANCELED', 'Request has been canceled'));
+    }
+    return new Promise((resolve, reject) => {
+      this.requestMap[newId] = {
+        cacheKey: keyHash,
+        groupId,
+        id: newId,
+        ordinal,
+        reject,
+        resolve,
+        retry: -1,
+        run,
+        status: 'pending'
+      };
+      if (!this.isRunning) {
+        this.process();
+      }
+    });
+  }
+  process() {
+    this.stop();
+    this.isRunning = true;
+    const maxRetry = this.context.maxRetry;
+    const interval = setInterval(() => {
+      const remainingRequests = Object.values(this.requestMap);
+      if (remainingRequests.length === 0) {
+        this.isRunning = false;
+        clearInterval(interval);
+        return;
+      }
+      console.log('[ApiRequestStrategyV2] Processing requests...', remainingRequests.map(r => r.groupId));
+
+      // Get first this.limit requests base on id
+      const requests = remainingRequests.filter(request => request.status !== 'running').sort((a, b) => a.id - b.id).sort((a, b) => a.ordinal - b.ordinal).slice(0, this.context.callRate);
+
+      // Start requests
+      requests.forEach(request => {
+        request.status = 'running';
+        if (request.cacheKey) {
+          if (this.cacheMap.has(request.cacheKey)) {
+            const resp = this.cacheMap.get(request.cacheKey);
+            request.resolve(resp);
+            console.log('[ApiRequestStrategyV2] Cache hit for request', request.id, 'with cache key', request.cacheKey);
+            delete this.requestMap[request.id];
+            return;
+          }
+        }
+        request.run().then(rs => {
+          request.resolve(rs);
+          if (request.cacheKey) {
+            this.cacheMap.set(request.cacheKey, rs);
+            setTimeout(() => {
+              if (request.cacheKey) {
+                this.cacheMap.delete(request.cacheKey);
+              }
+            }, BASE_MINUTE_INTERVAL);
+          }
+          delete this.requestMap[request.id];
+        }).catch(e => {
+          const isRateLimited = this.isRateLimited(e);
+
+          // Limit rate
+          if (isRateLimited) {
+            if (request.retry < maxRetry) {
+              request.status = 'pending';
+              request.retry++;
+              this.context.reduceLimitRate();
+            } else {
+              // Reject request
+              request.reject(new SWError('MAX_RETRY', String(e)));
+            }
+          } else {
+            request.reject(new SWError('UNKNOWN', String(e)));
+          }
+        });
+      });
+    }, this.context.intervalCheck);
+    this.processInterval = interval;
+  }
+  stop() {
+    clearInterval(this.processInterval);
+    this.processInterval = undefined;
+  }
+  cancelGroupRequest(groupId) {
+    Object.values(this.requestMap).forEach(request => {
+      if (request.groupId === groupId) {
+        request.reject(new SWError('CANCELED', 'Request has been canceled'));
+      }
+      this.canceledGroupIds.add(groupId);
+    });
+    this.requestMap = Object.fromEntries(Object.entries(this.requestMap).filter(([_, request]) => request.groupId !== groupId));
+  }
+  setContext(context) {
+    this.stop();
+    this.context = context;
+    this.process();
+  }
+}

package/strategy/api-request-strategy-v2/types.d.ts

@@ -0,0 +1,11 @@
+import { ApiRequest, ApiRequestContext } from '../api-request-strategy/types';
+export interface ApiRequestStrategyV2 {
+    addRequest: <T>(run: ApiRequestV2<T>['run'], groupId: number, ordinal: number) => Promise<T>;
+    setContext: (context: ApiRequestContext) => void;
+    stop: (groupId?: number) => void;
+    cancelGroupRequest: (groupId: number) => void;
+}
+export interface ApiRequestV2<T> extends ApiRequest<T> {
+    groupId: number;
+    cacheKey?: string;
+}

package/strategy/api-request-strategy-v2/types.js

@@ -0,0 +1 @@
+export {};

package/types/buy.d.ts

@@ -4,7 +4,7 @@ export interface BuyService {
     symbol: string;
 }
 export declare type SupportService = 'transak' | 'banxa' | 'coinbase' | 'moonpay' | 'onramper' | 'meld';
-export declare type OnrampAccountSupportType = 'ETHEREUM' | 'SUBSTRATE' | 'TON' | 'CARDANO';
+export declare type OnrampAccountSupportType = 'ETHEREUM' | 'SUBSTRATE' | 'TON' | 'CARDANO' | 'BITCOIN';
 export interface BuyTokenInfo {
     network: string;
     symbol: string;

package/utils/gear/combine.d.ts

@@ -1,3 +1,4 @@
+import { GearApi } from '@gear-js/api';
 import { ApiPromise } from '@polkadot/api';
 import { GRC20 } from './grc20';
 import { VFT } from './vft';
@@ -7,4 +8,4 @@ export declare const DEFAULT_GEAR_ADDRESS: {
 };
 export declare const GEAR_DEFAULT_ADDRESS = "5EYCAe5ijiYfAXEth5DGRKiKuVjTXQKr877tUPz6eLz2t9aG";
 export declare function getGRC20ContractPromise(apiPromise: ApiPromise, contractAddress: string): GRC20;
-export declare function getVFTContractPromise(apiPromise: ApiPromise, contractAddress: string): VFT;
+export declare function getVFTContractPromise(api: GearApi, contractAddress?: string): VFT;

package/utils/gear/combine.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { GRC20 } from "./grc20.js";
-import { VFT } from "./vft.js";
+import { sailsCache, VFT } from "./vft.js";
 export const DEFAULT_GEAR_ADDRESS = {
   ALICE: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
   BOB: '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty'
@@ -12,7 +12,7 @@ export function getGRC20ContractPromise(apiPromise, contractAddress) {
   const gearApi = apiPromise;
   return new GRC20(gearApi, contractAddress);
 }
-export function getVFTContractPromise(apiPromise, contractAddress) {
-  const gearApi = apiPromise;
-  return new VFT(gearApi, contractAddress);
+export function getVFTContractPromise(api, contractAddress = '0x') {
+  const sails = sailsCache.get();
+  return new VFT(api, contractAddress, sails);
 }

package/utils/gear/vft.d.ts

@@ -1,19 +1,20 @@
 /// <reference types="node" />
 import { GearApi } from '@gear-js/api';
-import { ActorId, TransactionBuilder } from 'sails-js';
-import { TypeRegistry } from '@polkadot/types';
+import { ActorId, Sails, TransactionBuilder } from 'sails-js';
 export declare class VFT {
-    api: GearApi;
+    readonly api: GearApi;
     programId: `0x${string}`;
-    readonly registry: TypeRegistry;
     readonly service: VftService;
-    constructor(api: GearApi, programId?: `0x${string}`);
-    newCtorFromCode(code: Uint8Array | Buffer, name: string, symbol: string, decimals: number): TransactionBuilder<null>;
-    newCtorFromCodeId(codeId: `0x${string}`, name: string, symbol: string, decimals: number): TransactionBuilder<null>;
+    readonly sails: Sails;
+    constructor(api: GearApi, programId: `0x${string}`, sails: Sails);
+    newCtorFromCode(code: Uint8Array | Buffer, name: string, symbol: string, decimals: number): TransactionBuilder<any>;
+    newCtorFromCodeId(codeId: `0x${string}`, name: string, symbol: string, decimals: number): TransactionBuilder<any>;
 }
 export declare class VftService {
     private _program;
     constructor(_program: VFT);
+    private get functions();
+    private get queries();
     approve(spender: ActorId, value: number | string | bigint): TransactionBuilder<boolean>;
     transfer(to: ActorId, value: number | string | bigint): TransactionBuilder<boolean>;
     transferFrom(from: ActorId, to: ActorId, value: number | string | bigint): TransactionBuilder<boolean>;
@@ -26,11 +27,21 @@ export declare class VftService {
     subscribeToApprovalEvent(callback: (data: {
         owner: ActorId;
         spender: ActorId;
-        value: number | string | bigint;
+        value: bigint;
     }) => void | Promise<void>): Promise<() => void>;
     subscribeToTransferEvent(callback: (data: {
         from: ActorId;
         to: ActorId;
-        value: number | string | bigint;
+        value: bigint;
     }) => void | Promise<void>): Promise<() => void>;
 }
+declare class SailsCache {
+    private static instance;
+    private sail;
+    private constructor();
+    static getInstance(): SailsCache;
+    init(): Promise<void>;
+    get(): Sails;
+}
+export declare const sailsCache: SailsCache;
+export {};

package/utils/gear/vft.js

@@ -1,28 +1,26 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { decodeAddress } from '@gear-js/api';
-import { getFnNamePrefix, getServiceNamePrefix, TransactionBuilder, ZERO_ADDRESS } from 'sails-js';
-import { TypeRegistry } from '@polkadot/types';
+import { Sails } from 'sails-js';
+import { SailsIdlParser } from 'sails-js-parser';
 export class VFT {
-  constructor(api, programId = '0x') {
+  constructor(api, programId = '0x', sails) {
     this.api = api;
     this.programId = programId;
-    const types = {};
-    this.registry = new TypeRegistry();
-    this.registry.setKnownTypes({
-      types
-    });
-    this.registry.register(types);
+    this.sails = sails;
+    this.sails.setApi(api);
+    this.sails.setProgramId(programId);
     this.service = new VftService(this);
   }
   newCtorFromCode(code, name, symbol, decimals) {
-    const builder = new TransactionBuilder(this.api, this.registry, 'upload_program', ['New', name, symbol, decimals], '(String, String, String, u8)', 'String', code);
+    const ctor = this.sails.ctors.New;
+    const builder = ctor.fromCode(code, name, symbol, decimals);
     this.programId = builder.programId;
     return builder;
   }
   newCtorFromCodeId(codeId, name, symbol, decimals) {
-    const builder = new TransactionBuilder(this.api, this.registry, 'create_program', ['New', name, symbol, decimals], '(String, String, String, u8)', 'String', codeId);
+    const ctor = this.sails.ctors.New;
+    const builder = ctor.fromCodeId(codeId, name, symbol, decimals);
     this.programId = builder.programId;
     return builder;
   }
@@ -31,132 +29,103 @@ export class VftService {
   constructor(_program) {
     this._program = _program;
   }
+  get functions() {
+    return this._program.sails.services.Vft.functions;
+  }
+  get queries() {
+    return this._program.sails.services.Vft.queries;
+  }
   approve(spender, value) {
-    if (!this._program.programId) {
-      throw new Error('Program ID is not set');
-    }
-    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Vft', 'Approve', spender, value], '(String, String, [u8;32], U256)', 'bool', this._program.programId);
+    return this.functions.Approve(spender, value);
   }
   transfer(to, value) {
-    if (!this._program.programId) {
-      throw new Error('Program ID is not set');
-    }
-    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Vft', 'Transfer', to, value], '(String, String, [u8;32], U256)', 'bool', this._program.programId);
+    return this.functions.Transfer(to, value);
   }
   transferFrom(from, to, value) {
-    if (!this._program.programId) {
-      throw new Error('Program ID is not set');
+    return this.functions.TransferFrom(from, to, value);
+  }
+  allowance(owner, spender, originAddress, value, atBlock) {
+    return this.queries.Allowance(originAddress, BigInt(value || 0), atBlock, owner, spender);
+  }
+  balanceOf(account, originAddress, value, atBlock) {
+    return this.queries.BalanceOf(originAddress, BigInt(value || 0), atBlock, account);
+  }
+  decimals(originAddress, value, atBlock) {
+    return this.queries.Decimals(originAddress, BigInt(value || 0), atBlock);
+  }
+  name(originAddress, value, atBlock) {
+    return this.queries.Name(originAddress, BigInt(value || 0), atBlock);
+  }
+  symbol(originAddress, value, atBlock) {
+    return this.queries.Symbol(originAddress, BigInt(value || 0), atBlock);
+  }
+  totalSupply(originAddress, value, atBlock) {
+    return this.queries.TotalSupply(originAddress, BigInt(value || 0), atBlock);
+  }
+  async subscribeToApprovalEvent(callback) {
+    return this._program.sails.services.Vft.events.Approval.subscribe(callback);
+  }
+  async subscribeToTransferEvent(callback) {
+    return this._program.sails.services.Vft.events.Transfer.subscribe(callback);
+  }
+}
+
+// Cache sai
+const vftIdl = `
+constructor {
+  New : (name: str, symbol: str, decimals: u8);
+};
+
+service Vft {
+  Approve : (spender: actor_id, value: u256) -> bool;
+  Transfer : (to: actor_id, value: u256) -> bool;
+  TransferFrom : (from: actor_id, to: actor_id, value: u256) -> bool;
+
+  query Allowance : (owner: actor_id, spender: actor_id) -> u256;
+  query BalanceOf : (account: actor_id) -> u256;
+  query Decimals : () -> u8;
+  query Name : () -> str;
+  query Symbol : () -> str;
+  query TotalSupply : () -> u256;
+
+  events {
+    Approval: struct {
+      owner: actor_id,
+      spender: actor_id,
+      value: u256,
+    };
+    Transfer: struct {
+      from: actor_id,
+      to: actor_id,
+      value: u256,
+    };
+  }
+};
+`;
+class SailsCache {
+  static instance = null;
+  sail = null;
+
+  // eslint-disable-next-line no-useless-constructor, @typescript-eslint/no-empty-function
+  constructor() {}
+  static getInstance() {
+    if (!SailsCache.instance) {
+      SailsCache.instance = new SailsCache();
     }
-    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Vft', 'TransferFrom', from, to, value], '(String, String, [u8;32], [u8;32], U256)', 'bool', this._program.programId);
-  }
-  async allowance(owner, spender, originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String, [u8;32], [u8;32])', ['Vft', 'Allowance', owner, spender]).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, U256)', reply.payload);
-    return result[2].toBigInt();
-  }
-  async balanceOf(account, originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String, [u8;32])', ['Vft', 'BalanceOf', account]).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, U256)', reply.payload);
-    return result[2].toBigInt();
-  }
-  async decimals(originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String)', ['Vft', 'Decimals']).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, u8)', reply.payload);
-    return result[2].toNumber();
-  }
-  async name(originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String)', ['Vft', 'Name']).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, String)', reply.payload);
-    return result[2].toString();
-  }
-  async symbol(originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String)', ['Vft', 'Symbol']).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, String)', reply.payload);
-    return result[2].toString();
-  }
-  async totalSupply(originAddress, value, atBlock) {
-    const payload = this._program.registry.createType('(String, String)', ['Vft', 'TotalSupply']).toHex();
-    const reply = await this._program.api.message.calculateReply({
-      destination: this._program.programId,
-      origin: decodeAddress(originAddress),
-      payload,
-      value: value || 0,
-      gasLimit: this._program.api.blockGasLimit.toBigInt(),
-      at: atBlock
-    });
-    const result = this._program.registry.createType('(String, String, U256)', reply.payload);
-    return result[2].toBigInt();
-  }
-  subscribeToApprovalEvent(callback) {
-    return this._program.api.gearEvents.subscribeToGearEvent('UserMessageSent', ({
-      data: {
-        message
-      }
-    }) => {
-      if (!message.source.eq(this._program.programId) || !message.destination.eq(ZERO_ADDRESS)) {
-        return;
-      }
-      const payload = message.payload.toHex();
-      if (getServiceNamePrefix(payload) === 'Vft' && getFnNamePrefix(payload) === 'Approval') {
-        // eslint-disable-next-line node/no-callback-literal,@typescript-eslint/no-floating-promises
-        callback(this._program.registry.createType('(String, String, {"owner":"[u8;32]","spender":"[u8;32]","value":"U256"})', message.payload)[2].toJSON());
-      }
-    });
-  }
-  subscribeToTransferEvent(callback) {
-    return this._program.api.gearEvents.subscribeToGearEvent('UserMessageSent', ({
-      data: {
-        message
-      }
-    }) => {
-      if (!message.source.eq(this._program.programId) || !message.destination.eq(ZERO_ADDRESS)) {
-        return;
-      }
-      const payload = message.payload.toHex();
-      if (getServiceNamePrefix(payload) === 'Service' && getFnNamePrefix(payload) === 'Transfer') {
-        // eslint-disable-next-line node/no-callback-literal,@typescript-eslint/no-floating-promises
-        callback(this._program.registry.createType('(String, String, {"from":"[u8;32]","to":"[u8;32]","value":"U256"})', message.payload)[2].toJSON());
-      }
-    });
-  }
-}
+    return SailsCache.instance;
+  }
+  async init() {
+    if (!this.sail) {
+      const parser = await SailsIdlParser.new();
+      const sails = new Sails(parser);
+      this.sail = sails.parseIdl(vftIdl);
+    }
+  }
+  get() {
+    if (!this.sail) {
+      throw new Error('Sails is not init yet');
+    }
+    return this.sail;
+  }
+}
+export const sailsCache = SailsCache.getInstance();