Updated dist files.

_version.d.ts

@@ -1 +1 @@
-export declare const version = "4.0.0-beta.14";
+export declare const version = "4.0.0-beta.15";

_version.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.version = "4.0.0-beta.14";
+exports.version = "4.0.0-beta.15";

wallet/abstract-signer.d.ts → abstract-signer.d.ts

@@ -1,6 +1,6 @@
-import { Provider } from '../providers/abstract-provider';
-import { Arrayish } from '../utils/bytes';
-import { TransactionRequest, TransactionResponse } from '../providers/abstract-provider';
+import { Provider } from './providers/abstract-provider';
+import { Arrayish } from './utils/bytes';
+import { TransactionRequest, TransactionResponse } from './providers/abstract-provider';
 export declare abstract class Signer {
     readonly provider?: Provider;
     abstract getAddress(): Promise<string>;

wallet/abstract-signer.js → abstract-signer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var properties_1 = require("../utils/properties");
+var properties_1 = require("./utils/properties");
 var Signer = /** @class */ (function () {
     function Signer() {
         properties_1.setType(this, 'Signer');

constants.d.ts

@@ -0,0 +1,11 @@
+import { BigNumber } from './utils/bignumber';
+declare const AddressZero = "0x0000000000000000000000000000000000000000";
+declare const HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
+declare const EtherSymbol = "\u039E";
+declare const NegativeOne: BigNumber;
+declare const Zero: BigNumber;
+declare const One: BigNumber;
+declare const Two: BigNumber;
+declare const WeiPerEther: BigNumber;
+declare const MaxUint256: BigNumber;
+export { AddressZero, HashZero, EtherSymbol, NegativeOne, Zero, One, Two, WeiPerEther, MaxUint256 };

constants.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var bignumber_1 = require("./utils/bignumber");
+var AddressZero = '0x0000000000000000000000000000000000000000';
+exports.AddressZero = AddressZero;
+var HashZero = '0x0000000000000000000000000000000000000000000000000000000000000000';
+exports.HashZero = HashZero;
+// NFKD (decomposed)
+//const EtherSymbol = '\uD835\uDF63';
+// NFKC (composed)
+var EtherSymbol = '\u039e';
+exports.EtherSymbol = EtherSymbol;
+var NegativeOne = bignumber_1.bigNumberify(-1);
+exports.NegativeOne = NegativeOne;
+var Zero = bignumber_1.bigNumberify(0);
+exports.Zero = Zero;
+var One = bignumber_1.bigNumberify(1);
+exports.One = One;
+var Two = bignumber_1.bigNumberify(2);
+exports.Two = Two;
+var WeiPerEther = bignumber_1.bigNumberify('1000000000000000000');
+exports.WeiPerEther = WeiPerEther;
+var MaxUint256 = bignumber_1.bigNumberify('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
+exports.MaxUint256 = MaxUint256;

contract.d.ts

@@ -0,0 +1,66 @@
+import { BigNumber } from './utils/bignumber';
+import { Indexed, Interface } from './utils/interface';
+import { Provider } from './providers/abstract-provider';
+import { Signer } from './abstract-signer';
+import { Arrayish } from './utils/bytes';
+import { ParamType } from './utils/abi-coder';
+import { Block, Listener, Log, TransactionReceipt, TransactionRequest, TransactionResponse } from './providers/abstract-provider';
+export declare type ContractFunction = (...params: Array<any>) => Promise<any>;
+export declare type EventFilter = {
+    address?: string;
+    topics?: Array<string>;
+};
+export interface Event extends Log {
+    args: Array<any>;
+    decode: (data: string, topics?: Array<string>) => any;
+    event: string;
+    eventSignature: string;
+    removeListener: () => void;
+    getBlock: () => Promise<Block>;
+    getTransaction: () => Promise<TransactionResponse>;
+    getTransactionReceipt: () => Promise<TransactionReceipt>;
+}
+export declare class VoidSigner extends Signer {
+    readonly address: string;
+    constructor(address: string, provider: Provider);
+    getAddress(): Promise<string>;
+    _fail(message: string, operation: string): Promise<any>;
+    signMessage(message: Arrayish | string): Promise<string>;
+    sendTransaction(transaction: TransactionRequest): Promise<TransactionResponse>;
+    connect(provider: Provider): VoidSigner;
+}
+interface Bucket<T> {
+    [name: string]: T;
+}
+export declare class Contract {
+    readonly address: string;
+    readonly interface: Interface;
+    readonly signer: Signer;
+    readonly provider: Provider;
+    readonly estimate: Bucket<(...params: Array<any>) => Promise<BigNumber>>;
+    readonly functions: Bucket<ContractFunction>;
+    readonly filters: Bucket<(...params: Array<any>) => EventFilter>;
+    readonly [name: string]: ContractFunction | any;
+    readonly addressPromise: Promise<string>;
+    readonly deployTransaction: TransactionResponse;
+    private _deployed;
+    constructor(addressOrName: string, contractInterface: Array<string | ParamType> | string | Interface, signerOrProvider: Signer | Provider);
+    deployed(): Promise<Contract>;
+    fallback(overrides?: TransactionRequest): Promise<TransactionResponse>;
+    connect(signerOrProvider: Signer | Provider | string): Contract;
+    attach(addressOrName: string): Contract;
+    deploy(bytecode: string, ...args: Array<any>): Promise<Contract>;
+    static isIndexed(value: any): value is Indexed;
+    private _events;
+    private _getEventFilter;
+    private _addEventListener;
+    on(event: EventFilter | string, listener: Listener): Contract;
+    once(event: EventFilter | string, listener: Listener): Contract;
+    addListener(eventName: EventFilter | string, listener: Listener): Contract;
+    emit(eventName: EventFilter | string, ...args: Array<any>): boolean;
+    listenerCount(eventName?: EventFilter | string): number;
+    listeners(eventName: EventFilter | string): Array<Listener>;
+    removeAllListeners(eventName: EventFilter | string): Contract;
+    removeListener(eventName: any, listener: Listener): Contract;
+}
+export {};