status-im
/
ethers.js
mirror of
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Updated dist files.

This commit is contained in:
Richard Moore 2018-08-02 20:43:09 -04:00
parent 5c8703fb30
commit bacf42a22f
No known key found for this signature in database
GPG Key ID: 525F70A6FCABC295
30 changed files with 2710 additions and 1829 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
_version.d.ts vendored
View File

@ -1 +1 @@
export declare const version = "4.0.0-beta.7";
export declare const version = "4.0.0-beta.8";

2
_version.js
View File

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

2032
dist/ethers.js vendored
View File

File diff suppressed because it is too large Load Diff

2
dist/ethers.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
dist/ethers.min.js.map vendored
View File

File diff suppressed because one or more lines are too long

1017
dist/ethers.types.txt vendored
View File

File diff suppressed because it is too large Load Diff

103
ethers.d.ts vendored
View File

@ -1,103 +1,12 @@
import { Contract, Interface } from './contracts';
import { Provider, getDefaultProvider, FallbackProvider, EtherscanProvider, InfuraProvider, JsonRpcProvider, Web3Provider, IpcProvider } from './providers';
import { JsonRpcSigner } from './providers/json-rpc-provider';
import * as providers from './providers';
import { HDNode, SigningKey, Wallet } from './wallet';
import * as utils from './utils';
import * as wordlists from './wordlists';
import { constants } from './utils/constants';
import * as errors from './utils/errors';
import * as utils from './utils';
import * as types from './types';
import * as wordlists from './wordlists';
import { platform } from './utils/shims';
import { version } from './_version';
import { Provider as _AbstractProvider } from './providers/abstract-provider';
import { Signer as _AbstractSigner } from './wallet/abstract-signer';
import { ContractFunction as _ContractFunction, Event as _Event, EventFilter as _EventFilter } from './contracts/contract';
import { Indexed as _Indexed, DeployDescription as _DeplyDescription, EventDescription as _EventDescription, FunctionDescription as _FunctionDescription, LogDescription as _LogDescription, TransactionDescription as _TransactionDescription } from './contracts/interface';
import { Block as _Block, BlockTag as _BlockTag, EventType as _EventType, Filter as _Filter, Log as _Log, Listener as _Listener, TransactionReceipt as _TransactionReceipt, TransactionRequest as _TransactionRequest, TransactionResponse as _TransactionResponse } from './providers/abstract-provider';
import { AsyncSendable as _AsyncSendable } from './providers/web3-provider';
import { CoerceFunc as _CoerceFunc, EventFragment as _EventFragment, FunctionFragment as _FunctionFragment, ParamType as _ParamType } from './utils/abi-coder';
import { BigNumberish as _BigNumberish } from './utils/bignumber';
import { Arrayish as _Arrayish, Hexable as _Hexable, Signature as _Signature } from './utils/bytes';
import { SupportedAlgorithms as _SupportedAlgorithms } from './utils/hmac';
import { Network as _Network, Networkish as _Networkish } from './utils/networks';
import { Transaction as _Transaction, UnsignedTransaction as _UnsignedTransaction } from './utils/transaction';
import { UnicodeNormalizationForm as _UnicodeNotmalizationForm } from './utils/utf8';
import { ConnectionInfo as _ConnectionInfo, OnceBlockable as _OnceBlockable, PollOptions as _PollOptions } from './utils/web';
import { EncryptOptions as _EncryptOptions, ProgressCallback as _ProgressCallback } from './wallet/secret-storage';
import { Wordlist as _Wordlist } from './wordlists/wordlist';
declare module types {
const AbstractSigner: typeof _AbstractSigner;
const AbstractProvider: typeof _AbstractProvider;
type SignerOrProvider = _AbstractSigner | _AbstractProvider;
type ContractFunction = _ContractFunction;
type EventFilter = _EventFilter;
interface Event extends _Event {
}
interface Indexed extends _Indexed {
}
interface DeployDescription extends _DeplyDescription {
}
interface EventDescription extends _EventDescription {
}
interface FunctionDescription extends _FunctionDescription {
}
interface LogDescription extends _LogDescription {
}
interface TransactionDescription extends _TransactionDescription {
}
type BlockTag = _BlockTag;
type EventType = _EventType;
type Filter = _Filter;
type Listener = _Listener;
type TransactionRequest = _TransactionRequest;
interface Block extends _Block {
}
interface Log extends _Log {
}
interface TransactionReceipt extends _TransactionReceipt {
}
interface TransactionResponse extends _TransactionResponse {
}
type AsyncSendable = _AsyncSendable;
type CoerceFunc = _CoerceFunc;
type EventFragment = _EventFragment;
type FunctionFragment = _FunctionFragment;
type ParamType = _ParamType;
type BigNumberish = _BigNumberish;
type Arrayish = _Arrayish;
type Hexable = _Hexable;
type Signature = _Signature;
const SupportedAlgorithms: typeof _SupportedAlgorithms;
type Network = _Network;
type Networkish = _Networkish;
type UnsignedTransaction = _UnsignedTransaction;
interface Transaction extends _Transaction {
}
const UnicodeNormalizationForm: typeof _UnicodeNotmalizationForm;
type ConnectionInfo = _ConnectionInfo;
interface OnceBlockable extends _OnceBlockable {
}
type PollOptions = _PollOptions;
type EncryptOptions = _EncryptOptions;
type ProgressCallback = _ProgressCallback;
const Wordlist: typeof _Wordlist;
}
declare const constants: {
AddressZero: string;
HashZero: string;
NegativeOne: utils.BigNumber;
Zero: utils.BigNumber;
One: utils.BigNumber;
Two: utils.BigNumber;
WeiPerEther: utils.BigNumber;
MaxUint256: utils.BigNumber;
};
declare const providers: {
Provider: typeof Provider;
FallbackProvider: typeof FallbackProvider;
EtherscanProvider: typeof EtherscanProvider;
InfuraProvider: typeof InfuraProvider;
IpcProvider: typeof IpcProvider;
JsonRpcProvider: typeof JsonRpcProvider;
Web3Provider: typeof Web3Provider;
JsonRpcSigner: typeof JsonRpcSigner;
};
declare function getDefaultProvider(network?: types.Network | string): providers.BaseProvider;
export { Wallet, HDNode, SigningKey, Contract, Interface, getDefaultProvider, providers, errors, constants, utils, types, wordlists, platform, version };

