polkamarkets-js 3.1.1 → 3.1.2

package/lib/openzeppelin-contracts.git/test/helpers/eip712.js

@@ -0,0 +1,30 @@
+const ethSigUtil = require('eth-sig-util');
+
+const EIP712Domain = [
+  { name: 'name', type: 'string' },
+  { name: 'version', type: 'string' },
+  { name: 'chainId', type: 'uint256' },
+  { name: 'verifyingContract', type: 'address' },
+];
+
+const Permit = [
+  { name: 'owner', type: 'address' },
+  { name: 'spender', type: 'address' },
+  { name: 'value', type: 'uint256' },
+  { name: 'nonce', type: 'uint256' },
+  { name: 'deadline', type: 'uint256' },
+];
+
+async function domainSeparator (name, version, chainId, verifyingContract) {
+  return '0x' + ethSigUtil.TypedDataUtils.hashStruct(
+    'EIP712Domain',
+    { name, version, chainId, verifyingContract },
+    { EIP712Domain },
+  ).toString('hex');
+}
+
+module.exports = {
+  EIP712Domain,
+  Permit,
+  domainSeparator,
+};

package/lib/openzeppelin-contracts.git/test/helpers/enums.js

@@ -0,0 +1,29 @@
+const { BN } = require('@openzeppelin/test-helpers');
+
+function Enum (...options) {
+  return Object.fromEntries(options.map((key, i) => [ key, new BN(i) ]));
+}
+
+module.exports = {
+  Enum,
+  ProposalState: Enum(
+    'Pending',
+    'Active',
+    'Canceled',
+    'Defeated',
+    'Succeeded',
+    'Queued',
+    'Expired',
+    'Executed',
+  ),
+  VoteType: Enum(
+    'Against',
+    'For',
+    'Abstain',
+  ),
+  Rounding: Enum(
+    'Down',
+    'Up',
+    'Zero',
+  ),
+};

package/lib/openzeppelin-contracts.git/test/helpers/erc1967.js

@@ -0,0 +1,24 @@
+const ImplementationLabel = 'eip1967.proxy.implementation';
+const AdminLabel = 'eip1967.proxy.admin';
+const BeaconLabel = 'eip1967.proxy.beacon';
+
+function labelToSlot (label) {
+  return '0x' + web3.utils.toBN(web3.utils.keccak256(label)).subn(1).toString(16);
+}
+
+function getSlot (address, slot) {
+  return web3.eth.getStorageAt(
+    web3.utils.isAddress(address) ? address : address.address,
+    web3.utils.isHex(slot) ? slot : labelToSlot(slot),
+  );
+}
+
+module.exports = {
+  ImplementationLabel,
+  AdminLabel,
+  BeaconLabel,
+  ImplementationSlot: labelToSlot(ImplementationLabel),
+  AdminSlot: labelToSlot(AdminLabel),
+  BeaconSlot: labelToSlot(BeaconLabel),
+  getSlot,
+};

package/lib/openzeppelin-contracts.git/test/helpers/governance.js

