586 lines
17 KiB
TypeScript
586 lines
17 KiB
TypeScript
import { singleton } from "./decorator/singleton.decorator";
|
|
import Web3 from "web3";
|
|
import {
|
|
recoverTypedSignature,
|
|
signTypedData,
|
|
SignTypedDataVersion,
|
|
} from "@metamask/eth-sig-util";
|
|
import "whatwg-fetch";
|
|
import { AllChains } from "./data/allchain";
|
|
import {
|
|
createWalletEvents,
|
|
WALLET_ACCOUNT_CHANGE,
|
|
WALLET_CHAIN_CHANGE,
|
|
WALLET_TOKEN_TYPE_CHANGE,
|
|
} from "./common/WalletEvent";
|
|
import { ERC20Standard } from "./standards/ERC20Standard";
|
|
import { ERC721Standard } from "./standards/ERC721Standard";
|
|
import { IAccount, INFT, initAccount, initNFT } from "./data/DataModel";
|
|
import { loadToken, saveData } from "./manage/DataManage";
|
|
import { WALLET_STORAGE_KEY_NAME } from "./config/constants";
|
|
import { DEFALUT_TOKENS } from "./config/chain_config";
|
|
import {
|
|
loadInternalWallet,
|
|
newMnemonic,
|
|
restoreWalletByMnemonic,
|
|
} from "./manage/WalletManage";
|
|
import { buildLoginSignMsg, signLogin } from "./util/sign.util";
|
|
import { JazzIcon } from "./comp/JazzIcon";
|
|
import { ERC1155Standard } from "./standards/ERC1155Standard";
|
|
import { ZWalletConnect } from "./comp/ZWalletConnect";
|
|
import { getJCErc721Info, getTypeByAddress, UNKNOW } from "./util/chain.util";
|
|
import { JCStandard } from "./standards/JCStandard";
|
|
import { NativeSvr } from "./services/NativeSvr";
|
|
import { ChainCommon } from "./standards/ChainCommon";
|
|
|
|
var global =
|
|
(typeof globalThis !== "undefined" && globalThis) ||
|
|
(typeof self !== "undefined" && self) ||
|
|
(typeof global !== "undefined" && global) ||
|
|
{};
|
|
|
|
window.debug = false;
|
|
|
|
export interface IChainData {
|
|
name: string;
|
|
type: string;
|
|
rpc: string;
|
|
id: number;
|
|
symbol: string;
|
|
explorerurl: string;
|
|
decimals?: number;
|
|
}
|
|
|
|
export enum WalletType {
|
|
INTERNAL = 0,
|
|
THIRD_PATH = 1,
|
|
}
|
|
@singleton
|
|
export default class JCWallet {
|
|
web3: Web3 = null;
|
|
private wallet: any = null;
|
|
private password: string = "111111";
|
|
private chainSet: Set<number> = new Set();
|
|
private chainMap: Map<number, IChainData> = new Map();
|
|
private _currentChain: IChainData;
|
|
public erc20Standard: ERC20Standard;
|
|
public erc721Standard: ERC721Standard;
|
|
public erc1155Standard: ERC1155Standard;
|
|
public chainCommon: ChainCommon;
|
|
public jcStandard: JCStandard;
|
|
public nativeSvr: NativeSvr;
|
|
public wConnect: ZWalletConnect;
|
|
public mainHandlers = createWalletEvents();
|
|
public data: IAccount[] = [];
|
|
public iconType = "jazz";
|
|
private accountIndex = 0;
|
|
private walletType: WalletType = WalletType.INTERNAL;
|
|
private rpcUrl: string = "";
|
|
public rpc: any = {};
|
|
public nativeAccount = "";
|
|
|
|
constructor({ type, chain }: { type: number; chain: number }) {
|
|
this.nativeSvr = new NativeSvr();
|
|
this.walletType = type;
|
|
chain = chain || 80001;
|
|
let data = AllChains.find((o) => o.id === chain);
|
|
if (!data) {
|
|
throw new Error("no current chain data");
|
|
}
|
|
this._currentChain = data;
|
|
this.rpcUrl = data.rpc;
|
|
console.log(`rpc url: ${this.rpcUrl}`);
|
|
if (this.walletType === WalletType.INTERNAL) {
|
|
this.prepareInternalWallet();
|
|
}
|
|
this.init({ chains: [chain], password: this.password });
|
|
window.jc = { wallet: this };
|
|
}
|
|
|
|
public get isInternal() {
|
|
return this.walletType === WalletType.INTERNAL;
|
|
}
|
|
|
|
private prepareInternalWallet() {
|
|
let token = loadToken();
|
|
if (!token) {
|
|
// check if token expired
|
|
} else {
|
|
// to goole login
|
|
}
|
|
}
|
|
|
|
public async initInternalWallet() {
|
|
let address: string = await loadInternalWallet();
|
|
this.nativeAccount = address;
|
|
console.log("native wallet address: " + address);
|
|
var start = Date.now();
|
|
this.web3 = new Web3(this.rpcUrl);
|
|
console.log(`init web3 cost: ${(Date.now() - start) / 1000}`);
|
|
this.erc20Standard = new ERC20Standard(this.web3);
|
|
console.log("init Erc20Standard");
|
|
this.erc721Standard = new ERC721Standard(this.web3);
|
|
console.log("init Erc721Standard");
|
|
this.erc1155Standard = new ERC1155Standard(this.web3);
|
|
console.log("init ERC1155Standard");
|
|
this.jcStandard = new JCStandard(this.web3);
|
|
this.chainCommon = new ChainCommon(this.web3);
|
|
console.log("init JCStandard");
|
|
this.createAccount();
|
|
// this.wallet = this.web3.eth.accounts.wallet.load(
|
|
// this.password,
|
|
// WALLET_STORAGE_KEY_NAME
|
|
// );
|
|
// console.log(`load wallet cost: ${(Date.now() - start) / 1000}`);
|
|
console.log(JSON.stringify(this.wallet[0]));
|
|
console.log(
|
|
"this.web3.eth.defaultAccount: " +
|
|
JSON.stringify(this.web3.eth.defaultAccount)
|
|
);
|
|
// if (!this.wallet || this.wallet.length === 0) {
|
|
// // this.createAccount();
|
|
// this.newWallet(this.password);
|
|
// }
|
|
// start = Date.now();
|
|
// this.data = loadData();
|
|
// console.log(`init wallet ext data cost: ${(Date.now() - start) / 1000}`);
|
|
}
|
|
/**
|
|
* init wallet connect
|
|
* @returns
|
|
*/
|
|
public async initThirdPartyWallet() {
|
|
return new Promise((resolve, reject) => {
|
|
for (const d of AllChains) {
|
|
const id = d.id;
|
|
this.rpc[id] = d.rpc;
|
|
}
|
|
|
|
this.wConnect = new ZWalletConnect(this.rpc);
|
|
// return this.wConnect.connect();
|
|
this.wConnect
|
|
.connect()
|
|
.then(() => {
|
|
//@ts-ignore
|
|
this.web3 = new Web3(this.wConnect.provider);
|
|
this.erc20Standard = new ERC20Standard(this.web3);
|
|
this.erc721Standard = new ERC721Standard(this.web3);
|
|
this.erc1155Standard = new ERC1155Standard(this.web3);
|
|
this.jcStandard = new JCStandard(this.web3);
|
|
this.chainCommon = new ChainCommon(this.web3);
|
|
return this.web3.eth.getChainId();
|
|
})
|
|
.then((chainId: number) => {
|
|
if (chainId === this._currentChain.id) {
|
|
resolve && resolve("");
|
|
} else {
|
|
this.updateCurrentChain(this.currentChain.id)
|
|
.then(() => {
|
|
resolve && resolve("");
|
|
})
|
|
.catch((err) => {
|
|
reject && reject("error change network");
|
|
});
|
|
}
|
|
})
|
|
.catch((err: Error) => {
|
|
console.log("initThirdPartyWallet error: " + err);
|
|
reject && reject(err.message);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* init chain data
|
|
* create local wallet data if there is no local wallet data
|
|
* @returns
|
|
*/
|
|
private init({ chains, password }: { chains: number[]; password: string }) {
|
|
for (let chain of chains) {
|
|
this.chainSet.add(chain);
|
|
if (!this.chainMap.has(chain)) {
|
|
let data = AllChains.find((o) => o.id === chain);
|
|
if (data) {
|
|
this.chainMap.set(chain, data);
|
|
if (!this._currentChain) {
|
|
this._currentChain = data;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
// if (this.walletType !== WalletType.INTERNAL) {
|
|
// return;
|
|
// }
|
|
}
|
|
|
|
public newWallet(password: string) {
|
|
this.password = password;
|
|
this.createAccount();
|
|
}
|
|
|
|
public restoreFromMnemonic(mnemonic: string, password: string) {
|
|
this.password = password;
|
|
this.wallet.clear();
|
|
restoreWalletByMnemonic(mnemonic, this.password);
|
|
return this.createAccount();
|
|
}
|
|
|
|
get currentChain() {
|
|
return this._currentChain;
|
|
}
|
|
|
|
updateCurrentChain(chainId: number) {
|
|
return new Promise((resolve, reject) => {
|
|
if (this.walletType === WalletType.INTERNAL) {
|
|
const chainData = this.chainMap.get(chainId);
|
|
this._currentChain = chainData;
|
|
this.web3.eth.setProvider(chainData.rpc);
|
|
this.mainHandlers.emit(WALLET_CHAIN_CHANGE, chainData);
|
|
this.updateListType("tokens");
|
|
resolve && resolve(this.currentChain);
|
|
} else {
|
|
console.log("third parth wallet change chain: " + chainId);
|
|
const chainData = this.chainMap.get(chainId);
|
|
this.wConnect
|
|
.addOrChangeChain(chainData)
|
|
.then(() => {
|
|
resolve && resolve(chainData);
|
|
})
|
|
.catch((err) => {
|
|
reject && reject(err);
|
|
});
|
|
setTimeout(() => {
|
|
// @ts-ignore
|
|
jumpToWallet();
|
|
}, 500);
|
|
}
|
|
});
|
|
}
|
|
|
|
updateListType(type: string) {
|
|
this.mainHandlers.emit(WALLET_TOKEN_TYPE_CHANGE, type);
|
|
}
|
|
|
|
get chainList() {
|
|
return [...this.chainMap.values()];
|
|
}
|
|
|
|
public saveLocal() {}
|
|
|
|
public loadLocal() {}
|
|
|
|
public saveRemote() {}
|
|
|
|
public loadRemote() {}
|
|
|
|
public currentAccount() {
|
|
if (this.walletType === WalletType.INTERNAL) {
|
|
return this.wallet[this.accountIndex];
|
|
} else {
|
|
return this.wConnect.accounts[0];
|
|
}
|
|
}
|
|
public get currentAccAddr() {
|
|
if (this.walletType === WalletType.INTERNAL) {
|
|
return this.nativeAccount;
|
|
} else {
|
|
return this.wConnect.accounts[0];
|
|
}
|
|
}
|
|
|
|
get currentAccountData() {
|
|
let address = this.currentAccount().address;
|
|
const chain = this.currentChain.id;
|
|
let data = this.data.find((o) => o.address === address);
|
|
if (!data) {
|
|
throw new Error("account data not found");
|
|
}
|
|
|
|
if (!data.tokenData[chain]) {
|
|
let tokens = DEFALUT_TOKENS[chain];
|
|
data.tokenData[chain] = {
|
|
tokens,
|
|
heros: [],
|
|
weapons: [],
|
|
chips: [],
|
|
};
|
|
}
|
|
|
|
saveData(this.data);
|
|
return data;
|
|
}
|
|
|
|
get accounts() {
|
|
return this.data;
|
|
}
|
|
|
|
public createAccount() {
|
|
// let account = this.web3.eth.accounts.create()
|
|
this.wallet = this.web3.eth.accounts.wallet;
|
|
const index = this.getMaxIdexOfType(0);
|
|
const nativePrefix = "0x000000000000000000000000";
|
|
const nativePrivateKey = `${nativePrefix}${this.currentAccAddr.slice(2)}`;
|
|
const acc = this.web3.eth.accounts.privateKeyToAccount(nativePrivateKey);
|
|
const account = this.wallet.add(acc);
|
|
this.web3.eth.defaultAccount = account.address;
|
|
console.log("web3 account: " + JSON.stringify(this.wallet[0]));
|
|
|
|
this.wallet.save(this.password, WALLET_STORAGE_KEY_NAME);
|
|
const chain = this.currentChain.id;
|
|
let data = this.data.find((o) => o.address === account.address);
|
|
if (!data) {
|
|
const nickname = `Account ${index + 1}`;
|
|
data = initAccount({
|
|
address: account.address,
|
|
chain,
|
|
nickname,
|
|
type: 0,
|
|
index,
|
|
});
|
|
this.data.push(data);
|
|
saveData(this.data);
|
|
}
|
|
|
|
this.accountIndex = this.wallet.length - 1;
|
|
this.mainHandlers.emit(WALLET_ACCOUNT_CHANGE, account.address);
|
|
return account.address;
|
|
}
|
|
|
|
public importAccount(privateKey: string) {
|
|
const account = this.wallet.add(privateKey);
|
|
const chain = this.currentChain.id;
|
|
let data = this.data.find((o) => o.address === account.address);
|
|
if (!data) {
|
|
const index = this.getMaxIdexOfType(1);
|
|
const nickname = `Imported ${index + 1}`;
|
|
data = initAccount({
|
|
address: account.address,
|
|
chain,
|
|
nickname,
|
|
type: 1,
|
|
index,
|
|
});
|
|
this.data.push(data);
|
|
saveData(this.data);
|
|
}
|
|
this.web3.eth.accounts.wallet.save(this.password, WALLET_STORAGE_KEY_NAME);
|
|
this.accountIndex = this.wallet.length - 1;
|
|
this.mainHandlers.emit(WALLET_ACCOUNT_CHANGE, account.address);
|
|
return account.address;
|
|
}
|
|
|
|
private getMaxIdexOfType(type: number) {
|
|
let maxIdx = -1;
|
|
for (let i = 0, l = this.data.length; i < l; i++) {
|
|
if (this.data[i].type !== type) {
|
|
continue;
|
|
}
|
|
maxIdx = Math.max(this.data[i].index, maxIdx);
|
|
}
|
|
return maxIdx + 1;
|
|
}
|
|
private getAccountByAddress(address: string) {
|
|
let account;
|
|
let index = 0;
|
|
for (let i = 0, l = this.wallet.length; i < l; i++) {
|
|
if (this.wallet[i].address === address) {
|
|
account = this.wallet[i];
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
return { account, index };
|
|
}
|
|
|
|
public selectAccount(address: string) {
|
|
const { index } = this.getAccountByAddress(address);
|
|
if (index !== this.accountIndex && index < this.wallet.length) {
|
|
this.accountIndex = index;
|
|
this.mainHandlers.emit(WALLET_ACCOUNT_CHANGE, this.wallet[index].address);
|
|
}
|
|
return address;
|
|
}
|
|
|
|
public async sendEth(to: string, amount: number | string) {
|
|
let from = this.currentAccount().address;
|
|
const amountToSend = this.web3.utils.toWei(amount + "", "ether");
|
|
let gas = await this.web3.eth.estimateGas({
|
|
from,
|
|
to,
|
|
value: amountToSend,
|
|
});
|
|
this.web3.eth.sendTransaction({ from, to, gas, value: amountToSend });
|
|
}
|
|
|
|
public async getBalance(address?: string) {
|
|
console.log("get balance with address: ", address);
|
|
let balance = await this.chainCommon.getBalance(address);
|
|
return balance;
|
|
}
|
|
|
|
public signTypedDataV4(signObj: any) {
|
|
const account = this.currentAccount();
|
|
return signTypedData({
|
|
data: signObj,
|
|
privateKey: Buffer.from(account.privateKey.replace("0x", ""), "hex"),
|
|
version: SignTypedDataVersion.V4,
|
|
});
|
|
}
|
|
|
|
public loginSign(nonce: string, tips: string, address?: string) {
|
|
return new Promise((resolve, reject) => {
|
|
const account = this.currentAccount();
|
|
if (this.walletType === WalletType.INTERNAL) {
|
|
const sig = signLogin(nonce, tips, account.privateKey);
|
|
resolve && resolve(sig);
|
|
} else {
|
|
const signObj = buildLoginSignMsg(nonce, tips);
|
|
this.wConnect
|
|
.signData(signObj, account)
|
|
.then((sig) => {
|
|
resolve && resolve(sig);
|
|
})
|
|
.catch((err) => {
|
|
reject && reject(err);
|
|
});
|
|
setTimeout(() => {
|
|
// @ts-ignore
|
|
jumpToWallet();
|
|
}, 500);
|
|
}
|
|
});
|
|
}
|
|
|
|
public recoverTypedSignatureV4(signObj: any, signature: string) {
|
|
return recoverTypedSignature({
|
|
data: signObj,
|
|
signature,
|
|
version: SignTypedDataVersion.V4,
|
|
});
|
|
}
|
|
|
|
public generateIconData(msg: string, diameter: number) {
|
|
let icon = new JazzIcon();
|
|
return icon.init(msg, diameter);
|
|
}
|
|
|
|
public async erc20Info(address: string) {
|
|
let symbol = await this.erc20Standard.getTokenSymbol(address);
|
|
let decimal = await this.erc20Standard.getTokenDecimals(address);
|
|
return { symbol, decimal };
|
|
}
|
|
|
|
public async erc20Balance(address: string, account?: string) {
|
|
if (!account) {
|
|
account = this.currentAccount().address;
|
|
}
|
|
let result = await this.erc20Standard.getBalanceOf(address, account);
|
|
return result;
|
|
}
|
|
|
|
public async sendErc20(address: string, to: string, amount: string) {
|
|
let from = this.currentAccount().address;
|
|
let result = await this.erc20Standard.transfer({
|
|
address,
|
|
from,
|
|
to,
|
|
amount,
|
|
});
|
|
return result;
|
|
}
|
|
|
|
private async updateTokenInfo(
|
|
data: INFT,
|
|
address: string,
|
|
index: number,
|
|
account: string
|
|
) {
|
|
const tokenId = await this.wallet.erc721Standard.getCollectibleTokenId(
|
|
address,
|
|
account,
|
|
index
|
|
);
|
|
const info = await getJCErc721Info(tokenId);
|
|
data.tokenId = tokenId;
|
|
data.name = info.name;
|
|
data.desc = info.description;
|
|
data.image = info.image;
|
|
data.last = Date.now();
|
|
}
|
|
|
|
public async nftInfo(
|
|
address: string,
|
|
index: number,
|
|
account: string,
|
|
refresh: boolean
|
|
) {
|
|
account = account || this.currentAccount().address;
|
|
const chain = this.wallet.currentChain.id;
|
|
const { categor, type } = getTypeByAddress(chain, address);
|
|
let nfts = [];
|
|
if (categor !== UNKNOW) {
|
|
nfts = this.currentAccountData.tokenData[chain][`${categor}s`];
|
|
}
|
|
let needRefresh = !(nfts.length > index && nfts[index].tokenId && !refresh);
|
|
if (needRefresh) {
|
|
this.updateTokenInfo(nfts[index], address, index, account);
|
|
saveData(this.data);
|
|
}
|
|
return nfts[index];
|
|
}
|
|
|
|
public async nftList(address: string, account?: string) {
|
|
account = account || this.currentAccount().address;
|
|
const chain = this.wallet.currentChain.id;
|
|
const amount = await this.erc721Standard.getBalance(address, account);
|
|
const { categor, type } = getTypeByAddress(chain, address);
|
|
let nfts = [];
|
|
if (categor !== UNKNOW) {
|
|
nfts = this.currentAccountData.tokenData[chain][`${categor}s`];
|
|
}
|
|
let refresh = false;
|
|
if (nfts.length !== amount) {
|
|
refresh = true;
|
|
}
|
|
if (refresh) {
|
|
nfts.length = 0;
|
|
for (let i = 0; i < amount; i++) {
|
|
const nftData = initNFT(address, i, type);
|
|
nfts.push(nftData);
|
|
}
|
|
}
|
|
return nfts;
|
|
}
|
|
|
|
public async sendNFT(address: string, to: string, tokenId: string) {
|
|
let from = this.currentAccount().address;
|
|
let result = await this.erc721Standard.transfer({
|
|
address,
|
|
from,
|
|
to,
|
|
tokenId,
|
|
});
|
|
return result;
|
|
}
|
|
|
|
public async erc1155Info(address: string) {}
|
|
|
|
public async erc1155List(address: string, account?: string) {
|
|
if (!account) {
|
|
account = this.currentAccount().address;
|
|
}
|
|
}
|
|
//TODO::
|
|
public async sendErc1155() {}
|
|
}
|
|
|
|
// window.jc = window.jc || {wallet: new JCWallet()};
|
|
|
|
export * from "./common/WalletEvent";
|
|
export * from "./common/ZError";
|
|
export * from "./config/chain_config";
|
|
export * from "./util/number.util";
|
|
export * from "./util/wallet.util";
|
|
export * from "./data/DataModel";
|
|
export * from "./lib/WalletConnect";
|