71
ethers.js
View File

@ -10,69 +10,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
var contracts_1 = require("./contracts");
exports.Contract = contracts_1.Contract;
exports.Interface = contracts_1.Interface;
var providers_1 = require("./providers");
exports.getDefaultProvider = providers_1.getDefaultProvider;
var json_rpc_provider_1 = require("./providers/json-rpc-provider");
var providers = __importStar(require("./providers"));
exports.providers = providers;
var wallet_1 = require("./wallet");
exports.HDNode = wallet_1.HDNode;
exports.SigningKey = wallet_1.SigningKey;
exports.Wallet = wallet_1.Wallet;
var utils = __importStar(require("./utils"));
exports.utils = utils;
var wordlists = __importStar(require("./wordlists"));
exports.wordlists = wordlists;
var constants_1 = require("./utils/constants");
exports.constants = constants_1.constants;
var errors = __importStar(require("./utils/errors"));
exports.errors = errors;
var utils = __importStar(require("./utils"));
exports.utils = utils;
var types = __importStar(require("./types"));
exports.types = types;
var wordlists = __importStar(require("./wordlists"));
exports.wordlists = wordlists;
// This is empty in node, and used by browserify to inject extra goodies
var shims_1 = require("./utils/shims");
exports.platform = shims_1.platform;
// This is generated by "npm run dist"
var _version_1 = require("./_version");
exports.version = _version_1.version;
///////////////////////////////
// Imported Abstracts
var abstract_provider_1 = require("./providers/abstract-provider");
var abstract_signer_1 = require("./wallet/abstract-signer");
var hmac_1 = require("./utils/hmac");
var utf8_1 = require("./utils/utf8");
var wordlist_1 = require("./wordlists/wordlist");
///////////////////////////////
// Exported Types
var types;
(function (types) {
types.AbstractSigner = abstract_signer_1.Signer;
types.AbstractProvider = abstract_provider_1.Provider;
;
;
;
;
;
;
;
;
;
;
// ./utils/hmac
types.SupportedAlgorithms = hmac_1.SupportedAlgorithms;
;
// ./utils/utf8
types.UnicodeNormalizationForm = utf8_1.UnicodeNormalizationForm;
;
// ./wordlists/wordlist
types.Wordlist = wordlist_1.Wordlist;
})(types || (types = {}));
exports.types = types;
///////////////////////////////
var constants = utils.constants;
exports.constants = constants;
var providers = {
Provider: providers_1.Provider,
FallbackProvider: providers_1.FallbackProvider,
EtherscanProvider: providers_1.EtherscanProvider,
InfuraProvider: providers_1.InfuraProvider,
IpcProvider: providers_1.IpcProvider,
JsonRpcProvider: providers_1.JsonRpcProvider,
Web3Provider: providers_1.Web3Provider,
JsonRpcSigner: json_rpc_provider_1.JsonRpcSigner
};
exports.providers = providers;
function getDefaultProvider(network) {
return new providers.FallbackProvider([
new providers.InfuraProvider(network),
new providers.EtherscanProvider(network),
]);
}
exports.getDefaultProvider = getDefaultProvider;

