@subwallet/extension-base 1.2.15-0 → 1.2.16-0

package/utils/gear/grc20.js

@@ -1,15 +1,9 @@
-// Copyright 2019-2022 @subwallet/extension-base
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-// https://github.com/breathx/gear-erc20/blob/master/js/src/lib.ts
-
 import { decodeAddress } from '@gear-js/api';
 import { TransactionBuilder } from 'sails-js';
 import { TypeRegistry } from '@polkadot/types';
-export const DEFAULT_GEAR_ADDRESS = {
-  ALICE: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
-  BOB: '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty'
-};
 export class GRC20 {
   constructor(api, programId = '0x') {
     this.api = api;
@@ -23,6 +17,7 @@ export class GRC20 {
       types
     });
     this.registry.register(types);
+    this.service = new Grc20Service(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);
@@ -34,98 +29,111 @@ export class GRC20 {
     this.programId = builder.programId;
     return builder;
   }
+}
+export class Grc20Service {
+  constructor(_program) {
+    this._program = _program;
+  }
   approve(spender, value) {
-    return new TransactionBuilder(this.api, this.registry, 'send_message', ['Approve', spender, value], '(String, ActorId, U256)', 'bool', this.programId);
+    if (!this._program.programId) {
+      throw new Error('Program ID is not set');
+    }
+    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Approve', spender, value], '(String, ActorId, U256)', 'bool', this._program.programId);
   }
   fromTransfer(from, to, value) {
-    return new TransactionBuilder(this.api, this.registry, 'send_message', ['FromTransfer', from, to, value], '(String, ActorId, ActorId, U256)', 'bool', this.programId);
+    if (!this._program.programId) {
+      throw new Error('Program ID is not set');
+    }
+    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['FromTransfer', from, to, value], '(String, ActorId, ActorId, U256)', 'bool', this._program.programId);
   }
   setBalance(newBalance) {
-    return new TransactionBuilder(this.api, this.registry, 'send_message', ['SetBalance', newBalance], '(String, U256)', 'bool', this.programId);
+    if (!this._program.programId) {
+      throw new Error('Program ID is not set');
+    }
+    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['SetBalance', newBalance], '(String, U256)', 'bool', this._program.programId);
   }
   transfer(to, value) {
-    return new TransactionBuilder(this.api, this.registry, 'send_message', ['Transfer', to, value], '(String, ActorId, U256)', 'bool', this.programId);
+    if (!this._program.programId) {
+      throw new Error('Program ID is not set');
+    }
+    return new TransactionBuilder(this._program.api, this._program.registry, 'send_message', ['Transfer', to, value], '(String, ActorId, U256)', 'bool', this._program.programId);
   }
   async allowance(owner, spender, originAddress, value, atBlock) {
-    const payload = this.registry.createType('(String, ActorId, ActorId)', ['Allowance', owner, spender]).toU8a();
-    const reply = await this.api.message.calculateReply({
-      destination: this.programId,
+    const payload = this._program.registry.createType('(String, ActorId, ActorId)', ['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.api.blockGasLimit.toBigInt(),
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
       at: atBlock
     });
-    const result = this.registry.createType('(String, U256)', reply.payload);
+    const result = this._program.registry.createType('(String, U256)', reply.payload);
     return result[1].toBigInt();
   }
   async balanceOf(owner, originAddress, value, atBlock) {
-    const payload = this.registry.createType('(String, ActorId)', ['BalanceOf', owner]).toU8a();
-    const reply = await this.api.message.calculateReply({
-      destination: this.programId,
+    const payload = this._program.registry.createType('(String, ActorId)', ['BalanceOf', owner]).toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
       origin: decodeAddress(originAddress),
       payload,
       value: value || 0,
-      gasLimit: this.api.blockGasLimit.toBigInt(),
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
       at: atBlock
     });
-    const result = this.registry.createType('(String, U256)', reply.payload);
+    const result = this._program.registry.createType('(String, U256)', reply.payload);
     return result[1].toBigInt();
   }
   async decimals(originAddress, value, atBlock) {
-    const payload = this.registry.createType('String', 'Decimals').toU8a();
-    const reply = await this.api.message.calculateReply({
-      destination: this.programId,
+    const payload = this._program.registry.createType('String', 'Decimals').toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
       origin: decodeAddress(originAddress),
       payload,
       value: value || 0,
-      gasLimit: this.api.blockGasLimit.toBigInt(),
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
       at: atBlock
     });
-    const result = this.registry.createType('(String, u8)', reply.payload);
+    const result = this._program.registry.createType('(String, u8)', reply.payload);
     return result[1].toNumber();
   }
   async name(originAddress, value, atBlock) {
-    const payload = this.registry.createType('String', 'Name').toU8a();
-    const reply = await this.api.message.calculateReply({
-      destination: this.programId,
+    const payload = this._program.registry.createType('String', 'Name').toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
       origin: decodeAddress(originAddress),
       payload,
       value: value || 0,
-      gasLimit: this.api.blockGasLimit.toBigInt(),
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
       at: atBlock
     });
-    const result = this.registry.createType('(String, String)', reply.payload);
+    const result = this._program.registry.createType('(String, String)', reply.payload);
     return result[1].toString();
   }
   async symbol(originAddress, value, atBlock) {
-    const payload = this.registry.createType('String', 'Symbol').toU8a();
-    const reply = await this.api.message.calculateReply({
-      destination: this.programId,
+    const payload = this._program.registry.createType('String', 'Symbol').toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
       origin: decodeAddress(originAddress),
       payload,
       value: value || 0,
-      gasLimit: this.api.blockGasLimit.toBigInt(),
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
       at: atBlock
     });
-    const result = this.registry.createType('(String, String)', reply.payload);
+    const result = this._program.registry.createType('(String, String)', reply.payload);
     return result[1].toString();
   }
   async totalSupply(originAddress, value, atBlock) {
-    const payload = this.registry.createType('String', 'TotalSupply').toU8a();
-    const reply = await this.api.message.calculateReply({
-      destination: this.programId,
+    const payload = this._program.registry.createType('String', 'TotalSupply').toHex();
+    const reply = await this._program.api.message.calculateReply({
+      destination: this._program.programId,
       origin: decodeAddress(originAddress),
       payload,
       value: value || 0,
-      gasLimit: this.api.blockGasLimit.toBigInt(),
+      gasLimit: this._program.api.blockGasLimit.toBigInt(),
       at: atBlock
     });
-    const result = this.registry.createType('(String, U256)', reply.payload);
+    const result = this._program.registry.createType('(String, U256)', reply.payload);
     return result[1].toBigInt();
   }
-}
-export function getGRC20ContractPromise(apiPromise, contractAddress) {
-  const gearApi = apiPromise;
-  return new GRC20(gearApi, contractAddress);
 }

package/utils/gear/index.d.ts

@@ -1 +1,3 @@
+export * from './combine';
 export * from './grc20';
+export * from './vft';

package/utils/gear/index.js

@@ -1,4 +1,6 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-export * from "./grc20.js";
+export * from "./combine.js";
+export * from "./grc20.js";
+export * from "./vft.js";

package/utils/gear/vft.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { GearApi } from '@gear-js/api';
+import { ActorId, TransactionBuilder } from 'sails-js';
+import { TypeRegistry } from '@polkadot/types';
+export declare class VFT {
+    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>;
+}
+export declare class VftService {
+    private _program;
+    constructor(_program: VFT);
+    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>;
+    allowance(owner: ActorId, spender: ActorId, originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<bigint>;
+    balanceOf(account: ActorId, originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<bigint>;
+    decimals(originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<number>;
+    name(originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<string>;
+    symbol(originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<string>;
+    totalSupply(originAddress: string, value?: number | string | bigint, atBlock?: `0x${string}`): Promise<bigint>;
+    subscribeToApprovalEvent(callback: (data: {
+        owner: ActorId;
+        spender: ActorId;
+        value: number | string | bigint;
+    }) => void | Promise<void>): Promise<() => void>;
+    subscribeToTransferEvent(callback: (data: {
+        from: ActorId;
+        to: ActorId;
+        value: number | string | bigint;
+    }) => void | Promise<void>): Promise<() => void>;
+}

package/utils/gear/vft.js

@@ -0,0 +1,162 @@
+// 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';
+export class VFT {
+  constructor(api, programId = '0x') {
+    this.api = api;
+    this.programId = programId;
+    const types = {};
+    this.registry = new TypeRegistry();
+    this.registry.setKnownTypes({
+      types
+    });
+    this.registry.register(types);
+    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);
+    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);
+    this.programId = builder.programId;
+    return builder;
+  }
+}
+export class VftService {
+  constructor(_program) {
+    this._program = _program;
+  }
+  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);
+  }
+  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);
+  }
+  transferFrom(from, 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', '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());
+      }
+    });
+  }
+}