@@ -0,0 +1,211 @@
+const { time } = require('@openzeppelin/test-helpers');
+
+function zip (...args) {
+  return Array(Math.max(...args.map(array => array.length)))
+    .fill()
+    .map((_, i) => args.map(array => array[i]));
+}
+
+function concatHex (...args) {
+  return web3.utils.bytesToHex([].concat(...args.map(h => web3.utils.hexToBytes(h || '0x'))));
+}
+
+function concatOpts (args, opts = null) {
+  return opts ? args.concat(opts) : args;
+}
+
+class GovernorHelper {
+  constructor (governor) {
+    this.governor = governor;
+  }
+
+  delegate (delegation = {}, opts = null) {
+    return Promise.all([
+      delegation.token.delegate(delegation.to, { from: delegation.to }),
+      delegation.value &&
+        delegation.token.transfer(...concatOpts([ delegation.to, delegation.value ]), opts),
+      delegation.tokenId &&
+        delegation.token.ownerOf(delegation.tokenId).then(owner =>
+          delegation.token.transferFrom(...concatOpts([ owner, delegation.to, delegation.tokenId ], opts)),
+        ),
+    ]);
+  }
+
+  propose (opts = null) {
+    const proposal = this.currentProposal;
+
+    return this.governor.methods[
+      proposal.useCompatibilityInterface
+        ? 'propose(address[],uint256[],string[],bytes[],string)'
+        : 'propose(address[],uint256[],bytes[],string)'
+    ](...concatOpts(proposal.fullProposal, opts));
+  }
+
+  queue (opts = null) {
+    const proposal = this.currentProposal;
+
+    return proposal.useCompatibilityInterface
+      ? this.governor.methods['queue(uint256)'](...concatOpts(
+        [ proposal.id ],
+        opts,
+      ))
+      : this.governor.methods['queue(address[],uint256[],bytes[],bytes32)'](...concatOpts(
+        proposal.shortProposal,
+        opts,
+      ));
+  }
+
+  execute (opts = null) {
+    const proposal = this.currentProposal;
+
+    return proposal.useCompatibilityInterface
+      ? this.governor.methods['execute(uint256)'](...concatOpts(
+        [ proposal.id ],
+        opts,
+      ))
+      : this.governor.methods['execute(address[],uint256[],bytes[],bytes32)'](...concatOpts(
+        proposal.shortProposal,
+        opts,
+      ));
+  }
+
+  cancel (opts = null) {
+    const proposal = this.currentProposal;
+
+    return proposal.useCompatibilityInterface
+      ? this.governor.methods['cancel(uint256)'](...concatOpts(
+        [ proposal.id ],
+        opts,
+      ))
+      : this.governor.methods['cancel(address[],uint256[],bytes[],bytes32)'](...concatOpts(
+        proposal.shortProposal,
+        opts,
+      ));
+  }
+
+  vote (vote = {}, opts = null) {
+    const proposal = this.currentProposal;
+
+    return vote.signature
+      // if signature, and either params or reason →
+      ? vote.params || vote.reason
+        ? vote.signature({
+          proposalId: proposal.id,
+          support: vote.support,
+          reason: vote.reason || '',
+          params: vote.params || '',
+        }).then(({ v, r, s }) => this.governor.castVoteWithReasonAndParamsBySig(...concatOpts(
+          [ proposal.id, vote.support, vote.reason || '', vote.params || '', v, r, s ],
+          opts,
+        )))
+        : vote.signature({
+          proposalId: proposal.id,
+          support: vote.support,
+        }).then(({ v, r, s }) => this.governor.castVoteBySig(...concatOpts(
+          [ proposal.id, vote.support, v, r, s ],
+          opts,
+        )))
+      : vote.params
+        // otherwise if params
+        ? this.governor.castVoteWithReasonAndParams(...concatOpts(
+          [ proposal.id, vote.support, vote.reason || '', vote.params ],
+          opts,
+        ))
+        : vote.reason
+          // otherwise if reason
+          ? this.governor.castVoteWithReason(...concatOpts(
+            [ proposal.id, vote.support, vote.reason ],
+            opts,
+          ))
+          : this.governor.castVote(...concatOpts(
+            [ proposal.id, vote.support ],
+            opts,
+          ));
+  }
+
+  waitForSnapshot (offset = 0) {
+    const proposal = this.currentProposal;
+    return this.governor.proposalSnapshot(proposal.id)
+      .then(blockNumber => time.advanceBlockTo(blockNumber.addn(offset)));
+  }
+
+  waitForDeadline (offset = 0) {
+    const proposal = this.currentProposal;
+    return this.governor.proposalDeadline(proposal.id)
+      .then(blockNumber => time.advanceBlockTo(blockNumber.addn(offset)));
+  }
+
+  waitForEta (offset = 0) {
+    const proposal = this.currentProposal;
+    return this.governor.proposalEta(proposal.id)
+      .then(timestamp => time.increaseTo(timestamp.addn(offset)));
+  }
+
+  /**
+   * Specify a proposal either as
+   * 1) an array of objects [{ target, value, data, signature? }]
+   * 2) an object of arrays { targets: [], values: [], data: [], signatures?: [] }
+   */
+  setProposal (actions, description) {
+    let targets, values, signatures, data, useCompatibilityInterface;
+
+    if (Array.isArray(actions)) {
+      useCompatibilityInterface = actions.some(a => 'signature' in a);
+      targets = actions.map(a => a.target);
+      values = actions.map(a => a.value || '0');
+      signatures = actions.map(a => a.signature || '');
+      data = actions.map(a => a.data || '0x');
+    } else {
+      useCompatibilityInterface = Array.isArray(actions.signatures);
+      ({ targets, values, signatures = [], data } = actions);
+    }
+
+    const fulldata = zip(signatures.map(s => s && web3.eth.abi.encodeFunctionSignature(s)), data)
+      .map(hexs => concatHex(...hexs));
+
+    const descriptionHash = web3.utils.keccak256(description);
+
+    // condensed version for queueing end executing
+    const shortProposal = [
+      targets,
+      values,
+      fulldata,
+      descriptionHash,
+    ];
+
+    // full version for proposing
+    const fullProposal = [
+      targets,
+      values,
+      ...(useCompatibilityInterface ? [ signatures ] : []),
+      data,
+      description,
+    ];
+
+    // proposal id
+    const id = web3.utils.toBN(web3.utils.keccak256(web3.eth.abi.encodeParameters(
+      [ 'address[]', 'uint256[]', 'bytes[]', 'bytes32' ],
+      shortProposal,
+    )));
+
+    this.currentProposal = {
+      id,
+      targets,
+      values,
+      signatures,
+      data,
+      fulldata,
+      description,
+      descriptionHash,
+      shortProposal,
+      fullProposal,
+      useCompatibilityInterface,
+    };
+
+    return this.currentProposal;
+  }
+}
+
+module.exports = {
+  GovernorHelper,
+};