2
package.json
View File

@ -1,6 +1,6 @@
{
"name": "ethers",
"version": "4.0.0-beta.7",
"version": "4.0.0-beta.8",
"description": "Ethereum wallet library.",
"main": "./index.js",
"types": "./index.d.ts",

67
providers/base-provider.d.ts vendored Normal file
View File

@ -0,0 +1,67 @@
import { BigNumber } from '../utils/bignumber';
import { Provider } from './abstract-provider';
import { Block, BlockTag, EventType, Filter, Listener, Log, TransactionReceipt, TransactionRequest, TransactionResponse } from './abstract-provider';
import { BigNumberish } from '../utils/bignumber';
import { Transaction } from '../utils/transaction';
import { Network, Networkish } from '../utils/networks';
export declare class BaseProvider extends Provider {
private _network;
private _events;
protected _emitted: any;
private _pollingInterval;
private _poller;
private _lastBlockNumber;
private _balances;
/**
* ready
*
* A Promise<Network> that resolves only once the provider is ready.
*
* Sub-classes that call the super with a network without a chainId
* MUST set this. Standard named networks have a known chainId.
*
*/
protected ready: Promise<Network>;
constructor(network: Networkish | Promise<Network>);
private _doPoll;
resetEventsBlock(blockNumber: number): void;
readonly network: Network;
getNetwork(): Promise<Network>;
readonly blockNumber: number;
polling: boolean;
pollingInterval: number;
waitForTransaction(transactionHash: string, timeout?: number): Promise<TransactionReceipt>;
getBlockNumber(): Promise<number>;
getGasPrice(): Promise<BigNumber>;
getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
_wrapTransaction(tx: Transaction, hash?: string): TransactionResponse;
call(transaction: TransactionRequest): Promise<string>;
estimateGas(transaction: TransactionRequest): Promise<BigNumber>;
getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
getTransaction(transactionHash: string): Promise<TransactionResponse>;
getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt>;
getLogs(filter: Filter): Promise<Array<Log>>;
getEtherPrice(): Promise<number>;
private _resolveNames;
private _getResolver;
resolveName(name: string | Promise<string>): Promise<string>;
lookupAddress(address: string | Promise<string>): Promise<string>;
static checkTransactionResponse(transaction: any): TransactionResponse;
doPoll(): void;
perform(method: string, params: any): Promise<any>;
protected _startPending(): void;
protected _stopPending(): void;
private _addEventListener;
on(eventName: EventType, listener: Listener): Provider;
once(eventName: EventType, listener: Listener): Provider;
addEventListener(eventName: EventType, listener: Listener): Provider;
emit(eventName: EventType, ...args: Array<any>): boolean;
listenerCount(eventName?: EventType): number;
listeners(eventName: EventType): Array<Listener>;
removeAllListeners(eventName: EventType): Provider;
removeListener(eventName: EventType, listener: Listener): Provider;
}

1066
providers/base-provider.js Normal file
View File

File diff suppressed because it is too large Load Diff

4
providers/etherscan-provider.d.ts vendored
View File

@ -1,7 +1,7 @@
import { Provider } from './provider';
import { BaseProvider } from './base-provider';
import { BlockTag, TransactionResponse } from './abstract-provider';
import { Networkish } from '../utils/networks';
export declare class EtherscanProvider extends Provider {
export declare class EtherscanProvider extends BaseProvider {
readonly baseUrl: string;
readonly apiKey: string;
constructor(network?: Networkish, apiKey?: string);

6
providers/etherscan-provider.js
View File

@ -17,7 +17,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
var provider_1 = require("./provider");
var base_provider_1 = require("./base-provider");
var bytes_1 = require("../utils/bytes");
var properties_1 = require("../utils/properties");
var web_1 = require("../utils/web");
@ -288,7 +288,7 @@ var EtherscanProvider = /** @class */ (function (_super) {
if (tx.creates == null && tx.contractAddress != null) {
tx.creates = tx.contractAddress;
}
var item = provider_1.Provider.checkTransactionResponse(tx);
var item = base_provider_1.BaseProvider.checkTransactionResponse(tx);
if (tx.timeStamp) {
item.timestamp = parseInt(tx.timeStamp);
}
@ -299,5 +299,5 @@ var EtherscanProvider = /** @class */ (function (_super) {
});
};
return EtherscanProvider;
}(provider_1.Provider));
}(base_provider_1.BaseProvider));
exports.EtherscanProvider = EtherscanProvider;

