@1inch/solidity-utils 3.5.6 → 3.6.0

package/contracts/PermitAndCall.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "./libraries/SafeERC20.sol";
+
+abstract contract PermitAndCall {
+    using SafeERC20 for IERC20;
+
+    function permitAndCall(bytes calldata permit, bytes calldata action) external payable {
+        IERC20(address(bytes20(permit))).tryPermit(permit[20:]);
+        // solhint-disable-next-line no-inline-assembly
+        assembly ("memory-safe") {
+            let ptr := mload(0x40)
+            calldatacopy(ptr, action.offset, action.length)
+            let success := delegatecall(gas(), address(), ptr, action.length, 0, 0)
+            returndatacopy(ptr, 0, returndatasize())
+            switch success
+            case 0 {
+                revert(ptr, returndatasize())
+            }
+            default {
+                return(ptr, returndatasize())
+            }
+        }
+    }
+}

package/contracts/libraries/BytesMemory.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title A library for operating on bytes memory slices without copying.
+ */
+library BytesMemory {
+    error OutOfBounds();
+
+    /**
+     * @dev A struct representing a slice of bytes.
+     * This points directly to memory without copying the slice.
+     */
+    struct Slice {
+        uint256 pointer; // The pointer to the location of the slice in memory.
+        uint256 length; // The length of the slice in bytes.
+    }
+
+    /**
+     * @dev Creates a `Slice` from a bytes array.
+     * @param data The bytes array to create a slice from.
+     * @return ret A `Slice` struct representing the entire bytes array.
+     */
+    function wrap(bytes memory data) internal pure returns (Slice memory ret) {
+        assembly ("memory-safe") { // solhint-disable-line no-inline-assembly
+            mstore(ret, add(data, 0x20))
+            mstore(add(ret, 0x20), mload(data))
+        }
+    }
+
+    /**
+     * @dev Returns a new `Slice` representing a portion of the original.
+     * @param data The original `Slice` to take a portion from.
+     * @param offset The offset in bytes from the start of the original `Slice`.
+     * @param size The size of the new `Slice` in bytes.
+     * @return ret A new `Slice` struct representing the specified portion of the original.
+     */
+    function slice(Slice memory data, uint256 offset, uint256 size) internal pure returns (Slice memory ret) {
+        if (offset + size > data.length) revert OutOfBounds();
+
+        unchecked {
+            ret.pointer = data.pointer + offset;
+            ret.length = size;
+        }
+    }
+
+    /**
+     * @dev Converts a `Slice` back into a bytes array. The bytes array is returned without copying the data.
+     * @param piece The `Slice` to convert back to a bytes array.
+     * @return ret The bytes array represented by the `Slice`.
+     */
+    function unwrap(Slice memory piece) internal view returns (bytes memory ret) {
+        uint256 pointer = piece.pointer;
+        uint256 length = piece.length;
+        assembly ("memory-safe") { // solhint-disable-line no-inline-assembly
+            ret := mload(0x40)
+            mstore(0x40, add(ret, add(0x20, length)))
+            mstore(ret, length)
+
+            switch gt(length, 32)
+            case 0 {
+                mstore(add(ret, 0x20), mload(pointer))
+            }
+            default {
+                pop(staticcall(gas(), 0x04, pointer, length, add(ret, 0x20), length))
+            }
+        }
+    }
+}

