@neo-one/client-core-esnext-esm
Version:
NEO•ONE client core types implementation.
593 lines (591 loc) • 22.1 kB
JavaScript
import { addressToScriptHash, assertAttributeUsageJSON, common, privateKeyToPublicKey, scriptHashToAddress, wifToPrivateKey, } from '@neo-one/client-common-esnext-esm';
import { utils } from '@neo-one/utils-esnext-esm';
import BigNumber from 'bignumber.js';
import _ from 'lodash';
import { InvalidArgumentError } from './errors';
export const assertString = (name, param) => {
if (param == undefined || typeof param !== 'string') {
throw new InvalidArgumentError('string', name, param);
}
return param;
};
export const assertBoolean = (name, value) => {
if (value == undefined || typeof value !== 'boolean') {
throw new InvalidArgumentError('boolean', name, value);
}
return value;
};
export const assertNullableBoolean = (name, value) => {
if (value == undefined) {
return undefined;
}
return assertBoolean(name, value);
};
export const assertNumber = (name, value) => {
if (value == undefined || typeof value !== 'number') {
throw new InvalidArgumentError('number', name, value);
}
return value;
};
export const assertNullableNumber = (name, value) => {
if (value == undefined) {
return undefined;
}
if (typeof value !== 'number') {
throw new InvalidArgumentError('number', name, value);
}
return value;
};
export const assertAddress = (name, addressIn) => {
const address = assertString(name, addressIn);
try {
addressToScriptHash(address);
return address;
}
catch {
try {
return scriptHashToAddress(address);
}
catch {
throw new InvalidArgumentError('Address', name, address);
}
}
};
export const assertHash256 = (name, hash) => {
const value = assertString(name, hash);
try {
return common.uInt256ToString(common.stringToUInt256(value));
}
catch {
throw new InvalidArgumentError('Hash256', name, value);
}
};
export const assertBuffer = (name, buffer) => {
const value = assertString(name, buffer);
if (Buffer.from(value, 'hex').toString('hex') !== value.toLowerCase()) {
throw new InvalidArgumentError('Buffer', name, value);
}
return value;
};
export const assertPublicKey = (name, publicKey) => {
const value = assertBuffer(name, publicKey);
try {
return common.ecPointToString(common.stringToECPoint(value));
}
catch {
throw new InvalidArgumentError('PublicKey', name, value);
}
};
export const assertBigNumber = (name, value) => {
if (value == undefined || !BigNumber.isBigNumber(value)) {
throw new InvalidArgumentError('BigNumber', name, value);
}
return value;
};
export const assertNullableBigNumber = (name, value) => {
if (value == undefined) {
return undefined;
}
return assertBigNumber(name, value);
};
export const assertArray = (name, value) => {
if (!Array.isArray(value)) {
throw new InvalidArgumentError('Array', name, value);
}
return value;
};
export const assertNullableArray = (name, value) => {
if (value == undefined) {
return [];
}
return assertArray(name, value);
};
export const assertMap = (name, value) => {
if (!(value instanceof Map)) {
throw new InvalidArgumentError('Map', name, value);
}
return value;
};
export const assertObject = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('Object', name, value);
}
return value;
};
export const assertNullableMap = (name, value) => {
if (value == undefined) {
return new Map();
}
return assertMap(name, value);
};
export const isObject = (value) => value != undefined && typeof value === 'object';
export const assertProperty = (value, objectName, name, assertType) => {
const valueAny = value;
return assertType(`${objectName}.${name}`, valueAny[name]);
};
export const assertUserAccountID = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('UserAccountID', name, value);
}
return {
network: assertProperty(value, 'UserAccountID', 'network', assertString),
address: assertProperty(value, 'UserAccountID', 'address', assertAddress),
};
};
export const assertNullableUserAccountID = (name, value) => {
if (value == undefined) {
return undefined;
}
return assertUserAccountID(name, value);
};
export const assertUpdateAccountNameOptions = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('UpdateAccountNameOptions', name, value);
}
return {
id: assertProperty(value, 'UpdateAccountNameOptions', 'id', assertUserAccountID),
name: assertProperty(value, 'UpdateAccountNameOptions', 'name', assertString),
};
};
const ABI_TYPES = new Set([
'Signature',
'Boolean',
'Address',
'Hash256',
'Buffer',
'PublicKey',
'String',
'Array',
'Map',
'Object',
'Void',
'Integer',
'ForwardValue',
]);
const assertABIType = (name, valueIn) => {
const value = assertString(name, valueIn);
if (!ABI_TYPES.has(value)) {
throw new InvalidArgumentError('ABIType', name, value);
}
return value;
};
const assertABIProperties = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('ABIReturn', name, value);
}
return _.fromPairs(Object.entries(value).map(([k, v]) => [assertString(name, k), assertABIReturn(name, v)]));
};
const assertABIReturn = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('ABIReturn', name, value);
}
const type = assertProperty(value, 'ABIReturn', 'type', assertABIType);
const optional = assertProperty(value, 'ABIReturn', 'optional', assertNullableBoolean);
const forwardedValue = assertProperty(value, 'ABIReturn', 'forwardedValue', assertNullableBoolean);
switch (type) {
case 'Signature':
return { type, optional, forwardedValue };
case 'Boolean':
return { type, optional, forwardedValue };
case 'Address':
return { type, optional, forwardedValue };
case 'Hash256':
return { type, optional, forwardedValue };
case 'Buffer':
return { type, optional, forwardedValue };
case 'PublicKey':
return { type, optional, forwardedValue };
case 'String':
return { type, optional, forwardedValue };
case 'Array':
return { type, value: assertProperty(value, 'ABIReturn', 'value', assertABIReturn), optional, forwardedValue };
case 'Map':
return {
type,
key: assertProperty(value, 'ABIReturn', 'key', assertABIReturn),
value: assertProperty(value, 'ABIReturn', 'value', assertABIReturn),
optional,
forwardedValue,
};
case 'Object':
return {
type,
properties: assertProperty(value, 'ABIReturn', 'properties', assertABIProperties),
optional,
forwardedValue,
};
case 'Void':
return { type, optional, forwardedValue };
case 'Integer':
return { type, decimals: assertProperty(value, 'ABIReturn', 'decimals', assertNumber), optional, forwardedValue };
case 'ForwardValue':
return { type, optional, forwardedValue };
default:
utils.assertNever(type);
throw new Error('For TS');
}
};
const assertABIDefaultType = (name, valueIn) => {
const value = assertString(name, valueIn);
switch (value) {
case 'sender':
return 'sender';
default:
throw new InvalidArgumentError('ABIDefaultType', name, value);
}
};
const assertNullableABIDefault = (name, value) => {
if (value == undefined) {
return undefined;
}
if (!isObject(value)) {
throw new InvalidArgumentError('ABIDefault', name, value);
}
const type = assertProperty(value, 'ABIDefault', 'type', assertABIDefaultType);
switch (type) {
case 'sender':
return { type: 'sender' };
default:
throw new InvalidArgumentError('ABIDefaultType', name, value);
}
};
const assertABIParameter = (propName, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('ABIParameter', propName, value);
}
const type = assertProperty(value, 'ABIParameter', 'type', assertABIType);
const name = assertProperty(value, 'ABIParameter', 'name', assertString);
const optional = assertProperty(value, 'ABIParameter', 'optional', assertNullableBoolean);
const rest = assertProperty(value, 'ABIParameter', 'rest', assertNullableBoolean);
const defaultValue = assertProperty(value, 'ABIParameter', 'default', assertNullableABIDefault);
const forwardedValue = assertProperty(value, 'ABIParameter', 'forwardedValue', assertNullableBoolean);
switch (type) {
case 'Signature':
return { type, name, optional, default: defaultValue, forwardedValue, rest };
case 'Boolean':
return { type, name, optional, default: defaultValue, forwardedValue, rest };
case 'Address':
return { type, name, optional, default: defaultValue, forwardedValue, rest };
case 'Hash256':
return { type, name, optional, default: defaultValue, forwardedValue, rest };
case 'Buffer':
return { type, name, optional, default: defaultValue, forwardedValue, rest };
case 'PublicKey':
return { type, name, optional, default: defaultValue, forwardedValue, rest };
case 'String':
return { type, name, optional, default: defaultValue, forwardedValue, rest };
case 'Array':
return {
type,
name,
optional,
default: defaultValue,
value: assertProperty(value, 'ABIParameter', 'value', assertABIReturn),
forwardedValue,
rest,
};
case 'Map':
return {
type,
name,
optional,
default: defaultValue,
key: assertProperty(value, 'ABIParameter', 'key', assertABIReturn),
value: assertProperty(value, 'ABIParameter', 'value', assertABIReturn),
forwardedValue,
rest,
};
case 'Object':
return {
type,
name,
optional,
default: defaultValue,
properties: assertProperty(value, 'ABIParameter', 'properties', assertABIProperties),
forwardedValue,
rest,
};
case 'Void':
return { type, name, optional, default: defaultValue, forwardedValue, rest };
case 'Integer':
return {
type,
name,
optional,
default: defaultValue,
decimals: assertProperty(value, 'ABIParameter', 'decimals', assertNumber),
forwardedValue,
};
case 'ForwardValue':
return { type, name, optional, default: defaultValue, forwardedValue, rest };
default:
utils.assertNever(type);
throw new Error('For TS');
}
};
const assertABIFunction = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('ABIFunction', name, value);
}
return {
name: assertProperty(value, 'ABIFunction', 'name', assertString),
parameters: assertProperty(value, 'ABIFunction', 'parameters', assertNullableArray).map((parameter) => assertABIParameter('ABIFunction.parameters', parameter)),
returnType: assertProperty(value, 'ABIFunction', 'returnType', assertABIReturn),
constant: assertProperty(value, 'ABIFunction', 'constant', assertNullableBoolean),
send: assertProperty(value, 'ABIFunction', 'send', assertNullableBoolean),
sendUnsafe: assertProperty(value, 'ABIFunction', 'sendUnsafe', assertNullableBoolean),
receive: assertProperty(value, 'ABIFunction', 'receive', assertNullableBoolean),
claim: assertProperty(value, 'ABIFunction', 'claim', assertNullableBoolean),
refundAssets: assertProperty(value, 'ABIFunction', 'refundAssets', assertNullableBoolean),
completeSend: assertProperty(value, 'ABIFunction', 'completeSend', assertNullableBoolean),
};
};
const assertABIEvent = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('ABIEvent', name, value);
}
return {
name: assertProperty(value, 'ABIEvent', 'name', assertString),
parameters: assertProperty(value, 'ABIEvent', 'parameters', assertNullableArray).map((parameter) => assertABIParameter('ABIEvent.parameters', parameter)),
};
};
export const assertABI = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('ABI', name, value);
}
return {
functions: assertProperty(value, 'ABI', 'functions', assertNullableArray).map((func) => assertABIFunction('ABI.functions', func)),
events: assertProperty(value, 'ABI', 'events', assertNullableArray).map((func) => assertABIEvent('ABI.events', func)),
};
};
const assertSmartContractNetworkDefinition = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('SmartContractNetworkDefinition', name, value);
}
return {
address: assertProperty(value, 'SmartContractNetworkDefinition', 'address', assertAddress),
};
};
const assertSmartContractNetworksDefinition = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('SmartContractNetworksDefinition', name, value);
}
return _.mapValues(value, (val) => assertSmartContractNetworkDefinition('SmartContractNetworksDefinition', val));
};
export const assertSourceMaps = (_name, value) => {
if (value == undefined) {
return undefined;
}
return value;
};
export const assertSmartContractDefinition = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('SmartContractDefinition', name, value);
}
return {
networks: assertProperty(value, 'SmartContractDefinition', 'networks', assertSmartContractNetworksDefinition),
abi: assertProperty(value, 'SmartContractDefinition', 'abi', assertABI),
sourceMaps: assertProperty(value, 'SmartContractDefinition', 'sourceMaps', assertSourceMaps),
};
};
export const assertScriptBuilderParam = (name, value) => {
if (value == undefined) {
throw new InvalidArgumentError('ScriptBuilderParam', name, value);
}
return value;
};
export const assertNullableScriptBuilderParam = (name, value) => {
if (value == undefined) {
return undefined;
}
return assertScriptBuilderParam(name, value);
};
export const assertParam = (name, value) => {
if (value == undefined) {
throw new InvalidArgumentError('Param', name, value);
}
return value;
};
export const assertNullableParam = (name, value) => {
if (value == undefined) {
return undefined;
}
return assertParam(name, value);
};
export const assertForwardValue = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('ForwardValue', name, value);
}
return {
name: assertProperty(value, 'ForwardValue', 'name', assertString),
converted: assertProperty(value, 'ForwardValue', 'converted', assertNullableScriptBuilderParam),
param: assertProperty(value, 'ForwardValue', 'param', assertNullableParam),
};
};
export const assertTransfer = (name, value) => {
if (!isObject(value)) {
throw new InvalidArgumentError('Transfer', name, value);
}
return {
amount: assertProperty(value, 'Transfer', 'amount', assertBigNumber),
asset: assertProperty(value, 'Transfer', 'asset', assertHash256),
to: assertProperty(value, 'Transfer', 'to', assertAddress),
};
};
export const assertPrivateKey = (name, valueIn) => {
const value = assertString(name, valueIn);
try {
privateKeyToPublicKey(value);
return value;
}
catch {
try {
return wifToPrivateKey(value);
}
catch {
throw new InvalidArgumentError('PrivateKey', name, value);
}
}
};
export const assertTransfers = (name, valueIn) => {
const value = assertArray(name, valueIn);
return value.map((val) => assertTransfer(name, val));
};
const assertAttributeUsage = (name, valueIn) => {
const value = assertString(name, valueIn);
try {
return assertAttributeUsageJSON(value);
}
catch {
throw new InvalidArgumentError('AttributeUsage', name, value);
}
};
export const assertAttribute = (name, attribute) => {
if (!isObject(attribute)) {
throw new InvalidArgumentError('Attribute', name, attribute);
}
const usage = assertProperty(attribute, 'Attribute', 'usage', assertAttributeUsage);
switch (usage) {
case 'ContractHash':
case 'Vote':
case 'Hash1':
case 'Hash2':
case 'Hash3':
case 'Hash4':
case 'Hash5':
case 'Hash6':
case 'Hash7':
case 'Hash8':
case 'Hash9':
case 'Hash10':
case 'Hash11':
case 'Hash12':
case 'Hash13':
case 'Hash14':
case 'Hash15':
return {
usage,
data: assertProperty(attribute, 'Attribute', 'data', assertHash256),
};
case 'Script':
return {
usage,
data: assertProperty(attribute, 'Attribute', 'data', assertAddress),
};
case 'ECDH02':
case 'ECDH03':
return {
usage,
data: assertProperty(attribute, 'Attribute', 'data', assertPublicKey),
};
case 'DescriptionUrl':
case 'Description':
case 'Remark':
case 'Remark1':
case 'Remark2':
case 'Remark3':
case 'Remark4':
case 'Remark5':
case 'Remark6':
case 'Remark7':
case 'Remark8':
case 'Remark9':
case 'Remark10':
case 'Remark11':
case 'Remark12':
case 'Remark13':
case 'Remark14':
case 'Remark15':
return {
usage,
data: assertProperty(attribute, 'Attribute', 'data', assertBuffer),
};
default:
utils.assertNever(usage);
throw new Error('For TS');
}
};
export const assertTransactionOptions = (name, options) => {
if (options == undefined) {
return {};
}
if (!isObject(options)) {
throw new InvalidArgumentError('TransactionOptions', name, options);
}
return {
from: assertProperty(options, 'TransactionOptions', 'from', assertNullableUserAccountID),
attributes: assertProperty(options, 'TransactionOptions', 'attributes', assertNullableArray).map((value) => assertAttribute('TransactionOption.attributes', value)),
networkFee: assertProperty(options, 'TransactionOptions', 'networkFee', assertNullableBigNumber),
systemFee: assertProperty(options, 'TransactionOptions', 'systemFee', assertNullableBigNumber),
};
};
export const assertInvokeSendUnsafeReceiveTransactionOptions = (name, options) => {
if (options == undefined) {
return {};
}
if (!isObject(options)) {
throw new InvalidArgumentError('InvokeSendUnsafeReceiveTransactionOptions', name, options);
}
return {
from: assertProperty(options, 'InvokeSendUnsafeReceiveTransactionOptions', 'from', assertNullableUserAccountID),
attributes: assertProperty(options, 'InvokeSendUnsafeReceiveTransactionOptions', 'attributes', assertNullableArray).map((value) => assertAttribute('TransactionOption.attributes', value)),
networkFee: assertProperty(options, 'InvokeSendUnsafeReceiveTransactionOptions', 'networkFee', assertNullableBigNumber),
systemFee: assertProperty(options, 'InvokeSendUnsafeReceiveTransactionOptions', 'systemFee', assertNullableBigNumber),
sendTo: assertProperty(options, 'InvokeSendUnsafeReceiveTransactionOptions', 'sendTo', assertNullableSendTo),
sendFrom: assertProperty(options, 'InvokeSendUnsafeReceiveTransactionOptions', 'sendFrom', assertNullableSendFrom),
skipSysFeeCheck: assertProperty(options, 'InvokeSendUnsafeReceiveTransactionOptions', 'skipSysFeeCheck', assertNullableBoolean),
};
};
const assertNullableSendTo = (name, value) => {
if (value == undefined) {
return undefined;
}
return assertNullableArray(name, value).map((transfer) => ({
amount: assertProperty(transfer, 'transfer', 'amount', assertBigNumber),
asset: assertProperty(transfer, 'transfer', 'asset', assertHash256),
}));
};
const assertNullableSendFrom = (name, value) => {
if (value == undefined) {
return undefined;
}
return assertTransfers(name, value);
};
export const assertNullableIterOptions = (name, options) => {
if (options == undefined) {
return undefined;
}
if (!isObject(options)) {
throw new InvalidArgumentError('IterOptions', name, options);
}
const indexStart = assertProperty(options, 'IterOptions', 'indexStart', assertNullableNumber);
const indexStop = assertProperty(options, 'IterOptions', 'indexStop', assertNullableNumber);
if (indexStart != undefined && indexStop != undefined && indexStart >= indexStop) {
throw new InvalidArgumentError('IterOptions', name, options);
}
return {
indexStart,
indexStop,
};
};
//# sourceMappingURL=args.js.map