| 1 | "use strict";
|
| 2 | Object.defineProperty(exports, "__esModule", { value: true });
|
| 3 | exports.sha256 = exports.keccak256 = exports.pack = void 0;
|
| 4 | var bignumber_1 = require("@ethersproject/bignumber");
|
| 5 | var bytes_1 = require("@ethersproject/bytes");
|
| 6 | var keccak256_1 = require("@ethersproject/keccak256");
|
| 7 | var sha2_1 = require("@ethersproject/sha2");
|
| 8 | var strings_1 = require("@ethersproject/strings");
|
| 9 | var regexBytes = new RegExp("^bytes([0-9]+)$");
|
| 10 | var regexNumber = new RegExp("^(u?int)([0-9]*)$");
|
| 11 | var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
|
| 12 | var Zeros = "0000000000000000000000000000000000000000000000000000000000000000";
|
| 13 | var logger_1 = require("@ethersproject/logger");
|
| 14 | var _version_1 = require("./_version");
|
| 15 | var logger = new logger_1.Logger(_version_1.version);
|
| 16 | function _pack(type, value, isArray) {
|
| 17 | switch (type) {
|
| 18 | case "address":
|
| 19 | if (isArray) {
|
| 20 | return (0, bytes_1.zeroPad)(value, 32);
|
| 21 | }
|
| 22 | return (0, bytes_1.arrayify)(value);
|
| 23 | case "string":
|
| 24 | return (0, strings_1.toUtf8Bytes)(value);
|
| 25 | case "bytes":
|
| 26 | return (0, bytes_1.arrayify)(value);
|
| 27 | case "bool":
|
| 28 | value = (value ? "0x01" : "0x00");
|
| 29 | if (isArray) {
|
| 30 | return (0, bytes_1.zeroPad)(value, 32);
|
| 31 | }
|
| 32 | return (0, bytes_1.arrayify)(value);
|
| 33 | }
|
| 34 | var match = type.match(regexNumber);
|
| 35 | if (match) {
|
| 36 |
|
| 37 | var size = parseInt(match[2] || "256");
|
| 38 | if ((match[2] && String(size) !== match[2]) || (size % 8 !== 0) || size === 0 || size > 256) {
|
| 39 | logger.throwArgumentError("invalid number type", "type", type);
|
| 40 | }
|
| 41 | if (isArray) {
|
| 42 | size = 256;
|
| 43 | }
|
| 44 | value = bignumber_1.BigNumber.from(value).toTwos(size);
|
| 45 | return (0, bytes_1.zeroPad)(value, size / 8);
|
| 46 | }
|
| 47 | match = type.match(regexBytes);
|
| 48 | if (match) {
|
| 49 | var size = parseInt(match[1]);
|
| 50 | if (String(size) !== match[1] || size === 0 || size > 32) {
|
| 51 | logger.throwArgumentError("invalid bytes type", "type", type);
|
| 52 | }
|
| 53 | if ((0, bytes_1.arrayify)(value).byteLength !== size) {
|
| 54 | logger.throwArgumentError("invalid value for " + type, "value", value);
|
| 55 | }
|
| 56 | if (isArray) {
|
| 57 | return (0, bytes_1.arrayify)((value + Zeros).substring(0, 66));
|
| 58 | }
|
| 59 | return value;
|
| 60 | }
|
| 61 | match = type.match(regexArray);
|
| 62 | if (match && Array.isArray(value)) {
|
| 63 | var baseType_1 = match[1];
|
| 64 | var count = parseInt(match[2] || String(value.length));
|
| 65 | if (count != value.length) {
|
| 66 | logger.throwArgumentError("invalid array length for " + type, "value", value);
|
| 67 | }
|
| 68 | var result_1 = [];
|
| 69 | value.forEach(function (value) {
|
| 70 | result_1.push(_pack(baseType_1, value, true));
|
| 71 | });
|
| 72 | return (0, bytes_1.concat)(result_1);
|
| 73 | }
|
| 74 | return logger.throwArgumentError("invalid type", "type", type);
|
| 75 | }
|
| 76 |
|
| 77 | function pack(types, values) {
|
| 78 | if (types.length != values.length) {
|
| 79 | logger.throwArgumentError("wrong number of values; expected ${ types.length }", "values", values);
|
| 80 | }
|
| 81 | var tight = [];
|
| 82 | types.forEach(function (type, index) {
|
| 83 | tight.push(_pack(type, values[index]));
|
| 84 | });
|
| 85 | return (0, bytes_1.hexlify)((0, bytes_1.concat)(tight));
|
| 86 | }
|
| 87 | exports.pack = pack;
|
| 88 | function keccak256(types, values) {
|
| 89 | return (0, keccak256_1.keccak256)(pack(types, values));
|
| 90 | }
|
| 91 | exports.keccak256 = keccak256;
|
| 92 | function sha256(types, values) {
|
| 93 | return (0, sha2_1.sha256)(pack(types, values));
|
| 94 | }
|
| 95 | exports.sha256 = sha256;
|
| 96 | |
| \ | No newline at end of file |