package/contracts/libraries/BytesStorage.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title A library for operating on bytes storage slices.
+ */
+library BytesStorage {
+    error OutOfBounds();
+
+    /**
+     * @dev A struct representing a slice of bytes storage.
+     */
+    struct Slice {
+        uint256 slot; // The storage slot where the data begins.
+        uint256 offset; // The byte offset within the slot where the data begins.
+        uint256 length; // The length of the data in bytes.
+    }
+
+    /**
+     * @dev Wraps a bytes storage array into a `Slice`. For a detailed explanation,
+     *      refer to https://ethereum.stackexchange.com/questions/107282/storage-and-memory-layout-of-strings/155800#155800
+     * @param data The bytes storage array to wrap.
+     * @return A `Slice` struct that refers to the storage location and length of `data`.
+     */
+    function wrap(bytes storage data) internal view returns (Slice memory) {
+        uint256 length;
+        uint256 slot;
+        assembly ("memory-safe") { // solhint-disable-line no-inline-assembly
+            let blob := sload(data.slot)
+
+            switch and(1, blob)
+            case 0 { // Short
+                slot := data.slot
+                length := shr(1, and(blob, 0xFF))
+            }
+            default { // Long
+                mstore(0, data.slot)
+                slot := keccak256(0, 0x20)
+                length := shr(1, blob)
+            }
+        }
+
+        return Slice({
+            slot: slot,
+            offset: 0,
+            length: length
+        });
+    }
+
+    /**
+     * @dev Returns a new `Slice` representing a portion of the original storage slice.
+     * @param data The original `Slice` to take a portion from.
+     * @param offset The offset in bytes from the start of the original `Slice`.
+     * @param size The size of the new `Slice` in bytes.
+     * @return A new `Slice` struct representing the specified portion of the original.
+     */
+    function slice(Slice memory data, uint256 offset, uint256 size) internal pure returns (Slice memory) {
+        if (offset + size > data.length) revert OutOfBounds();
+
+        uint256 newOffset = data.offset + offset;
+        return Slice({
+            slot: data.slot + (newOffset >> 5),
+            offset: newOffset & 0x1f,
+            length: size
+        });
+    }
+
+    /**
+     * @dev Copies a `Slice` from storage and returns it as a new bytes array.
+     * @param piece The `Slice` to copy from storage.
+     * @return ret The new bytes array containing the copied data.
+     */
+    function copy(Slice memory piece) internal view returns (bytes memory ret) {
+        uint256 startSlot = piece.slot;
+        uint256 offset = piece.offset;
+        uint256 length = piece.length;
+        assembly ("memory-safe") { // solhint-disable-line no-inline-assembly
+            ret := mload(0x40)
+            mstore(0x40, add(ret, add(0x20, length)))
+            mstore(ret, length)
+
+            let out := add(ret, 0x20)
+            let endSlot := add(startSlot, div(add(add(length, offset), 0x1F), 0x20))
+
+            mstore(out, shl(mul(8, offset), sload(startSlot)))
+            out := add(out, sub(0x20, offset))
+
+            for { let slot := add(startSlot, 1) } lt(slot, endSlot) { slot := add(slot, 1) } {
+                mstore(out, sload(slot))
+                out := add(out, 0x20)
+            }
+        }
+    }
+}

package/dist/src/prelude.js