8
providers/fallback-provider.d.ts vendored
View File

@ -1,7 +1,7 @@
import { Provider } from './provider';
export declare class FallbackProvider extends Provider {
import { BaseProvider } from './base-provider';
export declare class FallbackProvider extends BaseProvider {
private _providers;
constructor(providers: Array<Provider>);
readonly providers: Array<Provider>;
constructor(providers: Array<BaseProvider>);
readonly providers: Array<BaseProvider>;
perform(method: string, params: any): any;
}

4
providers/fallback-provider.js
View File

@ -17,7 +17,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
var provider_1 = require("./provider");
var base_provider_1 = require("./base-provider");
var errors = __importStar(require("../utils/errors"));
// Returns:
// - true is all networks match
@ -106,5 +106,5 @@ var FallbackProvider = /** @class */ (function (_super) {
});
};
return FallbackProvider;
}(provider_1.Provider));
}(base_provider_1.BaseProvider));
exports.FallbackProvider = FallbackProvider;

7
providers/index.d.ts vendored
View File

@ -1,11 +1,8 @@
import { Provider } from './provider';
import { BaseProvider } from './base-provider';
import { EtherscanProvider } from './etherscan-provider';
import { FallbackProvider } from './fallback-provider';
import { IpcProvider } from './ipc-provider';
import { InfuraProvider } from './infura-provider';
import { JsonRpcProvider, JsonRpcSigner } from './json-rpc-provider';
import { Web3Provider } from './web3-provider';
import { Provider as AbstractProvider } from './abstract-provider';
import { Network } from '../utils/networks';
declare function getDefaultProvider(network?: Network | string): Provider;
export { AbstractProvider, Provider, getDefaultProvider, FallbackProvider, EtherscanProvider, InfuraProvider, JsonRpcProvider, Web3Provider, IpcProvider, JsonRpcSigner };
export { BaseProvider, FallbackProvider, EtherscanProvider, InfuraProvider, JsonRpcProvider, Web3Provider, IpcProvider, JsonRpcSigner };

16
providers/index.js
View File

@ -1,7 +1,7 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
var provider_1 = require("./provider");
exports.Provider = provider_1.Provider;
var base_provider_1 = require("./base-provider");
exports.BaseProvider = base_provider_1.BaseProvider;
var etherscan_provider_1 = require("./etherscan-provider");
exports.EtherscanProvider = etherscan_provider_1.EtherscanProvider;
var fallback_provider_1 = require("./fallback-provider");
@ -15,15 +15,3 @@ exports.JsonRpcProvider = json_rpc_provider_1.JsonRpcProvider;
exports.JsonRpcSigner = json_rpc_provider_1.JsonRpcSigner;
var web3_provider_1 = require("./web3-provider");
exports.Web3Provider = web3_provider_1.Web3Provider;
///////////////////////////////
// Imported Abstracts
var abstract_provider_1 = require("./abstract-provider");
exports.AbstractProvider = abstract_provider_1.Provider;
///////////////////////////////
function getDefaultProvider(network) {
return new fallback_provider_1.FallbackProvider([
new infura_provider_1.InfuraProvider(network),
new etherscan_provider_1.EtherscanProvider(network),
]);
}
exports.getDefaultProvider = getDefaultProvider;

