plutosdk 0.0.8-beta.1

package/lib/utils/Platform.js

@@ -0,0 +1,142 @@
+import Config from "./Config";
+import Api from "./Api";
+import user from './User';
+import net from "./Net";
+/**
+ *
+ */
+class Platform {
+    /**
+     *
+     */
+    init() {
+        Telegram.WebApp.expand();
+        Telegram.WebApp.ready();
+        Telegram.WebApp.disableVerticalSwipes();
+    }
+    /**
+     *
+     */
+    reqGameInfo() {
+        return Api.gameInfo().then(data => {
+            let game = {
+                name: data['gamename'],
+                describe: data['gamesummary'],
+                icon: data['gameicon']
+            };
+            user.gameInfo = game;
+            return game;
+        });
+    }
+    /**
+     *
+     */
+    reqLogin() {
+        return Api.login().then(data => {
+            let plutoId = user.plutoId = data['plutoid'];
+            let firstName = user.firstName = data['tgfirstname'];
+            let lastName = user.lastName = data['tglastname'];
+            let icon = user.icon = data['icon'];
+            let ticket = data['ticket'];
+            net.token = data['token'];
+            return {
+                plutoId,
+                firstName,
+                lastName,
+                icon,
+                ticket
+            };
+        });
+    }
+    /**
+     * @param productId
+     * @param name
+     * @param orderId
+     * @param price
+     * @param customData
+     */
+    reqPurchase(productId, name, orderId, amount, customData) {
+        return Api.priceExchange(amount).then(data => {
+            user.purchaseData = {
+                name: name,
+                productId: productId,
+                orderId: orderId,
+                usdt: parseFloat(data['usdt']),
+                ton: parseFloat(data['ton']),
+                not: parseFloat(data['not']),
+                star: parseInt(data['star']),
+                customData: customData
+            };
+        });
+    }
+    /**
+     *
+     * @param payType
+     * @param currency
+     */
+    reqOrder(payType, currency) {
+        const { productId, name, orderId, usdt, customData } = user.purchaseData;
+        return Api.order(productId, name, orderId, usdt, payType, currency, customData).then(data => {
+            return {
+                amount: data['amount'],
+                orderNo: data['orderNo'],
+                payload: data['payload'],
+                payLink: data['payLink'],
+                walletAddress: data['walletAddress']
+            };
+        });
+    }
+    /**
+     *
+     * @param url
+     */
+    openLink(url) {
+        Telegram.WebApp.openLink(url);
+    }
+    /**
+     *
+     * @param url
+     */
+    openTelegramLink(url) {
+        Telegram.WebApp.openTelegramLink(url);
+    }
+    /**
+     *
+     * @param url
+     */
+    openInvoice(url) {
+        return new Promise((resolve, reject) => {
+            Telegram.WebApp.openInvoice(url, (status) => {
+                //支付成功
+                if (status == 'paid') {
+                    return resolve();
+                }
+                //
+                reject();
+            });
+        });
+    }
+    /**
+     *
+     * @param content
+     */
+    share(content) {
+        let link = `https://t.me/${Config.BOT_NAME}/games?startapp=g_${Config.GAME_ID}_${user.plutoId}`;
+        let text = encodeURIComponent(content);
+        let url = `https://t.me/share/url?url=${link}&text=${text}`;
+        this.openTelegramLink(url);
+    }
+    /**
+     *
+     */
+    enableClosingConfirmation() {
+        Telegram.WebApp.enableClosingConfirmation();
+    }
+    /**
+     *
+     */
+    disableClosingConfirmation() {
+        Telegram.WebApp.disableClosingConfirmation();
+    }
+}
+export default new Platform();

package/lib/utils/User.d.ts

