HierarchicalKey::getScriptAndSignData() - Code Metrics - Inspection of "HierarchicalKey: add getAddress and getScriptAndSi..." - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#662)

by thomas

created 2018-03-09 00:55 UTC

HierarchicalKey::getScriptAndSignData() A

↳ Parent: HierarchicalKey

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	4
nc	2
nop	0
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0
ccs	2
cts	2
cp	1
crap	2

<?php

declare(strict_types=1);

namespace BitWasp\Bitcoin\Key\Deterministic;

use BitWasp\Bitcoin\Address\BaseAddressCreator;
use BitWasp\Bitcoin\Bitcoin;
use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\KeyInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
use BitWasp\Bitcoin\Crypto\Hash;
use BitWasp\Bitcoin\Key\KeyToScript\ScriptAndSignData;
use BitWasp\Bitcoin\Key\KeyToScript\ScriptDataFactory;
use BitWasp\Bitcoin\Network\NetworkInterface;
use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\Base58ExtendedKeySerializer;
use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\ExtendedKeySerializer;
use BitWasp\Bitcoin\Util\IntRange;
use BitWasp\Buffertools\Buffer;
use BitWasp\Buffertools\BufferInterface;

class HierarchicalKey
{
    /**
     * @var EcAdapterInterface
     */
    protected $ecAdapter;

    /**
     * @var int
     */
    private $depth;

    /**
     * @var int
     */
    private $parentFingerprint;

    /**
     * @var int
     */
    private $sequence;

    /**
     * @var BufferInterface
     */
    private $chainCode;

    /**
     * @var KeyInterface
     */
    private $key;

    /**
     * @var ScriptDataFactory
     */
    private $scriptDataFactory;

    /**
     * @var ScriptAndSignData|null
     */
    private $scriptAndSignData;

    /**
     * @param EcAdapterInterface $ecAdapter
     * @param ScriptDataFactory $scriptDataFactory
     * @param int $depth
     * @param int $parentFingerprint
     * @param int $sequence
     * @param BufferInterface $chainCode
     * @param KeyInterface $key
     */
    public function __construct(EcAdapterInterface $ecAdapter, ScriptDataFactory $scriptDataFactory, int $depth, int $parentFingerprint, int $sequence, BufferInterface $chainCode, KeyInterface $key)
    {
        if ($depth < 0 || $depth > IntRange::U8_MAX) {
            throw new \InvalidArgumentException('Invalid depth for BIP32 key, must be in range [0 - 255] inclusive');
        }

        if ($parentFingerprint < 0 || $parentFingerprint > IntRange::U32_MAX) {
            throw new \InvalidArgumentException('Invalid fingerprint for BIP32 key, must be in range [0 - (2^31)-1] inclusive');
        }

        if ($sequence < 0 || $sequence > IntRange::U32_MAX) {
            throw new \InvalidArgumentException('Invalid sequence for BIP32 key, must be in range [0 - (2^31)-1] inclusive');
        }

        if ($chainCode->getSize() !== 32) {
            throw new \RuntimeException('Chaincode should be 32 bytes');
        }

        if (!$key->isCompressed()) {
            throw new \InvalidArgumentException('A HierarchicalKey must always be compressed');
        }

        $this->ecAdapter = $ecAdapter;
        $this->depth = $depth;
        $this->sequence = $sequence;
        $this->parentFingerprint = $parentFingerprint;
        $this->chainCode = $chainCode;
        $this->key = $key;
        $this->scriptDataFactory = $scriptDataFactory;
    }

    /**
     * Return the depth of this key. This is limited to 256 sequential derivations.
     *
     * @return int
     */
    public function getDepth(): int
    {
        return $this->depth;
    }

    /**
     * Get the sequence number for this address. Hardened keys are
     * created with sequence > 0x80000000. a sequence number lower
     * than this can be derived with the public key.
     *
     * @return int
     */
    public function getSequence(): int
    {
        return $this->sequence;
    }