4
providers/json-rpc-provider.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Provider } from './provider';
import { BaseProvider } from './base-provider';
import { Signer } from '../wallet/abstract-signer';
import { BigNumber } from '../utils/bignumber';
import { Arrayish } from '../utils/bytes';
@ -17,7 +17,7 @@ export declare class JsonRpcSigner extends Signer {
signMessage(message: Arrayish | string): Promise<string>;
unlock(password: string): Promise<boolean>;
}
export declare class JsonRpcProvider extends Provider {
export declare class JsonRpcProvider extends BaseProvider {
readonly connection: ConnectionInfo;
private _pendingFilter;
constructor(url?: ConnectionInfo | string, network?: Networkish);

4
providers/json-rpc-provider.js
View File

@ -18,7 +18,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
};
Object.defineProperty(exports, "__esModule", { value: true });
// See: https://github.com/ethereum/wiki/wiki/JSON-RPC
var provider_1 = require("./provider");
var base_provider_1 = require("./base-provider");
var abstract_signer_1 = require("../wallet/abstract-signer");
var address_1 = require("../utils/address");
var bytes_1 = require("../utils/bytes");
@ -344,5 +344,5 @@ var JsonRpcProvider = /** @class */ (function (_super) {
return result;
};
return JsonRpcProvider;
}(provider_1.Provider));
}(base_provider_1.BaseProvider));
exports.JsonRpcProvider = JsonRpcProvider;

2
src.ts/_version.ts
View File

@ -1 +1 @@
export const version = "4.0.0-beta.7";
export const version = "4.0.0-beta.8";

33
types.d.ts vendored
View File

@ -1,16 +1,17 @@
export { ContractFunction, Event, EventFilter } from './contracts/contract';
export { Indexed, DeployDescription, EventDescription, FunctionDescription, LogDescription, TransactionDescription } from './contracts/interface';
export { Provider as AbstractProvider, Block, BlockTag, EventType, Filter, Log, Listener, TransactionReceipt, TransactionRequest, TransactionResponse, } from './providers/abstract-provider';
export { AsyncSendable } from './providers/web3-provider';
export { JsonRpcSigner } from './providers/json-rpc-provider';
export { CoerceFunc, EventFragment, FunctionFragment, ParamType } from './utils/abi-coder';
export { BigNumberish } from './utils/bignumber';
export { Arrayish, Hexable, Signature } from './utils/bytes';
export { SupportedAlgorithms } from './utils/hmac';
export { Network, Networkish } from './utils/networks';
export { Transaction, UnsignedTransaction } from './utils/transaction';
export { UnicodeNormalizationForm } from './utils/utf8';
export { ConnectionInfo, OnceBlockable, PollOptions } from './utils/web';
export { Signer as AbstractSigner } from './wallet/abstract-signer';
export { EncryptOptions, ProgressCallback } from './wallet/secret-storage';
export { Wordlist } from './wordlists/wordlist';
import { Provider } from './providers/abstract-provider';
import { Signer } from './wallet/abstract-signer';
import { ContractFunction, Event, EventFilter } from './contracts/contract';
import { Indexed, DeployDescription, EventDescription, FunctionDescription, LogDescription, TransactionDescription } from './contracts/interface';
import { Block, BlockTag, EventType, Filter, Log, Listener, TransactionReceipt, TransactionRequest, TransactionResponse } from './providers/abstract-provider';
import { AsyncSendable } from './providers/web3-provider';
import { CoerceFunc, EventFragment, FunctionFragment, ParamType } from './utils/abi-coder';
import { BigNumberish } from './utils/bignumber';
import { Arrayish, Hexable, Signature } from './utils/bytes';
import { SupportedAlgorithms } from './utils/hmac';
import { Network, Networkish } from './utils/networks';
import { Transaction, UnsignedTransaction } from './utils/transaction';
import { UnicodeNormalizationForm } from './utils/utf8';
import { ConnectionInfo, OnceBlockable, PollOptions } from './utils/web';
import { EncryptOptions, ProgressCallback } from './wallet/secret-storage';
import { Wordlist } from './wordlists/wordlist';
export { Provider, Signer, ContractFunction, EventFilter, Event, Indexed, DeployDescription, EventDescription, FunctionDescription, LogDescription, TransactionDescription, BlockTag, EventType, Filter, Listener, TransactionRequest, Block, Log, TransactionReceipt, TransactionResponse, AsyncSendable, CoerceFunc, EventFragment, FunctionFragment, ParamType, BigNumberish, Arrayish, Hexable, Signature, SupportedAlgorithms, Network, Networkish, UnsignedTransaction, Transaction, UnicodeNormalizationForm, ConnectionInfo, OnceBlockable, PollOptions, EncryptOptions, ProgressCallback, Wordlist };