@@ -0,0 +1,62 @@
+import { IGame, IPurchase } from "../interface";
+/**
+ *
+ */
+declare class User {
+    private _gameInfo;
+    private _plutoId;
+    private _firstName;
+    private _lastName;
+    private _icon;
+    private _purchaseData;
+    /**
+     *
+     */
+    get gameInfo(): IGame;
+    /**
+     *
+     */
+    set gameInfo(value: IGame);
+    /**
+     *
+     */
+    get plutoId(): string;
+    /**
+     *
+     */
+    set plutoId(value: string);
+    /**
+     *
+     */
+    get firstName(): string;
+    /**
+     *
+     */
+    set firstName(value: string);
+    /**
+     *
+     */
+    get lastName(): string;
+    /**
+     *
+     */
+    set lastName(value: string);
+    /**
+     *
+     */
+    get icon(): string;
+    /**
+     *
+     */
+    set icon(value: string);
+    /**
+     *
+     */
+    get purchaseData(): IPurchase;
+    /**
+     *
+     */
+    set purchaseData(value: IPurchase);
+}
+declare const _default: User;
+export default _default;

package/lib/utils/User.js

@@ -0,0 +1,78 @@
+/**
+ *
+ */
+class User {
+    /**
+     *
+     */
+    get gameInfo() {
+        return this._gameInfo;
+    }
+    /**
+     *
+     */
+    set gameInfo(value) {
+        this._gameInfo = value;
+    }
+    /**
+     *
+     */
+    get plutoId() {
+        return this._plutoId;
+    }
+    /**
+     *
+     */
+    set plutoId(value) {
+        this._plutoId = value;
+    }
+    /**
+     *
+     */
+    get firstName() {
+        return this._firstName;
+    }
+    /**
+     *
+     */
+    set firstName(value) {
+        this._firstName = value;
+    }
+    /**
+     *
+     */
+    get lastName() {
+        return this._lastName;
+    }
+    /**
+     *
+     */
+    set lastName(value) {
+        this._lastName = value;
+    }
+    /**
+     *
+     */
+    get icon() {
+        return this._icon;
+    }
+    /**
+     *
+     */
+    set icon(value) {
+        this._icon = value;
+    }
+    /**
+     *
+     */
+    get purchaseData() {
+        return this._purchaseData || {};
+    }
+    /**
+     *
+     */
+    set purchaseData(value) {
+        this._purchaseData = value;
+    }
+}
+export default new User();

package/lib/utils/Utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param name
+ */
+export declare const getRes: (name: string) => string;
+/**
+ *
+ * @param text
+ */
+export declare const clipboard: (text: string) => Promise<void>;

package/lib/utils/Utils.js

@@ -0,0 +1,72 @@
+import Config from "./Config";
+/**
+ *
+ * @param name
+ */
+export const getRes = (name) => {
+    return `${Config.RES_URL}${name}`;
+};
+/**
+ *
+ * @param text
+ */
+export const clipboard = (text) => {
+    return new Promise((resolve, reject) => {
+        if (!text) {
+            return reject('copy content is null.');
+        }
+        //
+        writeText(text).then(() => {
+            resolve();
+        }).catch(() => {
+            execCopy(text).then(() => {
+                resolve();
+            }).catch(() => {
+                reject('copy content faile.');
+            });
+        });
+    });
+};
+/**
+ *
+ * @param text
+ */
+const writeText = (text) => {
+    return new Promise((resolve, reject) => {
+        if (!navigator || !navigator.clipboard) {
+            return reject();
+        }
+        //
+        navigator.clipboard.writeText(text).then(() => {
+            resolve();
+        }).catch(() => {
+            reject();
+        });
+    });
+};
+/**
+ *
+ * @param text
+ */
+const execCopy = (text) => {
+    return new Promise((resolve, reject) => {
+        let textArea = document.createElement("textarea");
+        textArea.value = text;
+        // 使textarea不在viewport，同时设置不可见
+        textArea.style.position = "absolute";
+        textArea.style.opacity = "0";
+        textArea.style.left = "-999999px";
+        textArea.style.top = "-999999px";
+        document.body.appendChild(textArea);
+        textArea.focus();
+        textArea.select();
+        let success = document.execCommand('copy');
+        textArea.remove();
+        if (success) {
+            resolve();
+        }
+        else {
+            reject();
+        }
+    });
+};

package/lib/utils/WalletManager.d.ts

