vue-tronlink
Version:
Vue support for the TronLink browser extension
1,184 lines (1,021 loc) • 32.2 kB
text/typescript
/* DO NOT EDIT THE BELOW FILE AS THIS IS LIKELY WILL BE GENERATED AGAIN AND REWRITE OVER IT */
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma enum-naming
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace no-camelcase
// tslint:disable:no-unused-variable
import TronWeb, {BigNumber, version, Contract} from "tronweb"
import BaseContract from "./base/base"
// eslint-disable-next-line import/named
export interface ApprovalEventArgs {
owner: string;
spender: string;
value: BigNumber;
}
export interface MinterAddedEventArgs {
account: string;
}
export interface MinterRemovedEventArgs {
account: string;
}
export interface TransferEventArgs {
from: string;
to: string;
value: BigNumber;
}
type Param = {
type: string,
value: any
}
export interface ContractInterface {
addMinter(account: string): Promise<void>
allowance(owner: string, spender: string): Promise<BigNumber>
approve(spender: string, amount: string): Promise<boolean>
balanceOf(account: string): Promise<BigNumber>
burn(amount: string): Promise<void>
burnFrom(account: string, amount: string): Promise<void>
cap(): Promise<BigNumber>
decimals(): Promise<BigNumber>
decreaseAllowance(spender: string, subtractedValue: string): Promise<boolean>
getDecimals(): Promise<BigNumber>
increaseAllowance(spender: string, addedValue: string): Promise<boolean>
isMinter(account: string): Promise<boolean>
mint(account: string, amount: string): Promise<boolean>
name(): Promise<string>
renounceMinter(): Promise<void>
symbol(): Promise<string>
tokenName(): Promise<string>
tokenSymbol(): Promise<string>
totalSupply(): Promise<BigNumber>
transfer(recipient: string, amount: string): Promise<boolean>
transferFrom(sender: string, recipient: string, amount: string): Promise<boolean>
}
// @ts-ignore
export class TokenTrc20 extends BaseContract implements ContractInterface {
public static deployedBytecode: string | undefined;
public static contractName = "TokenTrc20";
__debug: boolean = true;
tronweb: TronWeb = null;
contract: Contract;
contract_address_t: string;
based_version: string = version;
constructor(tron: TronWeb) {
super();
this.tronweb = tron
}
public static Instance(): (TokenTrc20 | any | boolean) {
if (window && window.hasOwnProperty("_contractTrc20Token888")) {
// @ts-ignore
const obj = window._contractTrc20Token888
if (obj instanceof TokenTrc20) {
return (obj) as TokenTrc20
} else {
return (obj) as TokenTrc20
}
} else {
return false
}
}
async init(contract_address: string) {
this.contract = await new Contract(this.tronweb, TokenTrc20.ABI(), contract_address);
/**this.contract = await this.tronweb.contract().new({
abi:CONTRACT_ABI,
bytecode: TokenTrc20.deployedBytecode
});**/
this.contract_address_t = contract_address;
if (window && !window.hasOwnProperty("_contractTrc20Token888")) {
// @ts-ignore
window._contractTrc20Token888 = this
}
}
setDebug(bool: boolean) {
this.__debug = bool
}
public isVersionCompatible(): boolean {
return this.based_version === this.tronweb.version
}
// @ts-ignore
public async addMinter(account: string): Promise<void> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.addMinter(account)
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 addMinter");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async allowance(owner: string, spender: string): Promise<BigNumber> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.allowance(owner, spender)
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 allowance");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async approve(spender: string, amount: string): Promise<boolean> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.approve(spender, amount)
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 approve");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async balanceOf(account: string): Promise<BigNumber> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.balanceOf(account)
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 balanceOf");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async burn(amount: string): Promise<void> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.burn(amount)
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 burn");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async burnFrom(account: string, amount: string): Promise<void> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.burnFrom(account, amount)
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 burnFrom");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async cap(): Promise<BigNumber> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.cap()
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 cap");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async decimals(): Promise<BigNumber> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.decimals()
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 decimals");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async decreaseAllowance(spender: string, subtractedValue: string): Promise<boolean> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.decreaseAllowance(spender, subtractedValue)
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 decreaseAllowance");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async getDecimals(): Promise<BigNumber> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.getDecimals()
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 getDecimals");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async increaseAllowance(spender: string, addedValue: string): Promise<boolean> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.increaseAllowance(spender, addedValue)
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 increaseAllowance");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async isMinter(account: string): Promise<boolean> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.isMinter(account)
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 isMinter");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async mint(account: string, amount: string): Promise<boolean> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.mint(account, amount)
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 mint");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async name(): Promise<string> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.name()
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 name");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async renounceMinter(): Promise<void> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.renounceMinter()
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 renounceMinter");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async symbol(): Promise<string> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.symbol()
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 symbol");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async tokenName(): Promise<string> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.tokenName()
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 tokenName");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async tokenSymbol(): Promise<string> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.tokenSymbol()
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 tokenSymbol");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async totalSupply(): Promise<BigNumber> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: true,
callValue: 0,
}
let val = await this.contract.totalSupply()
.call(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 totalSupply");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async transfer(recipient: string, amount: string): Promise<boolean> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.transfer(recipient, amount)
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 transfer");
console.log(val);
console.groupEnd();
}
return val
}
// @ts-ignore
public async transferFrom(sender: string, recipient: string, amount: string): Promise<boolean> {
let callparams = {
userFeePercentage: 30,
feeLimit: 100000000,
shouldPollResponse: true,
_isConstant: false,
callValue: 0,
}
let val = await this.contract.transferFrom(sender, recipient, amount)
.send(callparams)
;
if (this.__debug) {
console.group("==> debug return raw 💮 transferFrom");
console.log(val);
console.groupEnd();
}
return val
}
async startEventListeners(): Promise<any> {
// @ts-ignore
await this.contract && this.contract.Approval().watch((err, _result) => {
if (err) return console.error('Failed to bind event listener:', err);
if (_result) {
let {result, block, transaction, name, contract} = _result;
if (this.__debug) {
console.group('New event received');
console.log('- Contract Address:', contract);
console.log('- Event Name:', name);
console.log('- Transaction:', transaction);
console.log('- Block number:', block);
console.log('- Result:', result, '\n');
console.groupEnd();
}
this.emit("event_Approval", result);
}
});
// @ts-ignore
await this.contract && this.contract.MinterAdded().watch((err, _result) => {
if (err) return console.error('Failed to bind event listener:', err);
if (_result) {
let {result, block, transaction, name, contract} = _result;
if (this.__debug) {
console.group('New event received');
console.log('- Contract Address:', contract);
console.log('- Event Name:', name);
console.log('- Transaction:', transaction);
console.log('- Block number:', block);
console.log('- Result:', result, '\n');
console.groupEnd();
}
this.emit("event_MinterAdded", result);
}
});
// @ts-ignore
await this.contract && this.contract.MinterRemoved().watch((err, _result) => {
if (err) return console.error('Failed to bind event listener:', err);
if (_result) {
let {result, block, transaction, name, contract} = _result;
if (this.__debug) {
console.group('New event received');
console.log('- Contract Address:', contract);
console.log('- Event Name:', name);
console.log('- Transaction:', transaction);
console.log('- Block number:', block);
console.log('- Result:', result, '\n');
console.groupEnd();
}
this.emit("event_MinterRemoved", result);
}
});
// @ts-ignore
await this.contract && this.contract.Transfer().watch((err, _result) => {
if (err) return console.error('Failed to bind event listener:', err);
if (_result) {
let {result, block, transaction, name, contract} = _result;
if (this.__debug) {
console.group('New event received');
console.log('- Contract Address:', contract);
console.log('- Event Name:', name);
console.log('- Transaction:', transaction);
console.log('- Block number:', block);
console.log('- Result:', result, '\n');
console.groupEnd();
}
this.emit("event_Transfer", result);
}
});
}
/**
* @returns The contract ABI
*/
public static ABI(): any {
const abi = [
{
inputs: [],
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'constructor',
},
{
anonymous: false,
inputs: [
{
name: 'owner',
type: 'address',
indexed: true,
},
{
name: 'spender',
type: 'address',
indexed: true,
},
{
name: 'value',
type: 'uint256',
indexed: false,
},
],
name: 'Approval',
outputs: [],
type: 'event',
},
{
anonymous: false,
inputs: [
{
name: 'account',
type: 'address',
indexed: true,
},
],
name: 'MinterAdded',
outputs: [],
type: 'event',
},
{
anonymous: false,
inputs: [
{
name: 'account',
type: 'address',
indexed: true,
},
],
name: 'MinterRemoved',
outputs: [],
type: 'event',
},
{
anonymous: false,
inputs: [
{
name: 'from',
type: 'address',
indexed: true,
},
{
name: 'to',
type: 'address',
indexed: true,
},
{
name: 'value',
type: 'uint256',
indexed: false,
},
],
name: 'Transfer',
outputs: [],
type: 'event',
},
{
constant: false,
inputs: [
{
name: 'account',
type: 'address',
},
],
name: 'addMinter',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: true,
inputs: [
{
name: 'owner',
type: 'address',
},
{
name: 'spender',
type: 'address',
},
],
name: 'allowance',
outputs: [
{
name: '',
type: 'uint256',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'spender',
type: 'address',
},
{
name: 'amount',
type: 'uint256',
},
],
name: 'approve',
outputs: [
{
name: '',
type: 'bool',
},
],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: true,
inputs: [
{
name: 'account',
type: 'address',
},
],
name: 'balanceOf',
outputs: [
{
name: '',
type: 'uint256',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'amount',
type: 'uint256',
},
],
name: 'burn',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'account',
type: 'address',
},
{
name: 'amount',
type: 'uint256',
},
],
name: 'burnFrom',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: true,
inputs: [],
name: 'cap',
outputs: [
{
name: '',
type: 'uint256',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: true,
inputs: [],
name: 'decimals',
outputs: [
{
name: '',
type: 'uint8',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'spender',
type: 'address',
},
{
name: 'subtractedValue',
type: 'uint256',
},
],
name: 'decreaseAllowance',
outputs: [
{
name: '',
type: 'bool',
},
],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: true,
inputs: [],
name: 'getDecimals',
outputs: [
{
name: '',
type: 'uint8',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'spender',
type: 'address',
},
{
name: 'addedValue',
type: 'uint256',
},
],
name: 'increaseAllowance',
outputs: [
{
name: '',
type: 'bool',
},
],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: true,
inputs: [
{
name: 'account',
type: 'address',
},
],
name: 'isMinter',
outputs: [
{
name: '',
type: 'bool',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'account',
type: 'address',
},
{
name: 'amount',
type: 'uint256',
},
],
name: 'mint',
outputs: [
{
name: '',
type: 'bool',
},
],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: true,
inputs: [],
name: 'name',
outputs: [
{
name: '',
type: 'string',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: false,
inputs: [],
name: 'renounceMinter',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: true,
inputs: [],
name: 'symbol',
outputs: [
{
name: '',
type: 'string',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: true,
inputs: [],
name: 'tokenName',
outputs: [
{
name: '',
type: 'string',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: true,
inputs: [],
name: 'tokenSymbol',
outputs: [
{
name: '',
type: 'string',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: true,
inputs: [],
name: 'totalSupply',
outputs: [
{
name: '',
type: 'uint256',
},
],
payable: false,
stateMutability: 'view',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'recipient',
type: 'address',
},
{
name: 'amount',
type: 'uint256',
},
],
name: 'transfer',
outputs: [
{
name: '',
type: 'bool',
},
],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'sender',
type: 'address',
},
{
name: 'recipient',
type: 'address',
},
{
name: 'amount',
type: 'uint256',
},
],
name: 'transferFrom',
outputs: [
{
name: '',
type: 'bool',
},
],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
];
return abi;
}
}