ETH Price: $2,664.01 (-0.67%)

Contract

0x66dbba99501b8e4AdC51E152163eAF27B44392Bf
 

Overview

ETH Balance

0 ETH

ETH Value

$0.00

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To

There are no matching entries

Please try again later

Parent Transaction Hash Block From To
View All Internal Transactions

Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Inflator

Compiler Version
v0.8.19+commit.7dd6d404

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion
File 1 of 3 : Inflator.sol
// SPDX-License-Identifier: GPL-3.0

/// @title A contract used to decompress data compressed using the Deflate algorithm.
/// Based on Nouns https://github.com/nounsDAO/nouns-monorepo/blob/master/packages/nouns-contracts/contracts/Inflator.sol

/**
 *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░░░░░█████████░░█████████░░░ *
 * ░░░░░░██░░░████░░██░░░████░░░ *
 * ░░██████░░░████████░░░████░░░ *
 * ░░██░░██░░░████░░██░░░████░░░ *
 * ░░██░░██░░░████░░██░░░████░░░ *
 * ░░░░░░█████████░░█████████░░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 *
 */
pragma solidity >=0.8.0;

import {IInflator} from "./interfaces/IInflator.sol";
import {Inflate} from "./libs/Inflate.sol";

contract Inflator is IInflator {
    /**
     * @notice Decompresses Deflated bytes using the Puff algorithm
     * based on Based on https://github.com/adlerjohn/inflate-sol.
     * @param source the bytes to decompress.
     * @param destlen the length of the original decompressed bytes.
     * @return Inflate.ErrorCode 0 if successful, otherwise an error code specifying the reason for failure.
     * @return bytes the decompressed bytes.
     */
    function puff(bytes memory source, uint256 destlen) public pure returns (Inflate.ErrorCode, bytes memory) {
        return Inflate.puff(source, destlen);
    }
}

File 2 of 3 : IInflator.sol
// SPDX-License-Identifier: GPL-3.0

/// @title Interface for Inflator

/**
 *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░░░░░█████████░░█████████░░░ *
 * ░░░░░░██░░░████░░██░░░████░░░ *
 * ░░██████░░░████████░░░████░░░ *
 * ░░██░░██░░░████░░██░░░████░░░ *
 * ░░██░░██░░░████░░██░░░████░░░ *
 * ░░░░░░█████████░░█████████░░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 *
 */
pragma solidity >=0.8.0;

import {Inflate} from "../libs/Inflate.sol";

interface IInflator {
    function puff(bytes memory source, uint256 destlen) external pure returns (Inflate.ErrorCode, bytes memory);
}

File 3 of 3 : Inflate.sol
// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.8.0 <0.9.0;