    /**
     * Get the fingerprint of the parent key. For master keys, this is 00000000.
     *
     * @return int
     */
    public function getFingerprint(): int
    {
        if ($this->getDepth() === 0) {
            return 0;
        }

        return $this->parentFingerprint;
    }

    /**
     * Return the fingerprint to be used for child keys.
     * @return int
     */
    public function getChildFingerprint(): int
    {
        $pubKeyHash = $this->getPublicKey()->getPubKeyHash();
        return (int) $pubKeyHash->slice(0, 4)->getInt();
    }

    /**
     * Return the chain code - a deterministic 'salt' for HMAC-SHA512
     * in child derivations
     *
     * @return BufferInterface
     */
    public function getChainCode(): BufferInterface
    {
        return $this->chainCode;
    }

    /**
     * @return PrivateKeyInterface
     */
    public function getPrivateKey(): PrivateKeyInterface
    {
        if ($this->key->isPrivate()) {
            /** @var PrivateKeyInterface $key */
            $key = $this->key;
            return $key;
        }

        throw new \RuntimeException('Unable to get private key, not known');
    }

    /**
     * Get the public key the private key or public key.
     *
     * @return PublicKeyInterface
     */
    public function getPublicKey(): PublicKeyInterface
    {
        if ($this->isPrivate()) {
            return $this->getPrivateKey()->getPublicKey();
        } else {
            /** @var PublicKeyInterface $key */
            $key = $this->key;
            return $key;
        }
    }

    /**
     * @return HierarchicalKey
     */
    public function withoutPrivateKey(): HierarchicalKey
    {
        $clone = clone $this;
        $clone->key = $clone->getPublicKey();
        return $clone;
    }

    /**
     * @param ScriptDataFactory $factory
     * @return HierarchicalKey
     */
    public function withScriptFactory(ScriptDataFactory $factory)
    {
        $clone = clone $this;
        $clone->scriptDataFactory = $factory;
        return $clone;
    }

    /**
     * @return ScriptDataFactory
     */
    public function getScriptDataFactory()
    {
        return $this->scriptDataFactory;
    }

    /**
     * @return \BitWasp\Bitcoin\Key\KeyToScript\ScriptAndSignData
     */
    public function getScriptAndSignData()
    {
        if (null === $this->scriptAndSignData) {
            $this->scriptAndSignData = $this->scriptDataFactory->convertKey($this->key);
        }

        return $this->scriptAndSignData;
    }

    /**
     * @param BaseAddressCreator $addressCreator
     * @return \BitWasp\Bitcoin\Address\Address
     */
    public function getAddress(BaseAddressCreator $addressCreator)
    {
        return $this->getScriptAndSignData()->getAddress($addressCreator);
    }

    /**
     * Return whether this is a private key
     *
     * @return bool
     */
    public function isPrivate(): bool
    {
        return $this->key->isPrivate();
    }

    /**
     * Return whether the key is hardened
     *
     * @return bool
     */
    public function isHardened(): bool
    {
        return ($this->sequence >> 31) === 1;
    }

    /**
     * Create a buffer containing data to be hashed hashed to yield the child offset
     *
     * @param int $sequence
     * @return BufferInterface
     * @throws \Exception
     */
    public function getHmacSeed(int $sequence): BufferInterface
    {
        if ($sequence < 0 || $sequence > IntRange::U32_MAX) {
            throw new \InvalidArgumentException("Sequence is outside valid range, must be >= 0 && <= (2^31)-1");
        }

        if (($sequence >> 31) === 1) {
            if ($this->isPrivate() === false) {
                throw new \Exception("Can't derive a hardened key without the private key");
            }

            $data = "\x00{$this->getPrivateKey()->getBinary()}";
        } else {
            $data = $this->getPublicKey()->getBinary();
        }

        return new Buffer($data . pack("N", $sequence));
    }

