|
|
@ -4,233 +4,344 @@ |
|
|
//TODO - A reader MUST use the n field to validate the signature instead of performing signature recovery if a valid n field is provided.
|
|
|
//TODO - A reader MUST use the n field to validate the signature instead of performing signature recovery if a valid n field is provided.
|
|
|
|
|
|
|
|
|
function decode(paymentRequest) { |
|
|
function decode(paymentRequest) { |
|
|
let input = paymentRequest.toLowerCase(); |
|
|
let input = paymentRequest.toLowerCase() |
|
|
let splitPosition = input.lastIndexOf('1'); |
|
|
let splitPosition = input.lastIndexOf('1') |
|
|
let humanReadablePart = input.substring(0, splitPosition); |
|
|
let humanReadablePart = input.substring(0, splitPosition) |
|
|
let data = input.substring(splitPosition + 1, input.length - 6); |
|
|
let data = input.substring(splitPosition + 1, input.length - 6) |
|
|
let checksum = input.substring(input.length - 6, input.length); |
|
|
let checksum = input.substring(input.length - 6, input.length) |
|
|
if (!verify_checksum(humanReadablePart, bech32ToFiveBitArray(data + checksum))) { |
|
|
if ( |
|
|
throw 'Malformed request: checksum is incorrect'; // A reader MUST fail if the checksum is incorrect.
|
|
|
!verify_checksum(humanReadablePart, bech32ToFiveBitArray(data + checksum)) |
|
|
} |
|
|
) { |
|
|
return { |
|
|
throw 'Malformed request: checksum is incorrect' // A reader MUST fail if the checksum is incorrect.
|
|
|
'human_readable_part': decodeHumanReadablePart(humanReadablePart), |
|
|
} |
|
|
'data': decodeData(data, humanReadablePart), |
|
|
return { |
|
|
'checksum': checksum |
|
|
human_readable_part: decodeHumanReadablePart(humanReadablePart), |
|
|
} |
|
|
data: decodeData(data, humanReadablePart), |
|
|
|
|
|
checksum: checksum |
|
|
|
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function decodeHumanReadablePart(humanReadablePart) { |
|
|
function decodeHumanReadablePart(humanReadablePart) { |
|
|
let prefixes = ['lnbc', 'lntb', 'lnbcrt', 'lnsb']; |
|
|
let prefixes = ['lnbc', 'lntb', 'lnbcrt', 'lnsb'] |
|
|
let prefix; |
|
|
let prefix |
|
|
prefixes.forEach(value => { |
|
|
prefixes.forEach(value => { |
|
|
if (humanReadablePart.substring(0, value.length) === value) { |
|
|
if (humanReadablePart.substring(0, value.length) === value) { |
|
|
prefix = value; |
|
|
prefix = value |
|
|
} |
|
|
|
|
|
}); |
|
|
|
|
|
if (prefix == null) throw 'Malformed request: unknown prefix'; // A reader MUST fail if it does not understand the prefix.
|
|
|
|
|
|
let amount = decodeAmount(humanReadablePart.substring(prefix.length, humanReadablePart.length)); |
|
|
|
|
|
return { |
|
|
|
|
|
'prefix': prefix, |
|
|
|
|
|
'amount': amount |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
}) |
|
|
|
|
|
if (prefix == null) throw 'Malformed request: unknown prefix' // A reader MUST fail if it does not understand the prefix.
|
|
|
|
|
|
let amount = decodeAmount( |
|
|
|
|
|
humanReadablePart.substring(prefix.length, humanReadablePart.length) |
|
|
|
|
|
) |
|
|
|
|
|
return { |
|
|
|
|
|
prefix: prefix, |
|
|
|
|
|
amount: amount |
|
|
|
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function decodeData(data, humanReadablePart) { |
|
|
function decodeData(data, humanReadablePart) { |
|
|
let date32 = data.substring(0, 7); |
|
|
let date32 = data.substring(0, 7) |
|
|
let dateEpoch = bech32ToInt(date32); |
|
|
let dateEpoch = bech32ToInt(date32) |
|
|
let signature = data.substring(data.length - 104, data.length); |
|
|
let signature = data.substring(data.length - 104, data.length) |
|
|
let tagData = data.substring(7, data.length - 104); |
|
|
let tagData = data.substring(7, data.length - 104) |
|
|
let decodedTags = decodeTags(tagData); |
|
|
let decodedTags = decodeTags(tagData) |
|
|
let value = bech32ToFiveBitArray(date32 + tagData); |
|
|
let value = bech32ToFiveBitArray(date32 + tagData) |
|
|
value = fiveBitArrayTo8BitArray(value, true); |
|
|
value = fiveBitArrayTo8BitArray(value, true) |
|
|
value = textToHexString(humanReadablePart).concat(byteArrayToHexString(value)); |
|
|
value = textToHexString(humanReadablePart).concat(byteArrayToHexString(value)) |
|
|
return { |
|
|
return { |
|
|
'time_stamp': dateEpoch, |
|
|
time_stamp: dateEpoch, |
|
|
'tags': decodedTags, |
|
|
tags: decodedTags, |
|
|
'signature': decodeSignature(signature), |
|
|
signature: decodeSignature(signature), |
|
|
'signing_data': value |
|
|
signing_data: value |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function decodeSignature(signature) { |
|
|
function decodeSignature(signature) { |
|
|
let data = fiveBitArrayTo8BitArray(bech32ToFiveBitArray(signature)); |
|
|
let data = fiveBitArrayTo8BitArray(bech32ToFiveBitArray(signature)) |
|
|
let recoveryFlag = data[data.length - 1]; |
|
|
let recoveryFlag = data[data.length - 1] |
|
|
let r = byteArrayToHexString(data.slice(0, 32)); |
|
|
let r = byteArrayToHexString(data.slice(0, 32)) |
|
|
let s = byteArrayToHexString(data.slice(32, data.length - 1)); |
|
|
let s = byteArrayToHexString(data.slice(32, data.length - 1)) |
|
|
return { |
|
|
return { |
|
|
'r': r, |
|
|
r: r, |
|
|
's': s, |
|
|
s: s, |
|
|
'recovery_flag': recoveryFlag |
|
|
recovery_flag: recoveryFlag |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function decodeAmount(str) { |
|
|
function decodeAmount(str) { |
|
|
let multiplier = str.charAt(str.length - 1); |
|
|
let multiplier = str.charAt(str.length - 1) |
|
|
let amount = str.substring(0, str.length - 1); |
|
|
let amount = str.substring(0, str.length - 1) |
|
|
if (amount.substring(0, 1) === '0') { |
|
|
if (amount.substring(0, 1) === '0') { |
|
|
throw 'Malformed request: amount cannot contain leading zeros'; |
|
|
throw 'Malformed request: amount cannot contain leading zeros' |
|
|
} |
|
|
} |
|
|
amount = Number(amount); |
|
|
amount = Number(amount) |
|
|
if (amount < 0 || !Number.isInteger(amount)) { |
|
|
if (amount < 0 || !Number.isInteger(amount)) { |
|
|
throw 'Malformed request: amount must be a positive decimal integer'; // A reader SHOULD fail if amount contains a non-digit
|
|
|
throw 'Malformed request: amount must be a positive decimal integer' // A reader SHOULD fail if amount contains a non-digit
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
switch (multiplier) { |
|
|
switch (multiplier) { |
|
|
case '': |
|
|
case '': |
|
|
return 'Any amount'; // A reader SHOULD indicate if amount is unspecified
|
|
|
return 'Any amount' // A reader SHOULD indicate if amount is unspecified
|
|
|
case 'p': |
|
|
case 'p': |
|
|
return amount / 10; |
|
|
return amount / 10 |
|
|
case 'n': |
|
|
case 'n': |
|
|
return amount * 100; |
|
|
return amount * 100 |
|
|
case 'u': |
|
|
case 'u': |
|
|
return amount * 100000; |
|
|
return amount * 100000 |
|
|
case 'm': |
|
|
case 'm': |
|
|
return amount * 100000000; |
|
|
return amount * 100000000 |
|
|
default: |
|
|
default: |
|
|
// A reader SHOULD fail if amount is followed by anything except a defined multiplier.
|
|
|
// A reader SHOULD fail if amount is followed by anything except a defined multiplier.
|
|
|
throw 'Malformed request: undefined amount multiplier'; |
|
|
throw 'Malformed request: undefined amount multiplier' |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function decodeTags(tagData) { |
|
|
function decodeTags(tagData) { |
|
|
let tags = extractTags(tagData); |
|
|
let tags = extractTags(tagData) |
|
|
let decodedTags = []; |
|
|
let decodedTags = [] |
|
|
tags.forEach(value => decodedTags.push(decodeTag(value.type, value.length, value.data))); |
|
|
tags.forEach(value => |
|
|
return decodedTags; |
|
|
decodedTags.push(decodeTag(value.type, value.length, value.data)) |
|
|
|
|
|
) |
|
|
|
|
|
return decodedTags |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function extractTags(str) { |
|
|
function extractTags(str) { |
|
|
let tags = []; |
|
|
let tags = [] |
|
|
while (str.length > 0) { |
|
|
while (str.length > 0) { |
|
|
let type = str.charAt(0); |
|
|
let type = str.charAt(0) |
|
|
let dataLength = bech32ToInt(str.substring(1, 3)); |
|
|
let dataLength = bech32ToInt(str.substring(1, 3)) |
|
|
let data = str.substring(3, dataLength + 3); |
|
|
let data = str.substring(3, dataLength + 3) |
|
|
tags.push({ |
|
|
tags.push({ |
|
|
'type': type, |
|
|
type: type, |
|
|
'length': dataLength, |
|
|
length: dataLength, |
|
|
'data': data |
|
|
data: data |
|
|
}); |
|
|
}) |
|
|
str = str.substring(3 + dataLength, str.length); |
|
|
str = str.substring(3 + dataLength, str.length) |
|
|
} |
|
|
} |
|
|
return tags; |
|
|
return tags |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function decodeTag(type, length, data) { |
|
|
function decodeTag(type, length, data) { |
|
|
switch (type) { |
|
|
switch (type) { |
|
|
case 'p': |
|
|
case 'p': |
|
|
if (length !== 52) break; // A reader MUST skip over a 'p' field that does not have data_length 52
|
|
|
if (length !== 52) break // A reader MUST skip over a 'p' field that does not have data_length 52
|
|
|
return { |
|
|
return { |
|
|
'type': type, |
|
|
type: type, |
|
|
'length': length, |
|
|
length: length, |
|
|
'description': 'payment_hash', |
|
|
description: 'payment_hash', |
|
|
'value': byteArrayToHexString(fiveBitArrayTo8BitArray(bech32ToFiveBitArray(data))) |
|
|
value: byteArrayToHexString( |
|
|
}; |
|
|
fiveBitArrayTo8BitArray(bech32ToFiveBitArray(data)) |
|
|
case 'd': |
|
|
) |
|
|
return { |
|
|
} |
|
|
'type': type, |
|
|
case 'd': |
|
|
'length': length, |
|
|
return { |
|
|
'description': 'description', |
|
|
type: type, |
|
|
'value': bech32ToUTF8String(data) |
|
|
length: length, |
|
|
}; |
|
|
description: 'description', |
|
|
case 'n': |
|
|
value: bech32ToUTF8String(data) |
|
|
if (length !== 53) break; // A reader MUST skip over a 'n' field that does not have data_length 53
|
|
|
} |
|
|
return { |
|
|
case 'n': |
|
|
'type': type, |
|
|
if (length !== 53) break // A reader MUST skip over a 'n' field that does not have data_length 53
|
|
|
'length': length, |
|
|
return { |
|
|
'description': 'payee_public_key', |
|
|
type: type, |
|
|
'value': byteArrayToHexString(fiveBitArrayTo8BitArray(bech32ToFiveBitArray(data))) |
|
|
length: length, |
|
|
}; |
|
|
description: 'payee_public_key', |
|
|
case 'h': |
|
|
value: byteArrayToHexString( |
|
|
if (length !== 52) break; // A reader MUST skip over a 'h' field that does not have data_length 52
|
|
|
fiveBitArrayTo8BitArray(bech32ToFiveBitArray(data)) |
|
|
return { |
|
|
) |
|
|
'type': type, |
|
|
} |
|
|
'length': length, |
|
|
case 'h': |
|
|
'description': 'description_hash', |
|
|
if (length !== 52) break // A reader MUST skip over a 'h' field that does not have data_length 52
|
|
|
'value': data |
|
|
return { |
|
|
}; |
|
|
type: type, |
|
|
case 'x': |
|
|
length: length, |
|
|
return { |
|
|
description: 'description_hash', |
|
|
'type': type, |
|
|
value: data |
|
|
'length': length, |
|
|
} |
|
|
'description': 'expiry', |
|
|
case 'x': |
|
|
'value': bech32ToInt(data) |
|
|
return { |
|
|
}; |
|
|
type: type, |
|
|
case 'c': |
|
|
length: length, |
|
|
return { |
|
|
description: 'expiry', |
|
|
'type': type, |
|
|
value: bech32ToInt(data) |
|
|
'length': length, |
|
|
} |
|
|
'description': 'min_final_cltv_expiry', |
|
|
case 'c': |
|
|
'value': bech32ToInt(data) |
|
|
return { |
|
|
}; |
|
|
type: type, |
|
|
case 'f': |
|
|
length: length, |
|
|
let version = bech32ToFiveBitArray(data.charAt(0))[0]; |
|
|
description: 'min_final_cltv_expiry', |
|
|
if (version < 0 || version > 18) break; // a reader MUST skip over an f field with unknown version.
|
|
|
value: bech32ToInt(data) |
|
|
data = data.substring(1, data.length); |
|
|
} |
|
|
return { |
|
|
case 'f': |
|
|
'type': type, |
|
|
let version = bech32ToFiveBitArray(data.charAt(0))[0] |
|
|
'length': length, |
|
|
if (version < 0 || version > 18) break // a reader MUST skip over an f field with unknown version.
|
|
|
'description': 'fallback_address', |
|
|
data = data.substring(1, data.length) |
|
|
'value': { |
|
|
return { |
|
|
'version': version, |
|
|
type: type, |
|
|
'fallback_address': data |
|
|
length: length, |
|
|
} |
|
|
description: 'fallback_address', |
|
|
}; |
|
|
value: { |
|
|
case 'r': |
|
|
version: version, |
|
|
data = fiveBitArrayTo8BitArray(bech32ToFiveBitArray(data)); |
|
|
fallback_address: data |
|
|
let pubkey = data.slice(0, 33); |
|
|
} |
|
|
let shortChannelId = data.slice(33, 41); |
|
|
} |
|
|
let feeBaseMsat = data.slice(41, 45); |
|
|
case 'r': |
|
|
let feeProportionalMillionths = data.slice(45, 49); |
|
|
data = fiveBitArrayTo8BitArray(bech32ToFiveBitArray(data)) |
|
|
let cltvExpiryDelta = data.slice(49, 51); |
|
|
let pubkey = data.slice(0, 33) |
|
|
return { |
|
|
let shortChannelId = data.slice(33, 41) |
|
|
'type': type, |
|
|
let feeBaseMsat = data.slice(41, 45) |
|
|
'length': length, |
|
|
let feeProportionalMillionths = data.slice(45, 49) |
|
|
'description': 'routing_information', |
|
|
let cltvExpiryDelta = data.slice(49, 51) |
|
|
'value': { |
|
|
return { |
|
|
'public_key': byteArrayToHexString(pubkey), |
|
|
type: type, |
|
|
'short_channel_id': byteArrayToHexString(shortChannelId), |
|
|
length: length, |
|
|
'fee_base_msat': byteArrayToInt(feeBaseMsat), |
|
|
description: 'routing_information', |
|
|
'fee_proportional_millionths': byteArrayToInt(feeProportionalMillionths), |
|
|
value: { |
|
|
'cltv_expiry_delta': byteArrayToInt(cltvExpiryDelta) |
|
|
public_key: byteArrayToHexString(pubkey), |
|
|
} |
|
|
short_channel_id: byteArrayToHexString(shortChannelId), |
|
|
}; |
|
|
fee_base_msat: byteArrayToInt(feeBaseMsat), |
|
|
default: |
|
|
fee_proportional_millionths: byteArrayToInt( |
|
|
// reader MUST skip over unknown fields
|
|
|
feeProportionalMillionths |
|
|
} |
|
|
), |
|
|
|
|
|
cltv_expiry_delta: byteArrayToInt(cltvExpiryDelta) |
|
|
|
|
|
} |
|
|
|
|
|
} |
|
|
|
|
|
default: |
|
|
|
|
|
// reader MUST skip over unknown fields
|
|
|
|
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function polymod(values) { |
|
|
function polymod(values) { |
|
|
let GEN = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]; |
|
|
let GEN = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3] |
|
|
let chk = 1; |
|
|
let chk = 1 |
|
|
values.forEach((value) => { |
|
|
values.forEach(value => { |
|
|
let b = (chk >> 25); |
|
|
let b = chk >> 25 |
|
|
chk = (chk & 0x1ffffff) << 5 ^ value; |
|
|
chk = ((chk & 0x1ffffff) << 5) ^ value |
|
|
for (let i = 0; i < 5; i++) { |
|
|
for (let i = 0; i < 5; i++) { |
|
|
if (((b >> i) & 1) === 1) { |
|
|
if (((b >> i) & 1) === 1) { |
|
|
chk ^= GEN[i]; |
|
|
chk ^= GEN[i] |
|
|
} else { |
|
|
} else { |
|
|
chk ^= 0; |
|
|
chk ^= 0 |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
}); |
|
|
}) |
|
|
return chk; |
|
|
return chk |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function expand(str) { |
|
|
function expand(str) { |
|
|
let array = []; |
|
|
let array = [] |
|
|
for (let i = 0; i < str.length; i++) { |
|
|
for (let i = 0; i < str.length; i++) { |
|
|
array.push(str.charCodeAt(i) >> 5); |
|
|
array.push(str.charCodeAt(i) >> 5) |
|
|
} |
|
|
} |
|
|
array.push(0); |
|
|
array.push(0) |
|
|
for (let i = 0; i < str.length; i++) { |
|
|
for (let i = 0; i < str.length; i++) { |
|
|
array.push(str.charCodeAt(i) & 31); |
|
|
array.push(str.charCodeAt(i) & 31) |
|
|
} |
|
|
} |
|
|
return array; |
|
|
return array |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function verify_checksum(hrp, data) { |
|
|
function verify_checksum(hrp, data) { |
|
|
hrp = expand(hrp); |
|
|
hrp = expand(hrp) |
|
|
let all = hrp.concat(data); |
|
|
let all = hrp.concat(data) |
|
|
let bool = polymod(all); |
|
|
let bool = polymod(all) |
|
|
return bool === 1; |
|
|
return bool === 1 |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
const bech32CharValues = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l' |
|
|
|
|
|
|
|
|
|
|
|
function byteArrayToInt(byteArray) { |
|
|
|
|
|
let value = 0 |
|
|
|
|
|
for (let i = 0; i < byteArray.length; ++i) { |
|
|
|
|
|
value = (value << 8) + byteArray[i] |
|
|
|
|
|
} |
|
|
|
|
|
return value |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function bech32ToInt(str) { |
|
|
|
|
|
let sum = 0 |
|
|
|
|
|
for (let i = 0; i < str.length; i++) { |
|
|
|
|
|
sum = sum * 32 |
|
|
|
|
|
sum = sum + bech32CharValues.indexOf(str.charAt(i)) |
|
|
|
|
|
} |
|
|
|
|
|
return sum |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function bech32ToFiveBitArray(str) { |
|
|
|
|
|
let array = [] |
|
|
|
|
|
for (let i = 0; i < str.length; i++) { |
|
|
|
|
|
array.push(bech32CharValues.indexOf(str.charAt(i))) |
|
|
|
|
|
} |
|
|
|
|
|
return array |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function fiveBitArrayTo8BitArray(int5Array, includeOverflow) { |
|
|
|
|
|
let count = 0 |
|
|
|
|
|
let buffer = 0 |
|
|
|
|
|
let byteArray = [] |
|
|
|
|
|
int5Array.forEach(value => { |
|
|
|
|
|
buffer = (buffer << 5) + value |
|
|
|
|
|
count += 5 |
|
|
|
|
|
if (count >= 8) { |
|
|
|
|
|
byteArray.push((buffer >> (count - 8)) & 255) |
|
|
|
|
|
count -= 8 |
|
|
|
|
|
} |
|
|
|
|
|
}) |
|
|
|
|
|
if (includeOverflow && count > 0) { |
|
|
|
|
|
byteArray.push((buffer << (8 - count)) & 255) |
|
|
|
|
|
} |
|
|
|
|
|
return byteArray |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function bech32ToUTF8String(str) { |
|
|
|
|
|
let int5Array = bech32ToFiveBitArray(str) |
|
|
|
|
|
let byteArray = fiveBitArrayTo8BitArray(int5Array) |
|
|
|
|
|
|
|
|
|
|
|
let utf8String = '' |
|
|
|
|
|
for (let i = 0; i < byteArray.length; i++) { |
|
|
|
|
|
utf8String += '%' + ('0' + byteArray[i].toString(16)).slice(-2) |
|
|
|
|
|
} |
|
|
|
|
|
return decodeURIComponent(utf8String) |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function byteArrayToHexString(byteArray) { |
|
|
|
|
|
return Array.prototype.map |
|
|
|
|
|
.call(byteArray, function (byte) { |
|
|
|
|
|
return ('0' + (byte & 0xff).toString(16)).slice(-2) |
|
|
|
|
|
}) |
|
|
|
|
|
.join('') |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function textToHexString(text) { |
|
|
|
|
|
let hexString = '' |
|
|
|
|
|
for (let i = 0; i < text.length; i++) { |
|
|
|
|
|
hexString += text.charCodeAt(i).toString(16) |
|
|
|
|
|
} |
|
|
|
|
|
return hexString |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function epochToDate(int) { |
|
|
|
|
|
let date = new Date(int * 1000) |
|
|
|
|
|
return date.toUTCString() |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function isEmptyOrSpaces(str) { |
|
|
|
|
|
return str === null || str.match(/^ *$/) !== null |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function toFixed(x) { |
|
|
|
|
|
if (Math.abs(x) < 1.0) { |
|
|
|
|
|
var e = parseInt(x.toString().split('e-')[1]) |
|
|
|
|
|
if (e) { |
|
|
|
|
|
x *= Math.pow(10, e - 1) |
|
|
|
|
|
x = '0.' + new Array(e).join('0') + x.toString().substring(2) |
|
|
|
|
|
} |
|
|
|
|
|
} else { |
|
|
|
|
|
var e = parseInt(x.toString().split('+')[1]) |
|
|
|
|
|
if (e > 20) { |
|
|
|
|
|
e -= 20 |
|
|
|
|
|
x /= Math.pow(10, e) |
|
|
|
|
|
x += new Array(e + 1).join('0') |
|
|
|
|
|
} |
|
|
|
|
|
} |
|
|
|
|
|
return x |
|
|
|
|
|
} |
|
|
|
fiatjaf
4 years ago