13
types.js
View File

@ -1,12 +1,15 @@
"use strict";
///////////////////////////////
// Imported Abstracts
Object.defineProperty(exports, "__esModule", { value: true });
var abstract_provider_1 = require("./providers/abstract-provider");
exports.AbstractProvider = abstract_provider_1.Provider;
var json_rpc_provider_1 = require("./providers/json-rpc-provider");
exports.JsonRpcSigner = json_rpc_provider_1.JsonRpcSigner;
exports.Provider = abstract_provider_1.Provider;
var abstract_signer_1 = require("./wallet/abstract-signer");
exports.Signer = abstract_signer_1.Signer;
var hmac_1 = require("./utils/hmac");
exports.SupportedAlgorithms = hmac_1.SupportedAlgorithms;
var utf8_1 = require("./utils/utf8");
exports.UnicodeNormalizationForm = utf8_1.UnicodeNormalizationForm;
var abstract_signer_1 = require("./wallet/abstract-signer");
exports.AbstractSigner = abstract_signer_1.Signer;
var wordlist_1 = require("./wordlists/wordlist");
exports.Wordlist = wordlist_1.Wordlist;
///////////////////////////////

2
utils/bytes.d.ts vendored
View File

@ -13,8 +13,6 @@ export interface Signature {
recoveryParam?: number;
v?: number;
}
export declare const AddressZero = "0x0000000000000000000000000000000000000000";
export declare const HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
export declare function isHexable(value: any): value is Hexable;
export declare function isArrayish(value: any): value is Arrayish;
export declare function arrayify(value: Arrayish | Hexable): Uint8Array;

2
utils/bytes.js
View File

@ -13,8 +13,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
Object.defineProperty(exports, "__esModule", { value: true });
var errors = __importStar(require("./errors"));
///////////////////////////////
exports.AddressZero = '0x0000000000000000000000000000000000000000';
exports.HashZero = '0x0000000000000000000000000000000000000000000000000000000000000000';
function isHexable(value) {
return !!(value.toHexString);
}

11
utils/constants.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
export declare const constants: {
AddressZero: string;
HashZero: string;
EtherSymbol: string;
NegativeOne: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
Zero: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
One: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
Two: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
WeiPerEther: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
MaxUint256: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
};

20
utils/constants.js Normal file
View File

@ -0,0 +1,20 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var bignumber_1 = require("./bignumber");
var AddressZero = '0x0000000000000000000000000000000000000000';
var HashZero = '0x0000000000000000000000000000000000000000000000000000000000000000';
// NFKD (decomposed)
//const EtherSymbol = '\uD835\uDF63';
// NFKC (composed)
var EtherSymbol = '\u039e';
exports.constants = {
AddressZero: AddressZero,
HashZero: HashZero,
EtherSymbol: EtherSymbol,
NegativeOne: bignumber_1.ConstantNegativeOne,
Zero: bignumber_1.ConstantZero,
One: bignumber_1.ConstantOne,
Two: bignumber_1.ConstantTwo,
WeiPerEther: bignumber_1.ConstantWeiPerEther,
MaxUint256: bignumber_1.ConstantMaxUint256
};