/// @notice Based on https://github.com/madler/zlib/blob/master/contrib/puff
/// @dev Modified the original code for gas optimizations
/// 1. Disable overflow/underflow checks
/// 2. Chunk some loop iterations
library Inflate {
    // Maximum bits in a code
    uint256 constant MAXBITS = 15;
    // Maximum number of literal/length codes
    uint256 constant MAXLCODES = 286;
    // Maximum number of distance codes
    uint256 constant MAXDCODES = 30;
    // Maximum codes lengths to read
    uint256 constant MAXCODES = (MAXLCODES + MAXDCODES);
    // Number of fixed literal/length codes
    uint256 constant FIXLCODES = 288;

    // Error codes
    enum ErrorCode {
        ERR_NONE, // 0 successful inflate
        ERR_NOT_TERMINATED, // 1 available inflate data did not terminate
        ERR_OUTPUT_EXHAUSTED, // 2 output space exhausted before completing inflate
        ERR_INVALID_BLOCK_TYPE, // 3 invalid block type (type == 3)
        ERR_STORED_LENGTH_NO_MATCH, // 4 stored block length did not match one's complement
        ERR_TOO_MANY_LENGTH_OR_DISTANCE_CODES, // 5 dynamic block code description: too many length or distance codes
        ERR_CODE_LENGTHS_CODES_INCOMPLETE, // 6 dynamic block code description: code lengths codes incomplete
        ERR_REPEAT_NO_FIRST_LENGTH, // 7 dynamic block code description: repeat lengths with no first length
        ERR_REPEAT_MORE, // 8 dynamic block code description: repeat more than specified lengths
        ERR_INVALID_LITERAL_LENGTH_CODE_LENGTHS, // 9 dynamic block code description: invalid literal/length code lengths
        ERR_INVALID_DISTANCE_CODE_LENGTHS, // 10 dynamic block code description: invalid distance code lengths
        ERR_MISSING_END_OF_BLOCK, // 11 dynamic block code description: missing end-of-block code
        ERR_INVALID_LENGTH_OR_DISTANCE_CODE, // 12 invalid literal/length or distance code in fixed or dynamic block
        ERR_DISTANCE_TOO_FAR, // 13 distance is too far back in fixed or dynamic block
        ERR_CONSTRUCT // 14 internal: error in construct()

    }

    // Input and output state
    struct State {
        //////////////////
        // Output state //
        //////////////////
        // Output buffer
        bytes output;
        // Bytes written to out so far
        uint256 outcnt;
        /////////////////
        // Input state //
        /////////////////
        // Input buffer
        bytes input;
        // Bytes read so far
        uint256 incnt;
        ////////////////
        // Temp state //
        ////////////////
        // Bit buffer
        uint256 bitbuf;
        // Number of bits in bit buffer
        uint256 bitcnt;
        //////////////////////////
        // Static Huffman codes //
        //////////////////////////
        Huffman lencode;
        Huffman distcode;
    }

    // Huffman code decoding tables
    struct Huffman {
        uint256[] counts;
        uint256[] symbols;
    }

    function bits(State memory s, uint256 need) private pure returns (ErrorCode, uint256) {
        unchecked {
            // Bit accumulator (can use up to 20 bits)
            uint256 val;

            // Load at least need bits into val
            val = s.bitbuf;
            while (s.bitcnt < need) {
                if (s.incnt == s.input.length) {
                    // Out of input
                    return (ErrorCode.ERR_NOT_TERMINATED, 0);
                }

                // Load eight bits
                val |= uint256(uint8(s.input[s.incnt++])) << s.bitcnt;
                s.bitcnt += 8;
            }

            // Drop need bits and update buffer, always zero to seven bits left
            s.bitbuf = val >> need;
            s.bitcnt -= need;

            // Return need bits, zeroing the bits above that
            uint256 ret = (val & ((1 << need) - 1));
            return (ErrorCode.ERR_NONE, ret);
        }
    }

    function _stored(State memory s) private pure returns (ErrorCode) {
        unchecked {
            // Length of stored block
            uint256 len;

            // Discard leftover bits from current byte (assumes s.bitcnt < 8)
            s.bitbuf = 0;
            s.bitcnt = 0;

            // Get length and check against its one's complement
            if (s.incnt + 4 > s.input.length) {
                // Not enough input
                return ErrorCode.ERR_NOT_TERMINATED;
            }
            len = uint256(uint8(s.input[s.incnt++]));
            len |= uint256(uint8(s.input[s.incnt++])) << 8;

            if (uint8(s.input[s.incnt++]) != (~len & 0xFF) || uint8(s.input[s.incnt++]) != ((~len >> 8) & 0xFF)) {
                // Didn't match complement!
                return ErrorCode.ERR_STORED_LENGTH_NO_MATCH;
            }

            // Copy len bytes from in to out
            if (s.incnt + len > s.input.length) {
                // Not enough input
                return ErrorCode.ERR_NOT_TERMINATED;
            }
            if (s.outcnt + len > s.output.length) {
                // Not enough output space
                return ErrorCode.ERR_OUTPUT_EXHAUSTED;
            }
            while (len != 0) {
                // Note: Solidity reverts on underflow, so we decrement here
                len -= 1;
                s.output[s.outcnt++] = s.input[s.incnt++];
            }

            // Done with a valid stored block
            return ErrorCode.ERR_NONE;
        }
    }

    function _decode(State memory s, Huffman memory h) private pure returns (ErrorCode, uint256) {
        unchecked {
            // Current number of bits in code
            uint256 len;
            // Len bits being decoded
            uint256 code = 0;
            // First code of length len
            uint256 first = 0;
            // Number of codes of length len
            uint256 count;
            // Index of first code of length len in symbol table
            uint256 index = 0;
            // Error code
            ErrorCode err;

            uint256 tempCode;
            for (len = 1; len <= MAXBITS; len += 5) {
                // Get next bit
                (err, tempCode) = bits(s, 1);
                if (err != ErrorCode.ERR_NONE) {
                    return (err, 0);
                }
                code |= tempCode;
                count = h.counts[len];

                // If length len, return symbol
                if (code < first + count) {
                    return (ErrorCode.ERR_NONE, h.symbols[index + (code - first)]);
                }
                // Else update for next length
                index += count;
                first += count;
                first <<= 1;
                code <<= 1;

                // Get next bit
                (err, tempCode) = bits(s, 1);
                if (err != ErrorCode.ERR_NONE) {
                    return (err, 0);
                }
                code |= tempCode;
                count = h.counts[len + 1];

                // If length len, return symbol
                if (code < first + count) {
                    return (ErrorCode.ERR_NONE, h.symbols[index + (code - first)]);
                }
                // Else update for next length
                index += count;
                first += count;
                first <<= 1;
                code <<= 1;

                // Get next bit
                (err, tempCode) = bits(s, 1);
                if (err != ErrorCode.ERR_NONE) {
                    return (err, 0);
                }
                code |= tempCode;
                count = h.counts[len + 2];

                // If length len, return symbol
                if (code < first + count) {
                    return (ErrorCode.ERR_NONE, h.symbols[index + (code - first)]);
                }
                // Else update for next length
                index += count;
                first += count;
                first <<= 1;
                code <<= 1;

                // Get next bit
                (err, tempCode) = bits(s, 1);
                if (err != ErrorCode.ERR_NONE) {
                    return (err, 0);
                }
                code |= tempCode;
                count = h.counts[len + 3];

                // If length len, return symbol
                if (code < first + count) {
                    return (ErrorCode.ERR_NONE, h.symbols[index + (code - first)]);
                }
                // Else update for next length
                index += count;
                first += count;
                first <<= 1;
                code <<= 1;

                // Get next bit
                (err, tempCode) = bits(s, 1);
                if (err != ErrorCode.ERR_NONE) {
                    return (err, 0);
                }
                code |= tempCode;
                count = h.counts[len + 4];

                // If length len, return symbol
                if (code < first + count) {
                    return (ErrorCode.ERR_NONE, h.symbols[index + (code - first)]);
                }
                // Else update for next length
                index += count;
                first += count;
                first <<= 1;
                code <<= 1;
            }

            // Ran out of codes
            return (ErrorCode.ERR_INVALID_LENGTH_OR_DISTANCE_CODE, 0);
        }
    }

    function _construct(Huffman memory h, uint256[] memory lengths, uint256 n, uint256 start)
        private
        pure
        returns (ErrorCode)
    {
        unchecked {
            // Current symbol when stepping through lengths[]
            uint256 symbol;
            // Current length when stepping through h.counts[]
            uint256 len;
            // Number of possible codes left of current length
            uint256 left;
            // Offsets in symbol table for each length
            uint256[MAXBITS + 1] memory offs;

            // Count number of codes of each length
            for (len = 0; len <= MAXBITS; ++len) {
                h.counts[len] = 0;
            }
            for (symbol = 0; symbol < n; ++symbol) {
                // Assumes lengths are within bounds
                ++h.counts[lengths[start + symbol]];
            }
            // No codes!
            if (h.counts[0] == n) {
                // Complete, but decode() will fail
                return (ErrorCode.ERR_NONE);
            }

            // Check for an over-subscribed or incomplete set of lengths

            // One possible code of zero length
            left = 1;

            for (len = 1; len <= MAXBITS; len += 5) {
                // One more bit, double codes left
                left <<= 1;
                if (left < h.counts[len]) {
                    // Over-subscribed--return error
                    return ErrorCode.ERR_CONSTRUCT;
                }
                // Deduct count from possible codes
                left -= h.counts[len];

                // One more bit, double codes left
                left <<= 1;
                if (left < h.counts[len + 1]) {
                    // Over-subscribed--return error
                    return ErrorCode.ERR_CONSTRUCT;
                }
                // Deduct count from possible codes
                left -= h.counts[len + 1];

                // One more bit, double codes left
                left <<= 1;
                if (left < h.counts[len + 2]) {
                    // Over-subscribed--return error
                    return ErrorCode.ERR_CONSTRUCT;
                }
                // Deduct count from possible codes
                left -= h.counts[len + 2];

                // One more bit, double codes left
                left <<= 1;
                if (left < h.counts[len + 3]) {
                    // Over-subscribed--return error
                    return ErrorCode.ERR_CONSTRUCT;
                }
                // Deduct count from possible codes
                left -= h.counts[len + 3];

                // One more bit, double codes left
                left <<= 1;
                if (left < h.counts[len + 4]) {
                    // Over-subscribed--return error
                    return ErrorCode.ERR_CONSTRUCT;
                }
                // Deduct count from possible codes
                left -= h.counts[len + 4];
            }

            // Generate offsets into symbol table for each length for sorting
            offs[1] = 0;
            for (len = 1; len < MAXBITS; ++len) {
                offs[len + 1] = offs[len] + h.counts[len];
            }

            // Put symbols in table sorted by length, by symbol order within each length
            for (symbol = 0; symbol < n; ++symbol) {
                if (lengths[start + symbol] != 0) {
                    h.symbols[offs[lengths[start + symbol]]++] = symbol;
                }
            }

            // Left > 0 means incomplete
            return left > 0 ? ErrorCode.ERR_CONSTRUCT : ErrorCode.ERR_NONE;
        }
    }

    function _codes(State memory s, Huffman memory lencode, Huffman memory distcode) private pure returns (ErrorCode) {
        unchecked {
            // Decoded symbol
            uint256 symbol;
            // Length for copy
            uint256 len;
            // Distance for copy
            uint256 dist;
            // TODO Solidity doesn't support constant arrays, but these are fixed at compile-time
            // Size base for length codes 257..285
            uint16[29] memory lens = [
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                13,
                15,
                17,
                19,
                23,
                27,
                31,
                35,
                43,
                51,
                59,
                67,
                83,
                99,
                115,
                131,
                163,
                195,
                227,
                258
            ];
            // Extra bits for length codes 257..285
            uint8[29] memory lext =
                [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
            // Offset base for distance codes 0..29
            uint16[30] memory dists = [
                1,
                2,
                3,
                4,
                5,
                7,
                9,
                13,
                17,
                25,
                33,
                49,
                65,
                97,
                129,
                193,
                257,
                385,
                513,
                769,
                1025,
                1537,
                2049,
                3073,
                4097,
                6145,
                8193,
                12289,
                16385,
                24577
            ];
            // Extra bits for distance codes 0..29
            uint8[30] memory dext =
                [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
            // Error code
            ErrorCode err;

            // Decode literals and length/distance pairs
            while (symbol != 256) {
                (err, symbol) = _decode(s, lencode);
                if (err != ErrorCode.ERR_NONE) {
                    // Invalid symbol
                    return err;
                }

                if (symbol < 256) {
                    // Literal: symbol is the byte
                    // Write out the literal
                    if (s.outcnt == s.output.length) {
                        return ErrorCode.ERR_OUTPUT_EXHAUSTED;
                    }
                    s.output[s.outcnt] = bytes1(uint8(symbol));
                    ++s.outcnt;
                } else if (symbol > 256) {
                    uint256 tempBits;
                    // Length
                    // Get and compute length
                    symbol -= 257;
                    if (symbol >= 29) {
                        // Invalid fixed code
                        return ErrorCode.ERR_INVALID_LENGTH_OR_DISTANCE_CODE;
                    }

                    (err, tempBits) = bits(s, lext[symbol]);
                    if (err != ErrorCode.ERR_NONE) {
                        return err;
                    }
                    len = lens[symbol] + tempBits;

                    // Get and check distance
                    (err, symbol) = _decode(s, distcode);
                    if (err != ErrorCode.ERR_NONE) {
                        // Invalid symbol
                        return err;
                    }
                    (err, tempBits) = bits(s, dext[symbol]);
                    if (err != ErrorCode.ERR_NONE) {
                        return err;
                    }
                    dist = dists[symbol] + tempBits;
                    if (dist > s.outcnt) {
                        // Distance too far back
                        return ErrorCode.ERR_DISTANCE_TOO_FAR;
                    }

                    // Copy length bytes from distance bytes back
                    if (s.outcnt + len > s.output.length) {
                        return ErrorCode.ERR_OUTPUT_EXHAUSTED;
                    }
                    while (len != 0) {
                        // Note: Solidity reverts on underflow, so we decrement here
                        len -= 1;
                        s.output[s.outcnt] = s.output[s.outcnt - dist];
                        ++s.outcnt;
                    }
                } else {
                    s.outcnt += len;
                }
            }

            // Done with a valid fixed or dynamic block
            return ErrorCode.ERR_NONE;
        }
    }

    function _build_fixed(State memory s) private pure returns (ErrorCode) {
        unchecked {
            // Build fixed Huffman tables
            // TODO this is all a compile-time constant
            uint256 symbol;
            uint256[] memory lengths = new uint256[](FIXLCODES);

            // Literal/length table
            for (symbol = 0; symbol < 144; ++symbol) {
                lengths[symbol] = 8;
            }
            for (; symbol < 256; ++symbol) {
                lengths[symbol] = 9;
            }
            for (; symbol < 280; ++symbol) {
                lengths[symbol] = 7;
            }
            for (; symbol < FIXLCODES; ++symbol) {
                lengths[symbol] = 8;
            }

            _construct(s.lencode, lengths, FIXLCODES, 0);

            // Distance table
            for (symbol = 0; symbol < MAXDCODES; ++symbol) {
                lengths[symbol] = 5;
            }

            _construct(s.distcode, lengths, MAXDCODES, 0);

            return ErrorCode.ERR_NONE;
        }
    }

    function _fixed(State memory s) private pure returns (ErrorCode) {
        unchecked {
            // Decode data until end-of-block code
            return _codes(s, s.lencode, s.distcode);
        }
    }

    function _build_dynamic_lengths(State memory s) private pure returns (ErrorCode, uint256[] memory) {
        unchecked {
            uint256 ncode;
            // Index of lengths[]
            uint256 index;
            // Descriptor code lengths
            uint256[] memory lengths = new uint256[](MAXCODES);
            // Error code
            ErrorCode err;
            // Permutation of code length codes
            uint8[19] memory order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];

            (err, ncode) = bits(s, 4);
            if (err != ErrorCode.ERR_NONE) {
                return (err, lengths);
            }
            ncode += 4;

            // Read code length code lengths (really), missing lengths are zero
            for (index = 0; index < ncode; ++index) {
                (err, lengths[order[index]]) = bits(s, 3);
                if (err != ErrorCode.ERR_NONE) {
                    return (err, lengths);
                }
            }
            for (; index < 19; ++index) {
                lengths[order[index]] = 0;
            }

            return (ErrorCode.ERR_NONE, lengths);
        }
    }

    function _build_dynamic(State memory s) private pure returns (ErrorCode, Huffman memory, Huffman memory) {
        unchecked {
            // Number of lengths in descriptor
            uint256 nlen;
            uint256 ndist;
            // Index of lengths[]
            uint256 index;
            // Error code
            ErrorCode err;
            // Descriptor code lengths
            uint256[] memory lengths = new uint256[](MAXCODES);
            // Length and distance codes
            Huffman memory lencode = Huffman(new uint256[](MAXBITS + 1), new uint256[](MAXLCODES));
            Huffman memory distcode = Huffman(new uint256[](MAXBITS + 1), new uint256[](MAXDCODES));
            uint256 tempBits;

            // Get number of lengths in each table, check lengths
            (err, nlen) = bits(s, 5);
            if (err != ErrorCode.ERR_NONE) {
                return (err, lencode, distcode);
            }
            nlen += 257;
            (err, ndist) = bits(s, 5);
            if (err != ErrorCode.ERR_NONE) {
                return (err, lencode, distcode);
            }
            ndist += 1;

            if (nlen > MAXLCODES || ndist > MAXDCODES) {
                // Bad counts
                return (ErrorCode.ERR_TOO_MANY_LENGTH_OR_DISTANCE_CODES, lencode, distcode);
            }

            (err, lengths) = _build_dynamic_lengths(s);
            if (err != ErrorCode.ERR_NONE) {
                return (err, lencode, distcode);
            }

            // Build huffman table for code lengths codes (use lencode temporarily)
            err = _construct(lencode, lengths, 19, 0);
            if (err != ErrorCode.ERR_NONE) {
                // Require complete code set here
                return (ErrorCode.ERR_CODE_LENGTHS_CODES_INCOMPLETE, lencode, distcode);
            }

            // Read length/literal and distance code length tables
            index = 0;
            while (index < nlen + ndist) {
                // Decoded value
                uint256 symbol;
                // Last length to repeat
                uint256 len;

                (err, symbol) = _decode(s, lencode);
                if (err != ErrorCode.ERR_NONE) {
                    // Invalid symbol
                    return (err, lencode, distcode);
                }

                if (symbol < 16) {
                    // Length in 0..15
                    lengths[index++] = symbol;
                } else {
                    // Repeat instruction
                    // Assume repeating zeros
                    len = 0;
                    if (symbol == 16) {
                        // Repeat last length 3..6 times
                        if (index == 0) {
                            // No last length!
                            return (ErrorCode.ERR_REPEAT_NO_FIRST_LENGTH, lencode, distcode);
                        }
                        // Last length
                        len = lengths[index - 1];
                        (err, tempBits) = bits(s, 2);
                        if (err != ErrorCode.ERR_NONE) {
                            return (err, lencode, distcode);
                        }
                        symbol = 3 + tempBits;
                    } else if (symbol == 17) {
                        // Repeat zero 3..10 times
                        (err, tempBits) = bits(s, 3);
                        if (err != ErrorCode.ERR_NONE) {
                            return (err, lencode, distcode);
                        }
                        symbol = 3 + tempBits;
                    } else {
                        // == 18, repeat zero 11..138 times
                        (err, tempBits) = bits(s, 7);
                        if (err != ErrorCode.ERR_NONE) {
                            return (err, lencode, distcode);
                        }
                        symbol = 11 + tempBits;
                    }

                    if (index + symbol > nlen + ndist) {
                        // Too many lengths!
                        return (ErrorCode.ERR_REPEAT_MORE, lencode, distcode);
                    }
                    while (symbol != 0) {
                        // Note: Solidity reverts on underflow, so we decrement here
                        symbol -= 1;

                        // Repeat last or zero symbol times
                        lengths[index++] = len;
                    }
                }
            }

            // Check for end-of-block code -- there better be one!
            if (lengths[256] == 0) {
                return (ErrorCode.ERR_MISSING_END_OF_BLOCK, lencode, distcode);
            }

            // Build huffman table for literal/length codes
            err = _construct(lencode, lengths, nlen, 0);
            if (
                err != ErrorCode.ERR_NONE
                    && (
                        err == ErrorCode.ERR_NOT_TERMINATED || err == ErrorCode.ERR_OUTPUT_EXHAUSTED
                            || nlen != lencode.counts[0] + lencode.counts[1]
                    )
            ) {
                // Incomplete code ok only for single length 1 code
                return (ErrorCode.ERR_INVALID_LITERAL_LENGTH_CODE_LENGTHS, lencode, distcode);
            }

            // Build huffman table for distance codes
            err = _construct(distcode, lengths, ndist, nlen);
            if (
                err != ErrorCode.ERR_NONE
                    && (
                        err == ErrorCode.ERR_NOT_TERMINATED || err == ErrorCode.ERR_OUTPUT_EXHAUSTED
                            || ndist != distcode.counts[0] + distcode.counts[1]
                    )
            ) {
                // Incomplete code ok only for single length 1 code
                return (ErrorCode.ERR_INVALID_DISTANCE_CODE_LENGTHS, lencode, distcode);
            }

            return (ErrorCode.ERR_NONE, lencode, distcode);
        }
    }

    function _dynamic(State memory s) private pure returns (ErrorCode) {
        unchecked {
            // Length and distance codes
            Huffman memory lencode;
            Huffman memory distcode;
            // Error code
            ErrorCode err;

            (err, lencode, distcode) = _build_dynamic(s);
            if (err != ErrorCode.ERR_NONE) {
                return err;
            }

            // Decode data until end-of-block code
            return _codes(s, lencode, distcode);
        }
    }

    function puff(bytes memory source, uint256 destlen) internal pure returns (ErrorCode, bytes memory) {
        unchecked {
            // Input/output state
            State memory s = State(
                new bytes(destlen),
                0,
                source,
                0,
                0,
                0,
                Huffman(new uint256[](MAXBITS + 1), new uint256[](FIXLCODES)),
                Huffman(new uint256[](MAXBITS + 1), new uint256[](MAXDCODES))
            );
            // Temp: last bit
            uint256 last;
            // Temp: block type bit
            uint256 t;
            // Error code
            ErrorCode err;

            // Build fixed Huffman tables
            err = _build_fixed(s);
            if (err != ErrorCode.ERR_NONE) {
                return (err, s.output);
            }

            // Process blocks until last block or error
            while (last == 0) {
                // One if last block
                (err, last) = bits(s, 1);
                if (err != ErrorCode.ERR_NONE) {
                    return (err, s.output);
                }

                // Block type 0..3
                (err, t) = bits(s, 2);
                if (err != ErrorCode.ERR_NONE) {
                    return (err, s.output);
                }

                err = (
                    t == 0
                        ? _stored(s)
                        : (t == 1 ? _fixed(s) : (t == 2 ? _dynamic(s) : ErrorCode.ERR_INVALID_BLOCK_TYPE))
                );
                // type == 3, invalid

                if (err != ErrorCode.ERR_NONE) {
                    // Return with error
                    break;
                }
            }

            return (err, s.output);
        }
    }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"bytes","name":"source","type":"bytes"},{"internalType":"uint256","name":"destlen","type":"uint256"}],"name":"puff","outputs":[{"internalType":"enum Inflate.ErrorCode","name":"","type":"uint8"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"pure","type":"function"}]

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

Deployed Bytecode

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

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.