392 lines
15 KiB
TypeScript
392 lines
15 KiB
TypeScript
'use strict';
|
|
|
|
import { Interface } from './interface';
|
|
|
|
import { Provider, TransactionResponse } from '../providers/provider';
|
|
import { Signer } from '../wallet/wallet';
|
|
|
|
import { getContractAddress } from '../utils/address';
|
|
import { isHexString } from '../utils/convert';
|
|
import { ParamType } from '../utils/abi-coder';
|
|
import { BigNumber, ConstantZero } from '../utils/bignumber';
|
|
import { defineReadOnly, resolveProperties } from '../utils/properties';
|
|
|
|
import * as errors from '../utils/errors';
|
|
|
|
var allowedTransactionKeys = {
|
|
data: true, from: true, gasLimit: true, gasPrice:true, nonce: true, to: true, value: true
|
|
}
|
|
|
|
function copyObject(object) {
|
|
var result = {};
|
|
for (var key in object) {
|
|
result[key] = object[key];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// @TODO: Expand this to resolve any promises too
|
|
function resolveAddresses(provider, value, paramType): Promise<any> {
|
|
if (Array.isArray(paramType)) {
|
|
var promises = [];
|
|
paramType.forEach((paramType, index) => {
|
|
var v = null;
|
|
if (Array.isArray(value)) {
|
|
v = value[index];
|
|
} else {
|
|
v = value[paramType.name];
|
|
}
|
|
promises.push(resolveAddresses(provider, v, paramType));
|
|
});
|
|
return Promise.all(promises);
|
|
}
|
|
|
|
if (paramType.type === 'address') {
|
|
return provider.resolveName(value);
|
|
}
|
|
|
|
if (paramType.components) {
|
|
return resolveAddresses(provider, value, paramType.components);
|
|
}
|
|
|
|
return Promise.resolve(value);
|
|
}
|
|
|
|
type RunFunction = (...params: Array<any>) => Promise<any>;
|
|
|
|
function runMethod(contract: Contract, functionName: string, estimateOnly: boolean): RunFunction {
|
|
let method = contract.interface.functions[functionName];
|
|
return function(...params): Promise<any> {
|
|
var transaction: any = {}
|
|
|
|
// If 1 extra parameter was passed in, it contains overrides
|
|
if (params.length === method.inputs.length + 1 && typeof(params[params.length - 1]) === 'object') {
|
|
transaction = copyObject(params.pop());
|
|
|
|
// Check for unexpected keys (e.g. using "gas" instead of "gasLimit")
|
|
for (var key in transaction) {
|
|
if (!allowedTransactionKeys[key]) {
|
|
throw new Error('unknown transaction override ' + key);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (params.length != method.inputs.length) {
|
|
throw new Error('incorrect number of arguments');
|
|
}
|
|
|
|
// Check overrides make sense
|
|
['data', 'to'].forEach(function(key) {
|
|
if (transaction[key] != null) {
|
|
throw new Error('cannot override ' + key) ;
|
|
}
|
|
});
|
|
|
|
// Send to the contract address
|
|
transaction.to = contract.addressPromise;
|
|
|
|
return resolveAddresses(contract.provider, params, method.inputs).then((params) => {
|
|
transaction.data = method.encode(params);
|
|
if (method.type === 'call') {
|
|
|
|
// Call (constant functions) always cost 0 ether
|
|
if (estimateOnly) {
|
|
return Promise.resolve(ConstantZero);
|
|
}
|
|
|
|
// Check overrides make sense
|
|
['gasLimit', 'gasPrice', 'value'].forEach(function(key) {
|
|
if (transaction[key] != null) {
|
|
throw new Error('call cannot override ' + key) ;
|
|
}
|
|
});
|
|
|
|
if (transaction.from == null && contract.signer) {
|
|
if (contract.signer.address) {
|
|
transaction.from = contract.signer.address;
|
|
} else if (contract.signer.getAddress) {
|
|
transaction.from = contract.signer.getAddress();
|
|
}
|
|
}
|
|
|
|
return resolveProperties(transaction).then((transaction) => {
|
|
return contract.provider.call(transaction).then((value) => {
|
|
try {
|
|
let result = method.decode(value);
|
|
if (method.outputs.length === 1) {
|
|
result = result[0];
|
|
}
|
|
return result;
|
|
|
|
} catch (error) {
|
|
if (value === '0x' && method.outputs.length > 0) {
|
|
errors.throwError('call exception', errors.CALL_EXCEPTION, {
|
|
address: contract.address,
|
|
method: method.signature,
|
|
value: params
|
|
});
|
|
}
|
|
throw error;
|
|
}
|
|
});
|
|
});
|
|
|
|
} else if (method.type === 'transaction') {
|
|
if (!contract.signer) { return Promise.reject(new Error('missing signer')); }
|
|
|
|
// Make sure they aren't overriding something they shouldn't
|
|
if (transaction.from != null) {
|
|
throw new Error('transaction cannot override from') ;
|
|
}
|
|
|
|
// Only computing the transaction estimate
|
|
if (estimateOnly) {
|
|
if (contract.signer.estimateGas) {
|
|
return contract.signer.estimateGas(transaction);
|
|
}
|
|
|
|
if (contract.signer.address) {
|
|
transaction.from = contract.signer.address;
|
|
} else if (contract.signer.getAddress) {
|
|
transaction.from = contract.signer.getAddress();
|
|
}
|
|
|
|
return resolveProperties(transaction).then((transaction) => {
|
|
return contract.provider.estimateGas(transaction);
|
|
});
|
|
}
|
|
|
|
// If the signer supports sendTrasaction, use it
|
|
if (contract.signer.sendTransaction) {
|
|
return contract.signer.sendTransaction(transaction);
|
|
}
|
|
|
|
if (!contract.signer.sign) {
|
|
return Promise.reject(new Error('custom signer does not support signing'));
|
|
}
|
|
|
|
if (transaction.chainId == null) {
|
|
transaction.chainId = contract.provider.getNetwork().then((network) => {
|
|
return network.chainId;
|
|
});
|
|
}
|
|
|
|
if (transaction.gasLimit == null) {
|
|
if (contract.signer.estimateGas) {
|
|
transaction.gasLimit = contract.signer.estimateGas(transaction);
|
|
} else {
|
|
transaction.gasLimit = contract.provider.estimateGas(transaction);
|
|
}
|
|
}
|
|
|
|
if (!transaction.nonce) {
|
|
if (contract.signer.getTransactionCount) {
|
|
transaction.nonce = contract.signer.getTransactionCount();
|
|
} else if (contract.signer.address) {
|
|
transaction.nonce = contract.provider.getTransactionCount(contract.signer.address);
|
|
} else if (contract.signer.getAddress) {
|
|
transaction.nonce = contract.provider.getTransactionCount(contract.signer.getAddress());
|
|
} else {
|
|
throw new Error('cannot determine nonce');
|
|
}
|
|
}
|
|
|
|
if (!transaction.gasPrice) {
|
|
if (contract.signer.getGasPrice) {
|
|
transaction.gasPrice = contract.signer.getGasPrice(transaction);
|
|
} else {
|
|
transaction.gasPrice = contract.provider.getGasPrice();
|
|
}
|
|
}
|
|
|
|
return resolveProperties(transaction).then((transaction) => {
|
|
let signedTransaction = contract.signer.sign(transaction);
|
|
return contract.provider.sendTransaction(signedTransaction);
|
|
});
|
|
}
|
|
|
|
throw new Error('invalid type - ' + method.type);
|
|
return null;
|
|
});
|
|
|
|
throw new Error('unsupport type - ' + method.type);
|
|
}
|
|
}
|
|
|
|
function isSigner(value: any): value is Signer {
|
|
return (value && value.provider != null);
|
|
}
|
|
|
|
export type ContractEstimate = (...params: Array<any>) => Promise<BigNumber>;
|
|
export type ContractFunction = (...params: Array<any>) => Promise<any>;
|
|
export type ContractEvent = (...params: Array<any>) => void;
|
|
|
|
interface Bucket<T> {
|
|
[name: string]: T;
|
|
}
|
|
|
|
export type Contractish = Array<string | ParamType> | Interface | string;
|
|
export class Contract {
|
|
readonly address: string;
|
|
readonly interface: Interface;
|
|
readonly signer: Signer;
|
|
readonly provider: Provider;
|
|
|
|
readonly estimate: Bucket<ContractEstimate>;
|
|
readonly functions: Bucket<ContractFunction>;
|
|
readonly events: Bucket<ContractEvent>;
|
|
|
|
readonly addressPromise: Promise<string>;
|
|
|
|
// This is only set if the contract was created with a call to deploy
|
|
readonly deployTransaction: TransactionResponse;
|
|
|
|
// https://github.com/Microsoft/TypeScript/issues/5453
|
|
// Once this issue is resolved (there are open PR) we can do this nicer. :)
|
|
|
|
constructor(addressOrName: string, contractInterface: Contractish, signerOrProvider: Signer | Provider) {
|
|
errors.checkNew(this, Contract);
|
|
|
|
// @TODO: Maybe still check the addressOrName looks like a valid address or name?
|
|
//address = getAddress(address);
|
|
if (contractInterface instanceof Interface) {
|
|
defineReadOnly(this, 'interface', contractInterface);
|
|
} else {
|
|
defineReadOnly(this, 'interface', new Interface(contractInterface));
|
|
}
|
|
|
|
if (!signerOrProvider) { throw new Error('missing signer or provider'); }
|
|
|
|
if (isSigner(signerOrProvider)) {
|
|
defineReadOnly(this, 'provider', signerOrProvider.provider);
|
|
defineReadOnly(this, 'signer', signerOrProvider);
|
|
} else {
|
|
defineReadOnly(this, 'provider', signerOrProvider);
|
|
defineReadOnly(this, 'signer', null);
|
|
}
|
|
|
|
|
|
defineReadOnly(this, 'estimate', { });
|
|
defineReadOnly(this, 'events', { });
|
|
defineReadOnly(this, 'functions', { });
|
|
|
|
// Not connected to an on-chain instance, so do not connect functions and events
|
|
if (!addressOrName) {
|
|
defineReadOnly(this, 'address', null);
|
|
defineReadOnly(this, 'addressPromise', Promise.resolve(null));
|
|
return;
|
|
}
|
|
|
|
defineReadOnly(this, 'address', addressOrName || null);
|
|
defineReadOnly(this, 'addressPromise', this.provider.resolveName(addressOrName || null));
|
|
|
|
Object.keys(this.interface.functions).forEach((name) => {
|
|
var run = runMethod(this, name, false);
|
|
|
|
if (this[name] == null) {
|
|
defineReadOnly(this, name, run);
|
|
} else {
|
|
console.log('WARNING: Multiple definitions for ' + name);
|
|
}
|
|
|
|
if (this.functions[name] == null) {
|
|
defineReadOnly(this.functions, name, run);
|
|
defineReadOnly(this.estimate, name, runMethod(this, name, true));
|
|
}
|
|
});
|
|
|
|
Object.keys(this.interface.events).forEach((eventName) => {
|
|
let eventInfo = this.interface.events[eventName];
|
|
|
|
let eventCallback = null;
|
|
|
|
let contract = this;
|
|
function handleEvent(log) {
|
|
contract.addressPromise.then((address) => {
|
|
// Not meant for us (the topics just has the same name)
|
|
if (address != log.address) { return; }
|
|
|
|
try {
|
|
let result = eventInfo.decode(log.data, log.topics);
|
|
|
|
// Some useful things to have with the log
|
|
log.args = result;
|
|
log.event = eventName;
|
|
log.parse = eventInfo.parse;
|
|
log.removeListener = function() {
|
|
contract.provider.removeListener(eventInfo.topics, handleEvent);
|
|
}
|
|
|
|
log.getBlock = function() { return contract.provider.getBlock(log.blockHash);; }
|
|
log.getTransaction = function() { return contract.provider.getTransaction(log.transactionHash); }
|
|
log.getTransactionReceipt = function() { return contract.provider.getTransactionReceipt(log.transactionHash); }
|
|
log.eventSignature = eventInfo.signature;
|
|
|
|
eventCallback.apply(log, Array.prototype.slice.call(result));
|
|
} catch (error) {
|
|
console.log(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
var property = {
|
|
enumerable: true,
|
|
get: function() {
|
|
return eventCallback;
|
|
},
|
|
set: function(value) {
|
|
if (!value) { value = null; }
|
|
|
|
if (!value && eventCallback) {
|
|
contract.provider.removeListener(eventInfo.topics, handleEvent);
|
|
|
|
} else if (value && !eventCallback) {
|
|
contract.provider.on(eventInfo.topics, handleEvent);
|
|
}
|
|
|
|
eventCallback = value;
|
|
}
|
|
};
|
|
|
|
var propertyName = 'on' + eventName.toLowerCase();
|
|
if (this[propertyName] == null) {
|
|
Object.defineProperty(this, propertyName, property);
|
|
}
|
|
|
|
Object.defineProperty(this.events, eventName, property);
|
|
|
|
}, this);
|
|
}
|
|
|
|
// Reconnect to a different signer or provider
|
|
connect(signerOrProvider: Signer | Provider): Contract {
|
|
return new Contract(this.address, this.interface, signerOrProvider);
|
|
}
|
|
|
|
// Deploy the contract with the bytecode, resolving to the deployed address.
|
|
// Use contract.deployTransaction.wait() to wait until the contract has
|
|
// been mined.
|
|
deploy(bytecode: string, ...args: Array<any>): Promise<Contract> {
|
|
if (this.signer == null) {
|
|
throw new Error('missing signer'); // @TODO: errors.throwError
|
|
}
|
|
|
|
if (!isHexString(bytecode)) {
|
|
errors.throwError('bytecode must be a valid hex string', errors.INVALID_ARGUMENT, { arg: 'bytecode', value: bytecode });
|
|
}
|
|
|
|
if ((bytecode.length % 2) !== 0) {
|
|
errors.throwError('bytecode must be valid data (even length)', errors.INVALID_ARGUMENT, { arg: 'bytecode', value: bytecode });
|
|
}
|
|
|
|
// @TODO: overrides of args.length = this.interface.deployFunction.inputs.length + 1
|
|
return this.signer.sendTransaction({
|
|
data: this.interface.deployFunction.encode(bytecode, args)
|
|
}).then((tx) => {
|
|
let contract = new Contract(getContractAddress(tx), this.interface, this.provider);
|
|
defineReadOnly(contract, 'deployTransaction', tx);
|
|
return contract;
|
|
});
|
|
}
|
|
}
|