package/lib/openzeppelin-contracts.git/test/helpers/sign.js

@@ -0,0 +1,47 @@
+function toEthSignedMessageHash (messageHex) {
+  const messageBuffer = Buffer.from(messageHex.substring(2), 'hex');
+  const prefix = Buffer.from(`\u0019Ethereum Signed Message:\n${messageBuffer.length}`);
+  return web3.utils.sha3(Buffer.concat([prefix, messageBuffer]));
+}
+
+/**
+ * Create a signer between a contract and a signer for a voucher of method, args, and redeemer
+ * Note that `method` is the web3 method, not the truffle-contract method
+ * @param contract TruffleContract
+ * @param signer address
+ * @param redeemer address
+ * @param methodName string
+ * @param methodArgs any[]
+ */
+const getSignFor = (contract, signer) => (redeemer, methodName, methodArgs = []) => {
+  const parts = [
+    contract.address,
+    redeemer,
+  ];
+
+  const REAL_SIGNATURE_SIZE = 2 * 65; // 65 bytes in hexadecimal string length
+  const PADDED_SIGNATURE_SIZE = 2 * 96; // 96 bytes in hexadecimal string length
+  const DUMMY_SIGNATURE = `0x${web3.utils.padLeft('', REAL_SIGNATURE_SIZE)}`;
+
+  // if we have a method, add it to the parts that we're signing
+  if (methodName) {
+    if (methodArgs.length > 0) {
+      parts.push(
+        contract.contract.methods[methodName](...methodArgs.concat([DUMMY_SIGNATURE])).encodeABI()
+          .slice(0, -1 * PADDED_SIGNATURE_SIZE),
+      );
+    } else {
+      const abi = contract.abi.find(abi => abi.name === methodName);
+      parts.push(abi.signature);
+    }
+  }
+
+  // return the signature of the "Ethereum Signed Message" hash of the hash of `parts`
+  const messageHex = web3.utils.soliditySha3(...parts);
+  return web3.eth.sign(messageHex, signer);
+};
+
+module.exports = {
+  toEthSignedMessageHash,
+  getSignFor,
+};