@@ -0,0 +1,52 @@
+import { IJettonPayInfo, ITransaction } from '../interface';
+/**
+ *
+ */
+declare class WalletManager {
+    private _tonConnect;
+    private _tokenJettonWalletAddress;
+    /**
+     *
+     */
+    get connected(): boolean;
+    /**
+     *
+     */
+    get rawAddress(): string;
+    /**
+     *
+     */
+    get friendlyAddress(): string;
+    /**
+     *
+     */
+    init(): void;
+    /**
+     *
+     */
+    connect(): Promise<string>;
+    /**
+     *
+     */
+    disconnect(): Promise<void>;
+    /**
+     *
+     * @param transaction
+     */
+    sendTransaction(transaction: ITransaction): Promise<string>;
+    /**
+     *
+     * @param tokenName
+     * @param amount
+     * @param comment
+     * @param destinationWallet
+     */
+    getTokenJettonPayInfo(tokenName: string, amount: string, comment: string, destinationWallet: string): Promise<IJettonPayInfo>;
+    /**
+     *
+     * @param tokenName
+     */
+    private getTokenJettonWalletAddress;
+}
+declare const _default: WalletManager;
+export default _default;

package/lib/utils/WalletManager.js

@@ -0,0 +1,236 @@
+import { TonConnectUI, toUserFriendlyAddress } from '@tonconnect/ui';
+import PubSub from 'pubsub-js';
+import { CODE, EVENT_WALLET_CONNECT } from './constant';
+import Config from './Config';
+import net from './Net';
+/**
+ *
+ */
+class WalletManager {
+    constructor() {
+        //
+        this._tonConnect = null;
+        //
+        this._tokenJettonWalletAddress = {};
+    }
+    /**
+     *
+     */
+    get connected() {
+        return this._tonConnect.connected;
+    }
+    /**
+     *
+     */
+    get rawAddress() {
+        if (!this._tonConnect.connected) {
+            return null;
+        }
+        //
+        return this._tonConnect.wallet.account.address;
+    }
+    /**
+     *
+     */
+    get friendlyAddress() {
+        if (!this._tonConnect.connected) {
+            return null;
+        }
+        //
+        return toUserFriendlyAddress(this._tonConnect.wallet.account.address, false);
+    }
+    /**
+     *
+     */
+    init() {
+        let tonConnect = this._tonConnect = new TonConnectUI({
+            manifestUrl: Config.MANIFEST_URL
+        });
+        //
+        tonConnect.setConnectRequestParameters({
+            state: 'ready',
+            value: {
+                tonProof: 'success'
+            }
+        });
+        //
+        tonConnect.connectionRestored.then(restored => {
+            if (restored) {
+                PubSub.publish(EVENT_WALLET_CONNECT, true);
+                console.log('tonConnect restored.');
+            }
+            else {
+                console.log('tonConnect not restored.');
+            }
+        });
+    }
+    /**
+     *
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.connected) {
+                return resolve(this._tonConnect.account.address);
+            }
+            //
+            const unsubscribeStatus = this._tonConnect.onStatusChange(wallet => {
+                console.log('onStatusChange==>' + JSON.stringify(wallet));
+                unsubscribeStatus();
+                if (!wallet) {
+                    return reject({
+                        code: CODE.WalletError,
+                        message: 'wallet info is null'
+                    });
+                }
+                //
+                let address = wallet.account.address;
+                PubSub.publish(EVENT_WALLET_CONNECT, true);
+                resolve(address);
+            });
+            //
+            const unsubscribeModal = this._tonConnect.onModalStateChange(state => {
+                console.log('onModalStateChange==>' + JSON.stringify(state));
+                if (state.status == 'closed') {
+                    unsubscribeModal();
+                    if (state.closeReason != 'wallet-selected') {
+                        //钱包未连接移除订阅
+                        unsubscribeStatus();
+                        reject({
+                            code: CODE.WalletError,
+                            message: 'wallet connect failed'
+                        });
+                    }
+                }
+            });
+            //
+            this._tonConnect.openModal().then(() => {
+                console.log('openModal success');
+            }).catch(error => {
+                console.log('openModal error==>' + JSON.stringify(error));
+                unsubscribeStatus();
+                unsubscribeModal();
+                reject({
+                    code: CODE.WalletError,
+                    message: 'open modal error'
+                });
+            });
+        });
+    }
+    /**
+     *
+     */
+    disconnect() {
+        return new Promise((resolve, reject) => {
+            if (!this.connected) {
+                return reject({
+                    code: CODE.WalletError,
+                    message: 'wallet not connected'
+                });
+            }
+            //
+            this._tonConnect.disconnect().then(() => {
+                PubSub.publish(EVENT_WALLET_CONNECT, false);
+                resolve();
+            }).catch(error => {
+                reject({
+                    code: CODE.WalletError,
+                    message: 'wallet disconnect error'
+                });
+            });
+        });
+    }
+    /**
+     *
+     * @param transaction
+     */
+    sendTransaction(transaction) {
+        return new Promise((resolve, reject) => {
+            if (!this.connected) {
+                return reject({
+                    code: CODE.WalletError,
+                    message: 'wallet not connected'
+                });
+            }
+            //
+            const tx = {
+                validUntil: Math.floor(Date.now() / 1000) + 360,
+                messages: [Object.assign({}, transaction)]
+            };
+            this._tonConnect.sendTransaction(tx).then(response => {
+                console.log('transaction success');
+                resolve(response.boc);
+            }).catch(error => {
+                console.log('transaction error==>' + JSON.stringify(error));
+                reject({
+                    code: CODE.WalletError,
+                    message: 'wallet transaction error'
+                });
+            });
+        });
+    }
+    /**
+     *
+     * @param tokenName
+     * @param amount
+     * @param comment
+     * @param destinationWallet
+     */
+    getTokenJettonPayInfo(tokenName, amount, comment, destinationWallet) {
+        return new Promise((resolve, reject) => {
+            this.getTokenJettonWalletAddress(tokenName).then(address => {
+                let url = `${Config.PAYLOAD_URL}/${tokenName}/${this.rawAddress}/${destinationWallet}/${amount}/${comment}`;
+                net.get(url, null, false).then(resp => {
+                    resolve({
+                        address: address,
+                        payload: resp.data.payload
+                    });
+                }).catch(error => {
+                    reject(error);
+                });
+            }).catch(error => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     *
+     * @param tokenName
+     */
+    getTokenJettonWalletAddress(tokenName) {
+        return new Promise((resolve, reject) => {
+            if (this._tokenJettonWalletAddress[tokenName]) {
+                return resolve(this._tokenJettonWalletAddress[tokenName]);
+            }
+            //
+            let jettonAddress = Config.TOKENS_JETTON_ADDRESS[tokenName];
+            if (!jettonAddress) {
+                return reject(`token invalid: ${tokenName}`);
+            }
+            //
+            let params = {
+                'owner_address': this.rawAddress,
+                'jetton_address': jettonAddress,
+                'limit': '1',
+                'offset': '0'
+            };
+            net.get(Config.TON_CENTER_URL, params, false).then(resp => {
+                var _a;
+                let address = (_a = resp.jetton_wallets[0]) === null || _a === void 0 ? void 0 : _a.address;
+                if (!address) {
+                    //没有代币钱包地址，说明没有此代币资产
+                    return reject({
+                        code: CODE.InsufficientFunds,
+                        message: 'insufficient funds'
+                    });
+                }
+                //
+                this._tokenJettonWalletAddress[tokenName] = address;
+                resolve(address);
+            }).catch(error => {
+                reject(error);
+            });
+        });
+    }
+}
+//
+export default new WalletManager();

package/lib/utils/config.d.ts

@@ -0,0 +1,25 @@
+/**
+ *
+ */
+export default class Config {
+    static APP_VERSION: string;
+    static RES_URL: string;
+    static API_URL: string;
+    static PAYLOAD_URL: string;
+    static TON_CENTER_URL: string;
+    static TOKENS_JETTON_ADDRESS: {
+        NOT: string;
+        CATI: string;
+        USDT: string;
+    };
+    static MANIFEST_URL: string;
+    static TEST_MODE: boolean;
+    static GAME_ID: string;
+    static BOT_NAME: string;
+    static INIT_DATA: string;
+    /**
+     *
+     * @param initConfig
+     */
+    static init(): void;
+}