14
utils/index.d.ts vendored
View File

@ -17,16 +17,4 @@ import { parse as parseTransaction, serialize as serializeTransaction } from './
import { toUtf8Bytes, toUtf8String } from './utf8';
import { formatEther, parseEther, formatUnits, parseUnits } from './units';
import { fetchJson } from './web';
import * as errors from './errors';
declare const etherSymbol = "\u039E";
declare const constants: {
AddressZero: string;
HashZero: string;
NegativeOne: BigNumber;
Zero: BigNumber;
One: BigNumber;
Two: BigNumber;
WeiPerEther: BigNumber;
MaxUint256: BigNumber;
};
export { AbiCoder, defaultAbiCoder, formatSignature, formatParamType, parseSignature, parseParamType, constants, RLP, fetchJson, getNetwork, defineReadOnly, defineFrozen, resolveProperties, shallowCopy, etherSymbol, arrayify, concat, padZeros, stripZeros, base64, BigNumber, bigNumberify, hexlify, hexStripZeros, hexZeroPad, hexDataLength, hexDataSlice, toUtf8Bytes, toUtf8String, hashMessage, namehash, id, getAddress, getIcapAddress, getContractAddress, formatEther, parseEther, formatUnits, parseUnits, keccak256, sha256, randomBytes, solidityPack, solidityKeccak256, soliditySha256, splitSignature, joinSignature, parseTransaction, serializeTransaction, getJsonWalletAddress, computePublicKey, verifyMessage, errors };
export { AbiCoder, defaultAbiCoder, formatSignature, formatParamType, parseSignature, parseParamType, RLP, fetchJson, getNetwork, defineReadOnly, defineFrozen, resolveProperties, shallowCopy, arrayify, concat, padZeros, stripZeros, base64, BigNumber, bigNumberify, hexlify, hexStripZeros, hexZeroPad, hexDataLength, hexDataSlice, toUtf8Bytes, toUtf8String, hashMessage, namehash, id, getAddress, getIcapAddress, getContractAddress, formatEther, parseEther, formatUnits, parseUnits, keccak256, sha256, randomBytes, solidityPack, solidityKeccak256, soliditySha256, splitSignature, joinSignature, parseTransaction, serializeTransaction, getJsonWalletAddress, computePublicKey, verifyMessage };

18
utils/index.js
View File

@ -76,21 +76,3 @@ exports.formatUnits = units_1.formatUnits;
exports.parseUnits = units_1.parseUnits;
var web_1 = require("./web");
exports.fetchJson = web_1.fetchJson;
var errors = __importStar(require("./errors"));
exports.errors = errors;
// NFKD (decomposed)
//const etherSymbol = '\uD835\uDF63';
// NFKC (composed)
var etherSymbol = '\u039e';
exports.etherSymbol = etherSymbol;
var constants = {
AddressZero: bytes_1.AddressZero,
HashZero: bytes_1.HashZero,
NegativeOne: bignumber_1.ConstantNegativeOne,
Zero: bignumber_1.ConstantZero,
One: bignumber_1.ConstantOne,
Two: bignumber_1.ConstantTwo,
WeiPerEther: bignumber_1.ConstantWeiPerEther,
MaxUint256: bignumber_1.ConstantMaxUint256
};
exports.constants = constants;

3
wallet/index.d.ts vendored
View File

@ -1,5 +1,4 @@
import { Wallet } from './wallet';
import * as HDNode from './hdnode';
import { SigningKey } from './signing-key';
import { Signer as AbstractSigner } from './abstract-signer';
export { AbstractSigner, HDNode, SigningKey, Wallet };
export { HDNode, SigningKey, Wallet };

2
wallet/index.js
View File

@ -13,5 +13,3 @@ var HDNode = __importStar(require("./hdnode"));
exports.HDNode = HDNode;
var signing_key_1 = require("./signing-key");
exports.SigningKey = signing_key_1.SigningKey;
var abstract_signer_1 = require("./abstract-signer");
exports.AbstractSigner = abstract_signer_1.Signer;