package/lib/openzeppelin-contracts.git/test/helpers/txpool.js

@@ -0,0 +1,40 @@
+const { network } = require('hardhat');
+const { promisify } = require('util');
+
+const queue = promisify(setImmediate);
+
+async function countPendingTransactions () {
+  return parseInt(
+    await network.provider.send('eth_getBlockTransactionCountByNumber', ['pending']),
+  );
+}
+
+async function batchInBlock (txs) {
+  try {
+    // disable auto-mining
+    await network.provider.send('evm_setAutomine', [false]);
+    // send all transactions
+    const promises = txs.map(fn => fn());
+    // wait for node to have all pending transactions
+    while (txs.length > await countPendingTransactions()) {
+      await queue();
+    }
+    // mine one block
+    await network.provider.send('evm_mine');
+    // fetch receipts
+    const receipts = await Promise.all(promises);
+    // Sanity check, all tx should be in the same block
+    const minedBlocks = new Set(receipts.map(({ receipt }) => receipt.blockNumber));
+    expect(minedBlocks.size).to.equal(1);
+
+    return receipts;
+  } finally {
+    // enable auto-mining
+    await network.provider.send('evm_setAutomine', [true]);
+  }
+}
+
+module.exports = {
+  countPendingTransactions,
+  batchInBlock,
+};

package/lib/openzeppelin-contracts.git/test/metatx/ERC2771Context.test.js

@@ -0,0 +1,109 @@
+const ethSigUtil = require('eth-sig-util');
+const Wallet = require('ethereumjs-wallet').default;
+const { EIP712Domain } = require('../helpers/eip712');
+
+const { expectEvent } = require('@openzeppelin/test-helpers');
+const { expect } = require('chai');
+
+const ERC2771ContextMock = artifacts.require('ERC2771ContextMock');
+const MinimalForwarder = artifacts.require('MinimalForwarder');
+const ContextMockCaller = artifacts.require('ContextMockCaller');
+
+const { shouldBehaveLikeRegularContext } = require('../utils/Context.behavior');
+
+const name = 'MinimalForwarder';
+const version = '0.0.1';
+
+contract('ERC2771Context', function (accounts) {
+  beforeEach(async function () {
+    this.forwarder = await MinimalForwarder.new();
+    this.recipient = await ERC2771ContextMock.new(this.forwarder.address);
+
+    this.domain = {
+      name,
+      version,
+      chainId: await web3.eth.getChainId(),
+      verifyingContract: this.forwarder.address,
+    };
+    this.types = {
+      EIP712Domain,
+      ForwardRequest: [
+        { name: 'from', type: 'address' },
+        { name: 'to', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'gas', type: 'uint256' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'data', type: 'bytes' },
+      ],
+    };
+  });
+
+  it('recognize trusted forwarder', async function () {
+    expect(await this.recipient.isTrustedForwarder(this.forwarder.address));
+  });
+
+  context('when called directly', function () {
+    beforeEach(async function () {
+      this.context = this.recipient; // The Context behavior expects the contract in this.context
+      this.caller = await ContextMockCaller.new();
+    });
+
+    shouldBehaveLikeRegularContext(...accounts);
+  });
+
+  context('when receiving a relayed call', function () {
+    beforeEach(async function () {
+      this.wallet = Wallet.generate();
+      this.sender = web3.utils.toChecksumAddress(this.wallet.getAddressString());
+      this.data = {
+        types: this.types,
+        domain: this.domain,
+        primaryType: 'ForwardRequest',
+      };
+    });
+
+    describe('msgSender', function () {
+      it('returns the relayed transaction original sender', async function () {
+        const data = this.recipient.contract.methods.msgSender().encodeABI();
+
+        const req = {
+          from: this.sender,
+          to: this.recipient.address,
+          value: '0',
+          gas: '100000',
+          nonce: (await this.forwarder.getNonce(this.sender)).toString(),
+          data,
+        };
+
+        const sign = ethSigUtil.signTypedMessage(this.wallet.getPrivateKey(), { data: { ...this.data, message: req } });
+        expect(await this.forwarder.verify(req, sign)).to.equal(true);
+
+        const { tx } = await this.forwarder.execute(req, sign);
+        await expectEvent.inTransaction(tx, ERC2771ContextMock, 'Sender', { sender: this.sender });
+      });
+    });
+
+    describe('msgData', function () {
+      it('returns the relayed transaction original data', async function () {
+        const integerValue = '42';
+        const stringValue = 'OpenZeppelin';
+        const data = this.recipient.contract.methods.msgData(integerValue, stringValue).encodeABI();
+
+        const req = {
+          from: this.sender,
+          to: this.recipient.address,
+          value: '0',
+          gas: '100000',
+          nonce: (await this.forwarder.getNonce(this.sender)).toString(),
+          data,
+        };
+
+        const sign = ethSigUtil.signTypedMessage(this.wallet.getPrivateKey(), { data: { ...this.data, message: req } });
+        expect(await this.forwarder.verify(req, sign)).to.equal(true);
+
+        const { tx } = await this.forwarder.execute(req, sign);
+        await expectEvent.inTransaction(tx, ERC2771ContextMock, 'Data', { data, integerValue, stringValue });
+      });
+    });
+  });
+});