@@ -11,6 +11,9 @@ Object.defineProperty(exports, "should", { enumerable: true, get: function () {
 const ethers_1 = require("ethers");
 const hardhat_network_helpers_1 = require("@nomicfoundation/hardhat-network-helpers");
 Object.defineProperty(exports, "time", { enumerable: true, get: function () { return hardhat_network_helpers_1.time; } });
+const chai_2 = require("chai");
+const mocha_chai_jest_snapshot_1 = require("mocha-chai-jest-snapshot");
+(0, chai_2.use)((0, mocha_chai_jest_snapshot_1.jestSnapshotPlugin)());
 exports.constants = {
     ZERO_ADDRESS: '0x0000000000000000000000000000000000000000',
     EEE_ADDRESS: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',

package/dist/src/prelude.js.map

@@ -1 +1 @@
-{"version":3,"file":"prelude.js","sourceRoot":"","sources":["../../src/prelude.ts"],"names":[],"mappings":";;;AAAA,+BAAiF;AAyBxE,0FAzBA,gBAAS,OAyBA;AAAE,+FAzBA,qBAAc,OAyBA;AAAE,uFAzBA,aAAM,OAyBA;AAAE,uFAzBA,aAAM,OAyBA;AAAE,uFAzBA,aAAM,OAyBA;AAAE,uFAzBA,aAAM,OAyBA;AAxBlE,mCAAoC;AACpC,sFAAgE;AAgBvD,qFAhBA,8BAAI,OAgBA;AAdA,QAAA,SAAS,GAAG;IACrB,YAAY,EAAE,4CAA4C;IAC1D,WAAW,EAAE,4CAA4C;IACzD,YAAY,EAAE,oEAAoE;IAClF,WAAW,EAAE,EAAE,IAAI,IAAI,GAAG,EAAE;IAC5B,UAAU,EAAE,EAAE,IAAI,IAAI,GAAG,EAAE;IAC3B,UAAU,EAAE,EAAE,IAAI,GAAG,GAAG,EAAE;IAC1B,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC;IACzB,WAAW,EAAE,EAAE,IAAI,IAAI,GAAG,EAAE;IAC5B,UAAU,EAAE,EAAE,IAAI,GAAG,GAAG,EAAE;IAC1B,UAAU,EAAE,CAAC,SAAS,EAAE,WAAW,CAAa;CAC1C,CAAC;AAKX,SAAgB,KAAK,CAAC,CAAS;IAC3B,OAAO,IAAA,mBAAU,EAAC,CAAC,CAAC,CAAC;AACzB,CAAC;AAFD,sBAEC"}
+{"version":3,"file":"prelude.js","sourceRoot":"","sources":["../../src/prelude.ts"],"names":[],"mappings":";;;AAAA,+BAAiF;AA6BxE,0FA7BA,gBAAS,OA6BA;AAAE,+FA7BA,qBAAc,OA6BA;AAAE,uFA7BA,aAAM,OA6BA;AAAE,uFA7BA,aAAM,OA6BA;AAAE,uFA7BA,aAAM,OA6BA;AAAE,uFA7BA,aAAM,OA6BA;AA5BlE,mCAAoC;AACpC,sFAAgE;AAoBvD,qFApBA,8BAAI,OAoBA;AAlBb,+BAA2B;AAC3B,uEAA8D;AAC9D,IAAA,UAAG,EAAC,IAAA,6CAAkB,GAAE,CAAC,CAAC;AAEb,QAAA,SAAS,GAAG;IACrB,YAAY,EAAE,4CAA4C;IAC1D,WAAW,EAAE,4CAA4C;IACzD,YAAY,EAAE,oEAAoE;IAClF,WAAW,EAAE,EAAE,IAAI,IAAI,GAAG,EAAE;IAC5B,UAAU,EAAE,EAAE,IAAI,IAAI,GAAG,EAAE;IAC3B,UAAU,EAAE,EAAE,IAAI,GAAG,GAAG,EAAE;IAC1B,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC;IACzB,WAAW,EAAE,EAAE,IAAI,IAAI,GAAG,EAAE;IAC5B,UAAU,EAAE,EAAE,IAAI,GAAG,GAAG,EAAE;IAC1B,UAAU,EAAE,CAAC,SAAS,EAAE,WAAW,CAAa;CAC1C,CAAC;AAKX,SAAgB,KAAK,CAAC,CAAS;IAC3B,OAAO,IAAA,mBAAU,EAAC,CAAC,CAAC,CAAC;AACzB,CAAC;AAFD,sBAEC"}

package/dist/typechain-types/contracts/PermitAndCall.d.ts

@@ -0,0 +1,35 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../common";
+export interface PermitAndCallInterface extends Interface {
+    getFunction(nameOrSignature: "permitAndCall"): FunctionFragment;
+    encodeFunctionData(functionFragment: "permitAndCall", values: [BytesLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "permitAndCall", data: BytesLike): Result;
+}
+export interface PermitAndCall extends BaseContract {
+    connect(runner?: ContractRunner | null): PermitAndCall;
+    waitForDeployment(): Promise<this>;
+    interface: PermitAndCallInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    permitAndCall: TypedContractMethod<[
+        permit: BytesLike,
+        action: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "permitAndCall"): TypedContractMethod<[
+        permit: BytesLike,
+        action: BytesLike
+    ], [
+        void
+    ], "payable">;
+    filters: {};
+}

package/dist/typechain-types/contracts/PermitAndCall.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PermitAndCall.js.map

package/dist/typechain-types/contracts/PermitAndCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermitAndCall.js","sourceRoot":"","sources":["../../../typechain-types/contracts/PermitAndCall.ts"],"names":[],"mappings":""}

package/dist/typechain-types/contracts/index.d.ts

@@ -7,5 +7,5 @@ export type { mocks };
 import type * as tests from "./tests";
 export type { tests };
 export type { EthReceiver } from "./EthReceiver";
-export type { GasChecker } from "./GasChecker";
 export type { OnlyWethReceiver } from "./OnlyWethReceiver";
+export type { PermitAndCall } from "./PermitAndCall";

package/dist/typechain-types/contracts/{GasChecker.d.ts → libraries/BytesMemory.d.ts}

@@ -1,11 +1,11 @@
 import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
-import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../common";
-export interface GasCheckerInterface extends Interface {
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../common";
+export interface BytesMemoryInterface extends Interface {
 }
-export interface GasChecker extends BaseContract {
-    connect(runner?: ContractRunner | null): GasChecker;
+export interface BytesMemory extends BaseContract {
+    connect(runner?: ContractRunner | null): BytesMemory;
     waitForDeployment(): Promise<this>;
-    interface: GasCheckerInterface;
+    interface: BytesMemoryInterface;
     queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
     queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
     on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;

package/dist/typechain-types/contracts/{GasChecker.js → libraries/BytesMemory.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=GasChecker.js.map
+//# sourceMappingURL=BytesMemory.js.map

package/dist/typechain-types/contracts/libraries/BytesMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BytesMemory.js","sourceRoot":"","sources":["../../../../typechain-types/contracts/libraries/BytesMemory.ts"],"names":[],"mappings":""}

package/dist/typechain-types/contracts/libraries/BytesStorage.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../common";
+export interface BytesStorageInterface extends Interface {
+}
+export interface BytesStorage extends BaseContract {
+    connect(runner?: ContractRunner | null): BytesStorage;
+    waitForDeployment(): Promise<this>;
+    interface: BytesStorageInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

package/dist/typechain-types/contracts/libraries/BytesStorage.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=BytesStorage.js.map

package/dist/typechain-types/contracts/libraries/BytesStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BytesStorage.js","sourceRoot":"","sources":["../../../../typechain-types/contracts/libraries/BytesStorage.ts"],"names":[],"mappings":""}

package/dist/typechain-types/contracts/libraries/index.d.ts

@@ -1,4 +1,6 @@
 export type { AddressArray } from "./AddressArray";
+export type { BytesMemory } from "./BytesMemory";
+export type { BytesStorage } from "./BytesStorage";
 export type { RevertReasonParser } from "./RevertReasonParser";
 export type { SafeERC20 } from "./SafeERC20";
 export type { UniERC20 } from "./UniERC20";

package/dist/typechain-types/contracts/tests/StringUtilTest.d.ts

@@ -2,10 +2,10 @@ import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, I
 import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
 export interface StringUtilTestInterface extends Interface {
     getFunction(nameOrSignature: "toHex" | "toHexBytes" | "toHexNaive" | "toHexNaiveBytes"): FunctionFragment;
-    encodeFunctionData(functionFragment: "toHex", values: [BigNumberish, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "toHexBytes", values: [BytesLike, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "toHexNaive", values: [BigNumberish, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "toHexNaiveBytes", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "toHex", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "toHexBytes", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "toHexNaive", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "toHexNaiveBytes", values: [BytesLike]): string;
     decodeFunctionResult(functionFragment: "toHex", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "toHexBytes", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "toHexNaive", data: BytesLike): Result;
@@ -24,54 +24,14 @@ export interface StringUtilTest extends BaseContract {
     listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
     listeners(eventName?: string): Promise<Array<Listener>>;
     removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
-    toHex: TypedContractMethod<[
-        value: BigNumberish,
-        expectedGasCost: BigNumberish
-    ], [
-        string
-    ], "view">;
-    toHexBytes: TypedContractMethod<[
-        data: BytesLike,
-        expectedGasCost: BigNumberish
-    ], [
-        string
-    ], "view">;
-    toHexNaive: TypedContractMethod<[
-        value: BigNumberish,
-        expectedGasCost: BigNumberish
-    ], [
-        string
-    ], "view">;
-    toHexNaiveBytes: TypedContractMethod<[
-        data: BytesLike,
-        expectedGasCost: BigNumberish
-    ], [
-        string
-    ], "view">;
+    toHex: TypedContractMethod<[value: BigNumberish], [string], "view">;
+    toHexBytes: TypedContractMethod<[data: BytesLike], [string], "view">;
+    toHexNaive: TypedContractMethod<[value: BigNumberish], [string], "view">;
+    toHexNaiveBytes: TypedContractMethod<[data: BytesLike], [string], "view">;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    getFunction(nameOrSignature: "toHex"): TypedContractMethod<[
-        value: BigNumberish,
-        expectedGasCost: BigNumberish
-    ], [
-        string
-    ], "view">;
-    getFunction(nameOrSignature: "toHexBytes"): TypedContractMethod<[
-        data: BytesLike,
-        expectedGasCost: BigNumberish
-    ], [
-        string
-    ], "view">;
-    getFunction(nameOrSignature: "toHexNaive"): TypedContractMethod<[
-        value: BigNumberish,
-        expectedGasCost: BigNumberish
-    ], [
-        string
-    ], "view">;
-    getFunction(nameOrSignature: "toHexNaiveBytes"): TypedContractMethod<[
-        data: BytesLike,
-        expectedGasCost: BigNumberish
-    ], [
-        string
-    ], "view">;
+    getFunction(nameOrSignature: "toHex"): TypedContractMethod<[value: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "toHexBytes"): TypedContractMethod<[data: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "toHexNaive"): TypedContractMethod<[value: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "toHexNaiveBytes"): TypedContractMethod<[data: BytesLike], [string], "view">;
     filters: {};
 }

package/dist/typechain-types/contracts/tests/mocks/BytesMemoryMock.d.ts

@@ -0,0 +1,102 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export declare namespace BytesMemory {
+    type SliceStruct = {
+        pointer: BigNumberish;
+        length: BigNumberish;
+    };
+    type SliceStructOutput = [pointer: bigint, length: bigint] & {
+        pointer: bigint;
+        length: bigint;
+    };
+}
+export interface BytesMemoryMockInterface extends Interface {
+    getFunction(nameOrSignature: "slice" | "wrap" | "wrapAndUnwrap" | "wrapWithNonDefaultPointer" | "wrapWithNonDefaultPointerAndUnwrap" | "wrapWithSliceAndUnwrap"): FunctionFragment;
+    encodeFunctionData(functionFragment: "slice", values: [BytesMemory.SliceStruct, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "wrap", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "wrapAndUnwrap", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "wrapWithNonDefaultPointer", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "wrapWithNonDefaultPointerAndUnwrap", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "wrapWithSliceAndUnwrap", values: [BytesLike, BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "slice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrapAndUnwrap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrapWithNonDefaultPointer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrapWithNonDefaultPointerAndUnwrap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrapWithSliceAndUnwrap", data: BytesLike): Result;
+}
+export interface BytesMemoryMock extends BaseContract {
+    connect(runner?: ContractRunner | null): BytesMemoryMock;
+    waitForDeployment(): Promise<this>;
+    interface: BytesMemoryMockInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    slice: TypedContractMethod<[
+        data: BytesMemory.SliceStruct,
+        offset: BigNumberish,
+        size: BigNumberish
+    ], [
+        BytesMemory.SliceStructOutput
+    ], "view">;
+    wrap: TypedContractMethod<[
+        data: BytesLike
+    ], [
+        BytesMemory.SliceStructOutput
+    ], "view">;
+    wrapAndUnwrap: TypedContractMethod<[data: BytesLike], [string], "view">;
+    wrapWithNonDefaultPointer: TypedContractMethod<[
+        data: BytesLike,
+        n: BigNumberish
+    ], [
+        BytesMemory.SliceStructOutput
+    ], "view">;
+    wrapWithNonDefaultPointerAndUnwrap: TypedContractMethod<[
+        data: BytesLike,
+        n: BigNumberish
+    ], [
+        string
+    ], "view">;
+    wrapWithSliceAndUnwrap: TypedContractMethod<[
+        data: BytesLike,
+        offset: BigNumberish,
+        size: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "slice"): TypedContractMethod<[
+        data: BytesMemory.SliceStruct,
+        offset: BigNumberish,
+        size: BigNumberish
+    ], [
+        BytesMemory.SliceStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "wrap"): TypedContractMethod<[
+        data: BytesLike
+    ], [
+        BytesMemory.SliceStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "wrapAndUnwrap"): TypedContractMethod<[data: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "wrapWithNonDefaultPointer"): TypedContractMethod<[
+        data: BytesLike,
+        n: BigNumberish
+    ], [
+        BytesMemory.SliceStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "wrapWithNonDefaultPointerAndUnwrap"): TypedContractMethod<[data: BytesLike, n: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "wrapWithSliceAndUnwrap"): TypedContractMethod<[
+        data: BytesLike,
+        offset: BigNumberish,
+        size: BigNumberish
+    ], [
+        string
+    ], "view">;
+    filters: {};
+}

package/dist/typechain-types/contracts/tests/mocks/BytesMemoryMock.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=BytesMemoryMock.js.map

package/dist/typechain-types/contracts/tests/mocks/BytesMemoryMock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BytesMemoryMock.js","sourceRoot":"","sources":["../../../../../typechain-types/contracts/tests/mocks/BytesMemoryMock.ts"],"names":[],"mappings":""}

package/dist/typechain-types/contracts/tests/mocks/BytesStorageMock.d.ts

@@ -0,0 +1,77 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export declare namespace BytesStorage {
+    type SliceStruct = {
+        slot: BigNumberish;
+        offset: BigNumberish;
+        length: BigNumberish;
+    };
+    type SliceStructOutput = [
+        slot: bigint,
+        offset: bigint,
+        length: bigint
+    ] & {
+        slot: bigint;
+        offset: bigint;
+        length: bigint;
+    };
+}
+export interface BytesStorageMockInterface extends Interface {
+    getFunction(nameOrSignature: "setData" | "wrap" | "wrapAndCopy" | "wrapAndSlice" | "wrapWithSliceAndCopy"): FunctionFragment;
+    encodeFunctionData(functionFragment: "setData", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "wrap", values?: undefined): string;
+    encodeFunctionData(functionFragment: "wrapAndCopy", values?: undefined): string;
+    encodeFunctionData(functionFragment: "wrapAndSlice", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "wrapWithSliceAndCopy", values: [BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "setData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrapAndCopy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrapAndSlice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrapWithSliceAndCopy", data: BytesLike): Result;
+}
+export interface BytesStorageMock extends BaseContract {
+    connect(runner?: ContractRunner | null): BytesStorageMock;
+    waitForDeployment(): Promise<this>;
+    interface: BytesStorageMockInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    setData: TypedContractMethod<[data: BytesLike], [void], "nonpayable">;
+    wrap: TypedContractMethod<[], [BytesStorage.SliceStructOutput], "view">;
+    wrapAndCopy: TypedContractMethod<[], [string], "view">;
+    wrapAndSlice: TypedContractMethod<[
+        offset: BigNumberish,
+        size: BigNumberish
+    ], [
+        BytesStorage.SliceStructOutput
+    ], "view">;
+    wrapWithSliceAndCopy: TypedContractMethod<[
+        offset: BigNumberish,
+        size: BigNumberish
+    ], [
+        string
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "setData"): TypedContractMethod<[data: BytesLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "wrap"): TypedContractMethod<[], [BytesStorage.SliceStructOutput], "view">;
+    getFunction(nameOrSignature: "wrapAndCopy"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "wrapAndSlice"): TypedContractMethod<[
+        offset: BigNumberish,
+        size: BigNumberish
+    ], [
+        BytesStorage.SliceStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "wrapWithSliceAndCopy"): TypedContractMethod<[
+        offset: BigNumberish,
+        size: BigNumberish
+    ], [
+        string
+    ], "view">;
+    filters: {};
+}

package/dist/typechain-types/contracts/tests/mocks/BytesStorageMock.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=BytesStorageMock.js.map

package/dist/typechain-types/contracts/tests/mocks/BytesStorageMock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BytesStorageMock.js","sourceRoot":"","sources":["../../../../../typechain-types/contracts/tests/mocks/BytesStorageMock.ts"],"names":[],"mappings":""}