package/utils/metadata.d.ts

@@ -1,3 +1,8 @@
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { HexString } from '@polkadot/util/types';
+import { ExtraInfo } from '@polkadot-api/merkleize-metadata';
 export declare const _isRuntimeUpdated: (signedExtensions?: string[]) => boolean;
-export declare const getMetadataHash: (chain: string) => Promise<string>;
-export declare const getShortMetadata: (chain: string, blob: string) => Promise<string>;
+export declare const calculateMetadataHash: (extraInfo: ExtraInfo, metadataV15: HexString) => string;
+export declare const getShortMetadata: (blob: HexString, extraInfo: ExtraInfo, metadata: HexString) => string;
+export declare const cacheMetadata: (chain: string, substrateApi: _SubstrateApi, chainService?: ChainService) => void;

package/utils/metadata.js

@@ -1,39 +1,49 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const LEDGER_API_URL = 'https://ledger-api.subwallet.app';
-const createUrl = path => `${LEDGER_API_URL}/${path}`;
+import { getSpecExtensions, getSpecTypes } from '@polkadot/types-known';
+import { u8aToHex } from '@polkadot/util';
+import { merkleizeMetadata } from '@polkadot-api/merkleize-metadata';
 export const _isRuntimeUpdated = signedExtensions => {
   return signedExtensions ? signedExtensions.includes('CheckMetadataHash') : false;
 };