    /**
     * Derive a child key
     *
     * @param int $sequence
     * @return HierarchicalKey
     * @throws \Exception
     */
    public function deriveChild(int $sequence): HierarchicalKey
    {
        $nextDepth = $this->depth + 1;
        if ($nextDepth > 255) {
            throw new \InvalidArgumentException('Invalid depth for BIP32 key, cannot exceed 255');
        }

        $hash = Hash::hmac('sha512', $this->getHmacSeed($sequence), $this->chainCode);
        $offset = $hash->slice(0, 32);
        $chain = $hash->slice(32);

        if (false === $this->ecAdapter->validatePrivateKey($offset)) {
            return $this->deriveChild($sequence + 1);
        }

        $key = $this->isPrivate() ? $this->getPrivateKey() : $this->getPublicKey();
        $key = $key->tweakAdd($offset->getGmp());

        return new HierarchicalKey(
            $this->ecAdapter,
            $this->scriptDataFactory,
            $nextDepth,
            $this->getChildFingerprint(),
            $sequence,
            $chain,
            $key
        );
    }

    /**
     * @param array|\stdClass|\Traversable $list
     * @return HierarchicalKey
     * @throws \Exception
     */
    public function deriveFromList($list): HierarchicalKey
    {
        if (!is_array($list) && !$list instanceof \Traversable && !$list instanceof \stdClass) {
            throw new \InvalidArgumentException('List must be an array or \Traversable');
        }

        $key = $this;
        foreach ($list as $sequence) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $key = $key->deriveChild((int) $sequence);
        }