package/lib/openzeppelin-contracts.git/test/metatx/MinimalForwarder.test.js

@@ -0,0 +1,184 @@
+const ethSigUtil = require('eth-sig-util');
+const Wallet = require('ethereumjs-wallet').default;
+const { EIP712Domain } = require('../helpers/eip712');
+
+const { expectRevert, constants } = require('@openzeppelin/test-helpers');
+const { expect } = require('chai');
+
+const MinimalForwarder = artifacts.require('MinimalForwarder');
+const CallReceiverMock = artifacts.require('CallReceiverMock');
+
+const name = 'MinimalForwarder';
+const version = '0.0.1';
+
+contract('MinimalForwarder', function (accounts) {
+  beforeEach(async function () {
+    this.forwarder = await MinimalForwarder.new();
+    this.domain = {
+      name,
+      version,
+      chainId: await web3.eth.getChainId(),
+      verifyingContract: this.forwarder.address,
+    };
+    this.types = {
+      EIP712Domain,
+      ForwardRequest: [
+        { name: 'from', type: 'address' },
+        { name: 'to', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'gas', type: 'uint256' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'data', type: 'bytes' },
+      ],
+    };
+  });
+
+  context('with message', function () {
+    beforeEach(async function () {
+      this.wallet = Wallet.generate();
+      this.sender = web3.utils.toChecksumAddress(this.wallet.getAddressString());
+      this.req = {
+        from: this.sender,
+        to: constants.ZERO_ADDRESS,
+        value: '0',
+        gas: '100000',
+        nonce: Number(await this.forwarder.getNonce(this.sender)),
+        data: '0x',
+      };
+      this.sign = () => ethSigUtil.signTypedMessage(
+        this.wallet.getPrivateKey(),
+        {
+          data: {
+            types: this.types,
+            domain: this.domain,
+            primaryType: 'ForwardRequest',
+            message: this.req,
+          },
+        },
+      );
+    });
+
+    context('verify', function () {
+      context('valid signature', function () {
+        beforeEach(async function () {
+          expect(await this.forwarder.getNonce(this.req.from))
+            .to.be.bignumber.equal(web3.utils.toBN(this.req.nonce));
+        });
+
+        it('success', async function () {
+          expect(await this.forwarder.verify(this.req, this.sign())).to.be.equal(true);
+        });
+
+        afterEach(async function () {
+          expect(await this.forwarder.getNonce(this.req.from))
+            .to.be.bignumber.equal(web3.utils.toBN(this.req.nonce));
+        });
+      });
+
+      context('invalid signature', function () {
+        it('tampered from', async function () {
+          expect(await this.forwarder.verify({ ...this.req, from: accounts[0] }, this.sign()))
+            .to.be.equal(false);
+        });
+        it('tampered to', async function () {
+          expect(await this.forwarder.verify({ ...this.req, to: accounts[0] }, this.sign()))
+            .to.be.equal(false);
+        });
+        it('tampered value', async function () {
+          expect(await this.forwarder.verify({ ...this.req, value: web3.utils.toWei('1') }, this.sign()))
+            .to.be.equal(false);
+        });
+        it('tampered nonce', async function () {
+          expect(await this.forwarder.verify({ ...this.req, nonce: this.req.nonce + 1 }, this.sign()))
+            .to.be.equal(false);
+        });
+        it('tampered data', async function () {
+          expect(await this.forwarder.verify({ ...this.req, data: '0x1742' }, this.sign()))
+            .to.be.equal(false);
+        });
+        it('tampered signature', async function () {
+          const tamperedsign = web3.utils.hexToBytes(this.sign());
+          tamperedsign[42] ^= 0xff;
+          expect(await this.forwarder.verify(this.req, web3.utils.bytesToHex(tamperedsign)))
+            .to.be.equal(false);
+        });
+      });
+    });
+
+    context('execute', function () {
+      context('valid signature', function () {
+        beforeEach(async function () {
+          expect(await this.forwarder.getNonce(this.req.from))
+            .to.be.bignumber.equal(web3.utils.toBN(this.req.nonce));
+        });
+
+        it('success', async function () {
+          await this.forwarder.execute(this.req, this.sign()); // expect to not revert
+        });
+
+        afterEach(async function () {
+          expect(await this.forwarder.getNonce(this.req.from))
+            .to.be.bignumber.equal(web3.utils.toBN(this.req.nonce + 1));
+        });
+      });
+
+      context('invalid signature', function () {
+        it('tampered from', async function () {
+          await expectRevert(
+            this.forwarder.execute({ ...this.req, from: accounts[0] }, this.sign()),
+            'MinimalForwarder: signature does not match request',
+          );
+        });
+        it('tampered to', async function () {
+          await expectRevert(
+            this.forwarder.execute({ ...this.req, to: accounts[0] }, this.sign()),
+            'MinimalForwarder: signature does not match request',
+          );
+        });
+        it('tampered value', async function () {
+          await expectRevert(
+            this.forwarder.execute({ ...this.req, value: web3.utils.toWei('1') }, this.sign()),
+            'MinimalForwarder: signature does not match request',
+          );
+        });
+        it('tampered nonce', async function () {
+          await expectRevert(
+            this.forwarder.execute({ ...this.req, nonce: this.req.nonce + 1 }, this.sign()),
+            'MinimalForwarder: signature does not match request',
+          );
+        });
+        it('tampered data', async function () {
+          await expectRevert(
+            this.forwarder.execute({ ...this.req, data: '0x1742' }, this.sign()),
+            'MinimalForwarder: signature does not match request',
+          );
+        });
+        it('tampered signature', async function () {
+          const tamperedsign = web3.utils.hexToBytes(this.sign());
+          tamperedsign[42] ^= 0xff;
+          await expectRevert(
+            this.forwarder.execute(this.req, web3.utils.bytesToHex(tamperedsign)),
+            'MinimalForwarder: signature does not match request',
+          );
+        });
+      });
+
+      it('bubble out of gas', async function () {
+        const receiver = await CallReceiverMock.new();
+        const gasAvailable = 100000;
+        this.req.to = receiver.address;
+        this.req.data = receiver.contract.methods.mockFunctionOutOfGas().encodeABI();
+        this.req.gas = 1000000;
+
+        await expectRevert.assertion(
+          this.forwarder.execute(this.req, this.sign(), { gas: gasAvailable }),
+        );
+
+        const { transactions } = await web3.eth.getBlock('latest');
+        const { gasUsed } = await web3.eth.getTransactionReceipt(transactions[0]);
+
+        expect(gasUsed).to.be.equal(gasAvailable);
+      });
+    });
+  });
+});