-export const getMetadataHash = async chain => {
-  const data = {
-    id: chain
-  };
-  const resp = await fetch(createUrl('node/metadata/hash'), {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify(data)
-  });
-  const rs = await resp.json();
-  return rs.metadataHash;
+export const calculateMetadataHash = (extraInfo, metadataV15) => {
+  const _merkleizeMetadata = merkleizeMetadata(metadataV15, extraInfo);
+  return u8aToHex(_merkleizeMetadata.digest());
 };
-export const getShortMetadata = async (chain, blob) => {
-  const data = {
-    chain: {
-      id: chain
-    },
-    txBlob: blob
-  };
-  const resp = await fetch(createUrl('transaction/metadata'), {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify(data)
-  });
-  const rs = await resp.json();
-  return rs.txMetadata;
+export const getShortMetadata = (blob, extraInfo, metadata) => {
+  const _merkleizeMetadata = merkleizeMetadata(metadata, extraInfo);
+  return u8aToHex(_merkleizeMetadata.getProofForExtrinsicPayload(blob));
+};
+export const cacheMetadata = (chain, substrateApi, chainService) => {
+  // Update metadata to database with async methods
+  substrateApi.api.isReady.then(async api => {
+    const currentSpecVersion = api.runtimeVersion.specVersion.toString();
+    const specName = api.runtimeVersion.specName.toString();
+    const genesisHash = api.genesisHash.toHex();
+    const metadata = await (chainService === null || chainService === void 0 ? void 0 : chainService.getMetadata(chain));
+
+    // Avoid date existed metadata
+    if (metadata && metadata.specVersion === currentSpecVersion && metadata.genesisHash === genesisHash) {
+      return;
+    }
+    const systemChain = await api.rpc.system.chain();
+    // const _metadata: Option<OpaqueMetadata> = await api.call.metadata.metadataAtVersion(15);
+    // const metadataHex = _metadata.isSome ? _metadata.unwrap().toHex().slice(2) : ''; // Need unwrap to create metadata object
+    let hexV15;
+    const metadataV15 = await api.call.metadata.metadataAtVersion(15);
+    if (!metadataV15.isEmpty) {
+      hexV15 = metadataV15.unwrap().toHex();
+    }
+    chainService === null || chainService === void 0 ? void 0 : chainService.upsertMetadata(chain, {
+      chain: chain,
+      genesisHash: genesisHash,
+      specName: specName,
+      specVersion: currentSpecVersion,
+      hexValue: api.runtimeMetadata.toHex(),
+      types: getSpecTypes(api.registry, systemChain, api.runtimeVersion.specName, api.runtimeVersion.specVersion),
+      userExtensions: getSpecExtensions(api.registry, systemChain, api.runtimeVersion.specName),
+      hexV15
+    }).catch(console.error);
+  }).catch(console.error);
 };