        return $key;
    }

    /**
     * Decodes a BIP32 path into actual 32bit sequence numbers and derives the child key
     *
     * @param string $path
     * @return HierarchicalKey
     * @throws \Exception
     */
    public function derivePath(string $path): HierarchicalKey
    {
        $sequences = new HierarchicalKeySequence();
        return $this->deriveFromList($sequences->decodePath($path));
    }

    /**
     * Serializes the instance according to whether it wraps a private or public key.
     * @param NetworkInterface $network
     * @return string
     */
    public function toExtendedKey(NetworkInterface $network = null): string
    {
        $network = $network ?: Bitcoin::getNetwork();

        $extendedSerializer = new Base58ExtendedKeySerializer(new ExtendedKeySerializer($this->ecAdapter));
        $extended = $extendedSerializer->serialize($network, $this);
        return $extended;
    }

    /**
     * Explicitly serialize as a private key. Throws an exception if
     * the key isn't private.
     *
     * @param NetworkInterface $network
     * @return string
     */
    public function toExtendedPrivateKey(NetworkInterface $network = null): string
    {
        if (!$this->isPrivate()) {
            throw new \LogicException('Cannot create extended private key from public');
        }

        return $this->toExtendedKey($network);
    }

    /**
     * Explicitly serialize as a public key. This will always work.
     *
     * @param NetworkInterface $network
     * @return string
     */
    public function toExtendedPublicKey(NetworkInterface $network = null): string
    {
        return $this->withoutPrivateKey()->toExtendedKey($network);
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace BitWasp\Bitcoin\Key\Deterministic;
6
7		use BitWasp\Bitcoin\Address\BaseAddressCreator;
8		use BitWasp\Bitcoin\Bitcoin;
9		use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
10		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\KeyInterface;
11		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
12		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
13		use BitWasp\Bitcoin\Crypto\Hash;
14		use BitWasp\Bitcoin\Key\KeyToScript\ScriptAndSignData;
15		use BitWasp\Bitcoin\Key\KeyToScript\ScriptDataFactory;
16		use BitWasp\Bitcoin\Network\NetworkInterface;
17		use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\Base58ExtendedKeySerializer;
18		use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\ExtendedKeySerializer;
19		use BitWasp\Bitcoin\Util\IntRange;
20		use BitWasp\Buffertools\Buffer;
21		use BitWasp\Buffertools\BufferInterface;
22
23		class HierarchicalKey
24		{
25		/**
26		* @var EcAdapterInterface
27		*/
28		protected $ecAdapter;
29
30		/**
31		* @var int
32		*/
33		private $depth;
34
35		/**
36		* @var int
37		*/
38		private $parentFingerprint;
39
40		/**
41		* @var int
42		*/
43		private $sequence;
44
45		/**
46		* @var BufferInterface
47		*/
48		private $chainCode;
49
50		/**
51		* @var KeyInterface
52		*/
53		private $key;
54
55		/**
56		* @var ScriptDataFactory
57		*/
58		private $scriptDataFactory;
59
60		/**
61	52	* @var ScriptAndSignData\|null
62		*/
63	52	private $scriptAndSignData;
64
65		/**
66		* @param EcAdapterInterface $ecAdapter
67	52	* @param ScriptDataFactory $scriptDataFactory
68		* @param int $depth
69		* @param int $parentFingerprint
70		* @param int $sequence
71	52	* @param BufferInterface $chainCode
72		* @param KeyInterface $key
73		*/
74		public function __construct(EcAdapterInterface $ecAdapter, ScriptDataFactory $scriptDataFactory, int $depth, int $parentFingerprint, int $sequence, BufferInterface $chainCode, KeyInterface $key)
75	52	{
76		if ($depth < 0 \|\| $depth > IntRange::U8_MAX) {
77		throw new \InvalidArgumentException('Invalid depth for BIP32 key, must be in range [0 - 255] inclusive');
78		}
79	52
80	1	if ($parentFingerprint < 0 \|\| $parentFingerprint > IntRange::U32_MAX) {
81		throw new \InvalidArgumentException('Invalid fingerprint for BIP32 key, must be in range [0 - (2^31)-1] inclusive');
82		}
83	51
84	51	if ($sequence < 0 \|\| $sequence > IntRange::U32_MAX) {
85	51	throw new \InvalidArgumentException('Invalid sequence for BIP32 key, must be in range [0 - (2^31)-1] inclusive');
86	51	}
87	51
88	51	if ($chainCode->getSize() !== 32) {
89	51	throw new \RuntimeException('Chaincode should be 32 bytes');
90		}
91
92		if (!$key->isCompressed()) {
93		throw new \InvalidArgumentException('A HierarchicalKey must always be compressed');
94		}
95
96	17	$this->ecAdapter = $ecAdapter;
97		$this->depth = $depth;
98	17	$this->sequence = $sequence;
99		$this->parentFingerprint = $parentFingerprint;
100		$this->chainCode = $chainCode;
101		$this->key = $key;
102		$this->scriptDataFactory = $scriptDataFactory;
103		}
104
105		/**
106		* Return the depth of this key. This is limited to 256 sequential derivations.
107		*
108	12	* @return int
109		*/
110	12	public function getDepth(): int
111		{
112		return $this->depth;
113		}
114
115		/**
116		* Get the sequence number for this address. Hardened keys are
117		* created with sequence > 0x80000000. a sequence number lower
118	13	* than this can be derived with the public key.
119		*
120	13	* @return int
121	11	*/
122		public function getSequence(): int
123		{
124	9	return $this->sequence;
125		}
126
127		/**
128		* Get the fingerprint of the parent key. For master keys, this is 00000000.
129		*
130		* @return int
131	14	*/
132		public function getFingerprint(): int
133	14	{
134	14	if ($this->getDepth() === 0) {
135		return 0;
136		}
137
138		return $this->parentFingerprint;
139		}
140
141		/**
142		* Return the fingerprint to be used for child keys.
143	11	* @return int
144		*/
145	11	public function getChildFingerprint(): int
146		{
147		$pubKeyHash = $this->getPublicKey()->getPubKeyHash();
148		return (int) $pubKeyHash->slice(0, 4)->getInt();
149		}
150
151	23	/**
152		* Return the chain code - a deterministic 'salt' for HMAC-SHA512
153	23	* in child derivations
154	21	*
155		* @return BufferInterface
156		*/
157	2	public function getChainCode(): BufferInterface
158		{
159		return $this->chainCode;
160		}
161
162		/**
163		* @return PrivateKeyInterface
164		*/
165	25	public function getPrivateKey(): PrivateKeyInterface
166		{
167	25	if ($this->key->isPrivate()) {
168	17	/** @var PrivateKeyInterface $key */
169		$key = $this->key;
170	15	return $key;
171		}
172
173		throw new \RuntimeException('Unable to get private key, not known');
174		}
175
176		/**
177	9	* Get the public key the private key or public key.
178		*
179	9	* @return PublicKeyInterface
180	9	*/
181	9	public function getPublicKey(): PublicKeyInterface
182		{
183		if ($this->isPrivate()) {
184		return $this->getPrivateKey()->getPublicKey();
185		} else {
186		/** @var PublicKeyInterface $key */
187		$key = $this->key;
188		return $key;
189	29	}
190		}
191	29
192		/**
193		* @return HierarchicalKey
194		*/
195		public function withoutPrivateKey(): HierarchicalKey
196		{
197		$clone = clone $this;
198		$clone->key = $clone->getPublicKey();
199	2	return $clone;
200		}
201	2
202		/**
203		* @param ScriptDataFactory $factory
204		* @return HierarchicalKey
205		*/
206		public function withScriptFactory(ScriptDataFactory $factory)
207		{
208		$clone = clone $this;
209		$clone->scriptDataFactory = $factory;
210		return $clone;
211	20	}
212
213	20	/**
214	6	* @return ScriptDataFactory
215		*/
216		public function getScriptDataFactory()
217	14	{
218	11	return $this->scriptDataFactory;
219	2	}
220
221		/**
222	9	* @return \BitWasp\Bitcoin\Key\KeyToScript\ScriptAndSignData
223		*/
224	12	public function getScriptAndSignData()
225		{
226		if (null === $this->scriptAndSignData) {
227	12	$this->scriptAndSignData = $this->scriptDataFactory->convertKey($this->key);
228		}
229
230		return $this->scriptAndSignData;
231		}
232
233		/**
234		* @param BaseAddressCreator $addressCreator
235		* @return \BitWasp\Bitcoin\Address\Address
236		*/
237	17	public function getAddress(BaseAddressCreator $addressCreator)
238		{
239	17	return $this->getScriptAndSignData()->getAddress($addressCreator);
240	17	}
241
242		/**
243		* Return whether this is a private key
244	17	*
245	12	* @return bool
246	12	*/
247		public function isPrivate(): bool
248	12	{
249	1	return $this->key->isPrivate();
250		}
251
252	12	/**
253	12	* Return whether the key is hardened
254		*
255	12	* @return bool
256	12	*/
257	12	public function isHardened(): bool
258	12	{
259	12	return ($this->sequence >> 31) === 1;
260	12	}
261	12
262		/**
263		* Create a buffer containing data to be hashed hashed to yield the child offset
264		*
265		* @param int $sequence
266		* @return BufferInterface
267		* @throws \Exception
268		*/
269	7	public function getHmacSeed(int $sequence): BufferInterface
270		{
271	7	if ($sequence < 0 \|\| $sequence > IntRange::U32_MAX) {
272		throw new \InvalidArgumentException("Sequence is outside valid range, must be >= 0 && <= (2^31)-1");
273		}
274
275	7	if (($sequence >> 31) === 1) {
276	7	if ($this->isPrivate() === false) {
277	7	throw new \Exception("Can't derive a hardened key without the private key");
278		}
279
280	7	$data = "\x00{$this->getPrivateKey()->getBinary()}";
281		} else {
282		$data = $this->getPublicKey()->getBinary();
283		}
284
285		return new Buffer($data . pack("N", $sequence));
286		}
287
288		/**
289		* Derive a child key
290	7	*
291		* @param int $sequence
292	7	* @return HierarchicalKey
293	7	* @throws \Exception
294		*/
295		public function deriveChild(int $sequence): HierarchicalKey
296		{
297		$nextDepth = $this->depth + 1;
298		if ($nextDepth > 255) {
299		throw new \InvalidArgumentException('Invalid depth for BIP32 key, cannot exceed 255');
300		}
301	11
302		$hash = Hash::hmac('sha512', $this->getHmacSeed($sequence), $this->chainCode);
303	11	$offset = $hash->slice(0, 32);
304		$chain = $hash->slice(32);
305	11
306	11	if (false === $this->ecAdapter->validatePrivateKey($offset)) {
307	11	return $this->deriveChild($sequence + 1);
308		}
309
310		$key = $this->isPrivate() ? $this->getPrivateKey() : $this->getPublicKey();
311		$key = $key->tweakAdd($offset->getGmp());
312
313		return new HierarchicalKey(
314		$this->ecAdapter,
315		$this->scriptDataFactory,
316		$nextDepth,
317	11	$this->getChildFingerprint(),
318		$sequence,
319	11	$chain,
320	2	$key
321		);
322		}
323	9
324		/**
325		* @param array\|\stdClass\|\Traversable $list
326		* @return HierarchicalKey
327		* @throws \Exception
328		*/
329		public function deriveFromList($list): HierarchicalKey
330		{
331		if (!is_array($list) && !$list instanceof \Traversable && !$list instanceof \stdClass) {
332	9	throw new \InvalidArgumentException('List must be an array or \Traversable');
333		}
334
335	9	$key = $this;
336	9	foreach ($list as $sequence) {
		0 ignored issues – show Bug introduced 2015-11-30 20:43 UTC by Report Bug Copy Issue Report The expression `$list` of type `array\|object<Traversable>\|object<stdClass>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
337		$key = $key->deriveChild((int) $sequence);
338		}
339
340		return $key;
341		}
342
343		/**
344		* Decodes a BIP32 path into actual 32bit sequence numbers and derives the child key
345		*
346		* @param string $path
347		* @return HierarchicalKey
348		* @throws \Exception
349		*/
350		public function derivePath(string $path): HierarchicalKey
351		{
352		$sequences = new HierarchicalKeySequence();
353		return $this->deriveFromList($sequences->decodePath($path));
354		}
355
356		/**
357		* Serializes the instance according to whether it wraps a private or public key.
358		* @param NetworkInterface $network
359		* @return string
360		*/
361		public function toExtendedKey(NetworkInterface $network = null): string
362		{
363		$network = $network ?: Bitcoin::getNetwork();
364
365		$extendedSerializer = new Base58ExtendedKeySerializer(new ExtendedKeySerializer($this->ecAdapter));
366		$extended = $extendedSerializer->serialize($network, $this);
367		return $extended;
368		}
369
370		/**
371		* Explicitly serialize as a private key. Throws an exception if
372		* the key isn't private.
373		*
374		* @param NetworkInterface $network
375		* @return string
376		*/
377		public function toExtendedPrivateKey(NetworkInterface $network = null): string
378		{
379		if (!$this->isPrivate()) {
380		throw new \LogicException('Cannot create extended private key from public');
381		}
382
383		return $this->toExtendedKey($network);
384		}
385
386		/**
387		* Explicitly serialize as a public key. This will always work.
388		*
389		* @param NetworkInterface $network
390		* @return string
391		*/
392		public function toExtendedPublicKey(NetworkInterface $network = null): string
393		{
394		return $this->withoutPrivateKey()->toExtendedKey($network);
395		}
396		}
397

Bit-Wasp / bitcoin-php

Pull Request — master (#662)

HierarchicalKey::getScriptAndSignData() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like