web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/test/token/ERC1155/ERC1155.test.js

@@ -0,0 +1,258 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { RevertType } = require('../../helpers/enums');
+const { zip } = require('../../helpers/iterate');
+const { shouldBehaveLikeERC1155 } = require('./ERC1155.behavior');
+
+const initialURI = 'https://token-cdn-domain/{id}.json';
+
+async function fixture() {
+  const [operator, holder, ...otherAccounts] = await ethers.getSigners();
+  const token = await ethers.deployContract('$ERC1155', [initialURI]);
+  return { token, operator, holder, otherAccounts };
+}
+
+describe('ERC1155', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  shouldBehaveLikeERC1155();
+
+  describe('internal functions', function () {
+    const tokenId = 1990n;
+    const mintValue = 9001n;
+    const burnValue = 3000n;
+
+    const tokenBatchIds = [2000n, 2010n, 2020n];
+    const mintValues = [5000n, 10000n, 42195n];
+    const burnValues = [5000n, 9001n, 195n];
+
+    const data = '0x12345678';
+
+    describe('_mint', function () {
+      it('reverts with a zero destination address', async function () {
+        await expect(this.token.$_mint(ethers.ZeroAddress, tokenId, mintValue, data))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InvalidReceiver')
+          .withArgs(ethers.ZeroAddress);
+      });
+
+      describe('with minted tokens', function () {
+        beforeEach(async function () {
+          this.tx = await this.token.connect(this.operator).$_mint(this.holder, tokenId, mintValue, data);
+        });
+
+        it('emits a TransferSingle event', async function () {
+          await expect(this.tx)
+            .to.emit(this.token, 'TransferSingle')
+            .withArgs(this.operator, ethers.ZeroAddress, this.holder, tokenId, mintValue);
+        });
+
+        it('credits the minted token value', async function () {
+          expect(await this.token.balanceOf(this.holder, tokenId)).to.equal(mintValue);
+        });
+      });
+    });
+
+    describe('_mintBatch', function () {
+      it('reverts with a zero destination address', async function () {
+        await expect(this.token.$_mintBatch(ethers.ZeroAddress, tokenBatchIds, mintValues, data))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InvalidReceiver')
+          .withArgs(ethers.ZeroAddress);
+      });
+
+      it('reverts if length of inputs do not match', async function () {
+        await expect(this.token.$_mintBatch(this.holder, tokenBatchIds, mintValues.slice(1), data))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InvalidArrayLength')
+          .withArgs(tokenBatchIds.length, mintValues.length - 1);
+
+        await expect(this.token.$_mintBatch(this.holder, tokenBatchIds.slice(1), mintValues, data))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InvalidArrayLength')
+          .withArgs(tokenBatchIds.length - 1, mintValues.length);
+      });
+
+      describe('with minted batch of tokens', function () {
+        beforeEach(async function () {
+          this.tx = await this.token.connect(this.operator).$_mintBatch(this.holder, tokenBatchIds, mintValues, data);
+        });
+
+        it('emits a TransferBatch event', async function () {
+          await expect(this.tx)
+            .to.emit(this.token, 'TransferBatch')
+            .withArgs(this.operator, ethers.ZeroAddress, this.holder, tokenBatchIds, mintValues);
+        });
+
+        it('credits the minted batch of tokens', async function () {
+          const holderBatchBalances = await this.token.balanceOfBatch(
+            tokenBatchIds.map(() => this.holder),
+            tokenBatchIds,
+          );
+
+          expect(holderBatchBalances).to.deep.equal(mintValues);
+        });
+      });
+    });
+
+    describe('_burn', function () {
+      it("reverts when burning the zero account's tokens", async function () {
+        await expect(this.token.$_burn(ethers.ZeroAddress, tokenId, mintValue))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InvalidSender')
+          .withArgs(ethers.ZeroAddress);
+      });
+
+      it('reverts when burning a non-existent token id', async function () {
+        await expect(this.token.$_burn(this.holder, tokenId, mintValue))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InsufficientBalance')
+          .withArgs(this.holder, 0, mintValue, tokenId);
+      });
+
+      it('reverts when burning more than available tokens', async function () {
+        await this.token.connect(this.operator).$_mint(this.holder, tokenId, mintValue, data);
+
+        await expect(this.token.$_burn(this.holder, tokenId, mintValue + 1n))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InsufficientBalance')
+          .withArgs(this.holder, mintValue, mintValue + 1n, tokenId);
+      });
+
+      describe('with minted-then-burnt tokens', function () {
+        beforeEach(async function () {
+          await this.token.$_mint(this.holder, tokenId, mintValue, data);
+          this.tx = await this.token.connect(this.operator).$_burn(this.holder, tokenId, burnValue);
+        });
+
+        it('emits a TransferSingle event', async function () {
+          await expect(this.tx)
+            .to.emit(this.token, 'TransferSingle')
+            .withArgs(this.operator, this.holder, ethers.ZeroAddress, tokenId, burnValue);
+        });
+
+        it('accounts for both minting and burning', async function () {
+          expect(await this.token.balanceOf(this.holder, tokenId)).to.equal(mintValue - burnValue);
+        });
+      });
+    });
+
+    describe('_burnBatch', function () {
+      it("reverts when burning the zero account's tokens", async function () {
+        await expect(this.token.$_burnBatch(ethers.ZeroAddress, tokenBatchIds, burnValues))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InvalidSender')
+          .withArgs(ethers.ZeroAddress);
+      });
+
+      it('reverts if length of inputs do not match', async function () {
+        await expect(this.token.$_burnBatch(this.holder, tokenBatchIds, burnValues.slice(1)))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InvalidArrayLength')
+          .withArgs(tokenBatchIds.length, burnValues.length - 1);
+
+        await expect(this.token.$_burnBatch(this.holder, tokenBatchIds.slice(1), burnValues))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InvalidArrayLength')
+          .withArgs(tokenBatchIds.length - 1, burnValues.length);
+      });
+
+      it('reverts when burning a non-existent token id', async function () {
+        await expect(this.token.$_burnBatch(this.holder, tokenBatchIds, burnValues))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InsufficientBalance')
+          .withArgs(this.holder, 0, burnValues[0], tokenBatchIds[0]);
+      });
+
+      describe('with minted-then-burnt tokens', function () {
+        beforeEach(async function () {
+          await this.token.$_mintBatch(this.holder, tokenBatchIds, mintValues, data);
+          this.tx = await this.token.connect(this.operator).$_burnBatch(this.holder, tokenBatchIds, burnValues);
+        });
+
+        it('emits a TransferBatch event', async function () {
+          await expect(this.tx)
+            .to.emit(this.token, 'TransferBatch')
+            .withArgs(this.operator, this.holder, ethers.ZeroAddress, tokenBatchIds, burnValues);
+        });
+
+        it('accounts for both minting and burning', async function () {
+          const holderBatchBalances = await this.token.balanceOfBatch(
+            tokenBatchIds.map(() => this.holder),
+            tokenBatchIds,
+          );
+
+          expect(holderBatchBalances).to.deep.equal(
+            zip(mintValues, burnValues).map(([mintValue, burnValue]) => mintValue - burnValue),
+          );
+        });
+      });
+    });
+
+    describe('_updateWithAcceptanceCheck', function () {
+      beforeEach(async function () {
+        const factory = await ethers.getContractFactory('$ERC1155ReceiverMock');
+        this.receiver = await ethers.deployContract('$ERC1155ReceiverMock', [
+          factory.interface.getFunction('onERC1155Received').selector,
+          factory.interface.getFunction('onERC1155BatchReceived').selector,
+          RevertType.None,
+        ]);
+      });
+
+      it('calls onERC1155Received when only one token is transferred', async function () {
+        await expect(
+          this.token.$_updateWithAcceptanceCheck(ethers.ZeroAddress, this.receiver, [tokenId], [mintValue], '0x'),
+        ).to.emit(this.receiver, 'Received');
+      });
+
+      it('calls onERC1155BatchReceived when only one token is transferred and batch flag is set to true', async function () {
+        await expect(
+          this.token.$_updateWithAcceptanceCheck(
+            ethers.ZeroAddress,
+            this.receiver,
+            [tokenId],
+            [mintValue],
+            '0x',
+            ethers.Typed.bool(true),
+          ),
+        ).to.emit(this.receiver, 'BatchReceived');
+      });
+
+      it('calls onERC1155BatchReceived when more than one token is transferred', async function () {
+        await expect(
+          this.token.$_updateWithAcceptanceCheck(ethers.ZeroAddress, this.receiver, tokenBatchIds, mintValues, '0x'),
+        ).to.emit(this.receiver, 'BatchReceived');
+      });
+    });
+
+    describe('_setApprovalForAll', function () {
+      it("reverts when adding an operator over the zero account's tokens", async function () {
+        await expect(this.token.$_setApprovalForAll(ethers.ZeroAddress, this.operator, true))
+          .to.be.revertedWithCustomError(this.token, 'ERC1155InvalidApprover')
+          .withArgs(ethers.ZeroAddress);
+      });
+    });
+  });
+
+  describe('ERC1155MetadataURI', function () {
+    const firstTokenID = 42n;
+    const secondTokenID = 1337n;
+
+    it('emits no URI event in constructor', async function () {
+      await expect(this.token.deploymentTransaction()).to.not.emit(this.token, 'URI');
+    });
+
+    it('sets the initial URI for all token types', async function () {
+      expect(await this.token.uri(firstTokenID)).to.equal(initialURI);
+      expect(await this.token.uri(secondTokenID)).to.equal(initialURI);
+    });
+
+    describe('_setURI', function () {
+      const newURI = 'https://token-cdn-domain/{locale}/{id}.json';
+
+      it('emits no URI event', async function () {
+        await expect(this.token.$_setURI(newURI)).to.not.emit(this.token, 'URI');
+      });
+
+      it('sets the new URI for all token types', async function () {
+        await this.token.$_setURI(newURI);
+
+        expect(await this.token.uri(firstTokenID)).to.equal(newURI);
+        expect(await this.token.uri(secondTokenID)).to.equal(newURI);
+      });
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/token/ERC1155/extensions/ERC1155Burnable.test.js

@@ -0,0 +1,66 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const ids = [42n, 1137n];
+const values = [3000n, 9902n];
+
+async function fixture() {
+  const [holder, operator, other] = await ethers.getSigners();
+
+  const token = await ethers.deployContract('$ERC1155Burnable', ['https://token-cdn-domain/{id}.json']);
+  await token.$_mint(holder, ids[0], values[0], '0x');
+  await token.$_mint(holder, ids[1], values[1], '0x');
+
+  return { token, holder, operator, other };
+}
+
+describe('ERC1155Burnable', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('burn', function () {
+    it('holder can burn their tokens', async function () {
+      await this.token.connect(this.holder).burn(this.holder, ids[0], values[0] - 1n);
+
+      expect(await this.token.balanceOf(this.holder, ids[0])).to.equal(1n);
+    });
+
+    it("approved operators can burn the holder's tokens", async function () {
+      await this.token.connect(this.holder).setApprovalForAll(this.operator, true);
+      await this.token.connect(this.operator).burn(this.holder, ids[0], values[0] - 1n);
+
+      expect(await this.token.balanceOf(this.holder, ids[0])).to.equal(1n);
+    });
+
+    it("unapproved accounts cannot burn the holder's tokens", async function () {
+      await expect(this.token.connect(this.other).burn(this.holder, ids[0], values[0] - 1n))
+        .to.be.revertedWithCustomError(this.token, 'ERC1155MissingApprovalForAll')
+        .withArgs(this.other, this.holder);
+    });
+  });
+
+  describe('burnBatch', function () {
+    it('holder can burn their tokens', async function () {
+      await this.token.connect(this.holder).burnBatch(this.holder, ids, [values[0] - 1n, values[1] - 2n]);
+
+      expect(await this.token.balanceOf(this.holder, ids[0])).to.equal(1n);
+      expect(await this.token.balanceOf(this.holder, ids[1])).to.equal(2n);
+    });
+
+    it("approved operators can burn the holder's tokens", async function () {
+      await this.token.connect(this.holder).setApprovalForAll(this.operator, true);
+      await this.token.connect(this.operator).burnBatch(this.holder, ids, [values[0] - 1n, values[1] - 2n]);
+
+      expect(await this.token.balanceOf(this.holder, ids[0])).to.equal(1n);
+      expect(await this.token.balanceOf(this.holder, ids[1])).to.equal(2n);
+    });
+
+    it("unapproved accounts cannot burn the holder's tokens", async function () {
+      await expect(this.token.connect(this.other).burnBatch(this.holder, ids, [values[0] - 1n, values[1] - 2n]))
+        .to.be.revertedWithCustomError(this.token, 'ERC1155MissingApprovalForAll')
+        .withArgs(this.other, this.holder);
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/token/ERC1155/extensions/ERC1155Pausable.test.js

@@ -0,0 +1,105 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+async function fixture() {
+  const [holder, operator, receiver, other] = await ethers.getSigners();
+  const token = await ethers.deployContract('$ERC1155Pausable', ['https://token-cdn-domain/{id}.json']);
+  return { token, holder, operator, receiver, other };
+}
+
+describe('ERC1155Pausable', function () {
+  const firstTokenId = 37n;
+  const firstTokenValue = 42n;
+  const secondTokenId = 19842n;
+  const secondTokenValue = 23n;
+
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('when token is paused', function () {
+    beforeEach(async function () {
+      await this.token.connect(this.holder).setApprovalForAll(this.operator, true);
+      await this.token.$_mint(this.holder, firstTokenId, firstTokenValue, '0x');
+      await this.token.$_pause();
+    });
+
+    it('reverts when trying to safeTransferFrom from holder', async function () {
+      await expect(
+        this.token
+          .connect(this.holder)
+          .safeTransferFrom(this.holder, this.receiver, firstTokenId, firstTokenValue, '0x'),
+      ).to.be.revertedWithCustomError(this.token, 'EnforcedPause');
+    });
+
+    it('reverts when trying to safeTransferFrom from operator', async function () {
+      await expect(
+        this.token
+          .connect(this.operator)
+          .safeTransferFrom(this.holder, this.receiver, firstTokenId, firstTokenValue, '0x'),
+      ).to.be.revertedWithCustomError(this.token, 'EnforcedPause');
+    });
+
+    it('reverts when trying to safeBatchTransferFrom from holder', async function () {
+      await expect(
+        this.token
+          .connect(this.holder)
+          .safeBatchTransferFrom(this.holder, this.receiver, [firstTokenId], [firstTokenValue], '0x'),
+      ).to.be.revertedWithCustomError(this.token, 'EnforcedPause');
+    });
+
+    it('reverts when trying to safeBatchTransferFrom from operator', async function () {
+      await expect(
+        this.token
+          .connect(this.operator)
+          .safeBatchTransferFrom(this.holder, this.receiver, [firstTokenId], [firstTokenValue], '0x'),
+      ).to.be.revertedWithCustomError(this.token, 'EnforcedPause');
+    });
+
+    it('reverts when trying to mint', async function () {
+      await expect(this.token.$_mint(this.holder, secondTokenId, secondTokenValue, '0x')).to.be.revertedWithCustomError(
+        this.token,
+        'EnforcedPause',
+      );
+    });
+
+    it('reverts when trying to mintBatch', async function () {
+      await expect(
+        this.token.$_mintBatch(this.holder, [secondTokenId], [secondTokenValue], '0x'),
+      ).to.be.revertedWithCustomError(this.token, 'EnforcedPause');
+    });
+
+    it('reverts when trying to burn', async function () {
+      await expect(this.token.$_burn(this.holder, firstTokenId, firstTokenValue)).to.be.revertedWithCustomError(
+        this.token,
+        'EnforcedPause',
+      );
+    });
+
+    it('reverts when trying to burnBatch', async function () {
+      await expect(
+        this.token.$_burnBatch(this.holder, [firstTokenId], [firstTokenValue]),
+      ).to.be.revertedWithCustomError(this.token, 'EnforcedPause');
+    });
+
+    describe('setApprovalForAll', function () {
+      it('approves an operator', async function () {
+        await this.token.connect(this.holder).setApprovalForAll(this.other, true);
+        expect(await this.token.isApprovedForAll(this.holder, this.other)).to.be.true;
+      });
+    });
+
+    describe('balanceOf', function () {
+      it('returns the token value owned by the given address', async function () {
+        expect(await this.token.balanceOf(this.holder, firstTokenId)).to.equal(firstTokenValue);
+      });
+    });
+
+    describe('isApprovedForAll', function () {
+      it('returns the approval of the operator', async function () {
+        expect(await this.token.isApprovedForAll(this.holder, this.operator)).to.be.true;
+      });
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/token/ERC1155/extensions/ERC1155Supply.test.js

@@ -0,0 +1,119 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+async function fixture() {
+  const [holder] = await ethers.getSigners();
+  const token = await ethers.deployContract('$ERC1155Supply', ['https://token-cdn-domain/{id}.json']);
+  return { token, holder };
+}
+
+describe('ERC1155Supply', function () {
+  const firstTokenId = 37n;
+  const firstTokenValue = 42n;
+  const secondTokenId = 19842n;
+  const secondTokenValue = 23n;
+
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('before mint', function () {
+    it('exist', async function () {
+      expect(await this.token.exists(firstTokenId)).to.be.false;
+    });
+
+    it('totalSupply', async function () {
+      expect(await this.token.totalSupply(ethers.Typed.uint256(firstTokenId))).to.equal(0n);
+      expect(await this.token.totalSupply()).to.equal(0n);
+    });
+  });
+
+  describe('after mint', function () {
+    describe('single', function () {
+      beforeEach(async function () {
+        await this.token.$_mint(this.holder, firstTokenId, firstTokenValue, '0x');
+      });
+
+      it('exist', async function () {
+        expect(await this.token.exists(firstTokenId)).to.be.true;
+      });
+
+      it('totalSupply', async function () {
+        expect(await this.token.totalSupply(ethers.Typed.uint256(firstTokenId))).to.equal(firstTokenValue);
+        expect(await this.token.totalSupply()).to.equal(firstTokenValue);
+      });
+    });
+
+    describe('batch', function () {
+      beforeEach(async function () {
+        await this.token.$_mintBatch(
+          this.holder,
+          [firstTokenId, secondTokenId],
+          [firstTokenValue, secondTokenValue],
+          '0x',
+        );
+      });
+
+      it('exist', async function () {
+        expect(await this.token.exists(firstTokenId)).to.be.true;
+        expect(await this.token.exists(secondTokenId)).to.be.true;
+      });
+
+      it('totalSupply', async function () {
+        expect(await this.token.totalSupply(ethers.Typed.uint256(firstTokenId))).to.equal(firstTokenValue);
+        expect(await this.token.totalSupply(ethers.Typed.uint256(secondTokenId))).to.equal(secondTokenValue);
+        expect(await this.token.totalSupply()).to.equal(firstTokenValue + secondTokenValue);
+      });
+    });
+  });
+
+  describe('after burn', function () {
+    describe('single', function () {
+      beforeEach(async function () {
+        await this.token.$_mint(this.holder, firstTokenId, firstTokenValue, '0x');
+        await this.token.$_burn(this.holder, firstTokenId, firstTokenValue);
+      });
+
+      it('exist', async function () {
+        expect(await this.token.exists(firstTokenId)).to.be.false;
+      });
+
+      it('totalSupply', async function () {
+        expect(await this.token.totalSupply(ethers.Typed.uint256(firstTokenId))).to.equal(0n);
+        expect(await this.token.totalSupply()).to.equal(0n);
+      });
+    });
+
+    describe('batch', function () {
+      beforeEach(async function () {
+        await this.token.$_mintBatch(
+          this.holder,
+          [firstTokenId, secondTokenId],
+          [firstTokenValue, secondTokenValue],
+          '0x',
+        );
+        await this.token.$_burnBatch(this.holder, [firstTokenId, secondTokenId], [firstTokenValue, secondTokenValue]);
+      });
+
+      it('exist', async function () {
+        expect(await this.token.exists(firstTokenId)).to.be.false;
+        expect(await this.token.exists(secondTokenId)).to.be.false;
+      });
+
+      it('totalSupply', async function () {
+        expect(await this.token.totalSupply(ethers.Typed.uint256(firstTokenId))).to.equal(0n);
+        expect(await this.token.totalSupply(ethers.Typed.uint256(secondTokenId))).to.equal(0n);
+        expect(await this.token.totalSupply()).to.equal(0n);
+      });
+    });
+  });
+
+  describe('other', function () {
+    it('supply unaffected by no-op', async function () {
+      await this.token.$_update(ethers.ZeroAddress, ethers.ZeroAddress, [firstTokenId], [firstTokenValue]);
+      expect(await this.token.totalSupply(ethers.Typed.uint256(firstTokenId))).to.equal(0n);
+      expect(await this.token.totalSupply()).to.equal(0n);
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/token/ERC1155/extensions/ERC1155URIStorage.test.js

@@ -0,0 +1,70 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const erc1155Uri = 'https://token.com/nfts/';
+const baseUri = 'https://token.com/';
+const tokenId = 1n;
+const value = 3000n;
+
+describe('ERC1155URIStorage', function () {
+  describe('with base uri set', function () {
+    async function fixture() {
+      const [holder] = await ethers.getSigners();
+
+      const token = await ethers.deployContract('$ERC1155URIStorage', [erc1155Uri]);
+      await token.$_setBaseURI(baseUri);
+      await token.$_mint(holder, tokenId, value, '0x');
+
+      return { token, holder };
+    }
+
+    beforeEach(async function () {
+      Object.assign(this, await loadFixture(fixture));
+    });
+
+    it('can request the token uri, returning the erc1155 uri if no token uri was set', async function () {
+      expect(await this.token.uri(tokenId)).to.equal(erc1155Uri);
+    });
+
+    it('can request the token uri, returning the concatenated uri if a token uri was set', async function () {
+      const tokenUri = '1234/';
+      const expectedUri = `${baseUri}${tokenUri}`;
+
+      await expect(this.token.$_setURI(ethers.Typed.uint256(tokenId), tokenUri))
+        .to.emit(this.token, 'URI')
+        .withArgs(expectedUri, tokenId);
+
+      expect(await this.token.uri(tokenId)).to.equal(expectedUri);
+    });
+  });
+
+  describe('with base uri set to the empty string', function () {
+    async function fixture() {
+      const [holder] = await ethers.getSigners();
+
+      const token = await ethers.deployContract('$ERC1155URIStorage', ['']);
+      await token.$_mint(holder, tokenId, value, '0x');
+
+      return { token, holder };
+    }
+
+    beforeEach(async function () {
+      Object.assign(this, await loadFixture(fixture));
+    });
+
+    it('can request the token uri, returning an empty string if no token uri was set', async function () {
+      expect(await this.token.uri(tokenId)).to.equal('');
+    });
+
+    it('can request the token uri, returning the token uri if a token uri was set', async function () {
+      const tokenUri = 'ipfs://1234/';
+
+      await expect(this.token.$_setURI(ethers.Typed.uint256(tokenId), tokenUri))
+        .to.emit(this.token, 'URI')
+        .withArgs(tokenUri, tokenId);
+
+      expect(await this.token.uri(tokenId)).to.equal(tokenUri);
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/token/ERC1155/utils/ERC1155Holder.test.js

@@ -0,0 +1,56 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { shouldSupportInterfaces } = require('../../../utils/introspection/SupportsInterface.behavior');
+
+const ids = [1n, 2n, 3n];
+const values = [1000n, 2000n, 3000n];
+const data = '0x12345678';
+
+async function fixture() {
+  const [owner] = await ethers.getSigners();
+
+  const token = await ethers.deployContract('$ERC1155', ['https://token-cdn-domain/{id}.json']);
+  const mock = await ethers.deployContract('$ERC1155Holder');
+
+  await token.$_mintBatch(owner, ids, values, '0x');
+
+  return { owner, token, mock };
+}
+
+describe('ERC1155Holder', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  shouldSupportInterfaces(['ERC1155Receiver']);
+
+  it('receives ERC1155 tokens from a single ID', async function () {
+    await this.token.connect(this.owner).safeTransferFrom(this.owner, this.mock, ids[0], values[0], data);
+
+    expect(await this.token.balanceOf(this.mock, ids[0])).to.equal(values[0]);
+
+    for (let i = 1; i < ids.length; i++) {
+      expect(await this.token.balanceOf(this.mock, ids[i])).to.equal(0n);
+    }
+  });
+
+  it('receives ERC1155 tokens from a multiple IDs', async function () {
+    expect(
+      await this.token.balanceOfBatch(
+        ids.map(() => this.mock),
+        ids,
+      ),
+    ).to.deep.equal(ids.map(() => 0n));
+
+    await this.token.connect(this.owner).safeBatchTransferFrom(this.owner, this.mock, ids, values, data);
+
+    expect(
+      await this.token.balanceOfBatch(
+        ids.map(() => this.mock),
+        ids,
+      ),
+    ).to.deep.equal(values);
+  });
+});