Repository: paritytech/ink
Pull request #582 (2020-11-17 04:53:56)

Make logo visible in GitHub App
The GitHub App uses a dark theme, in which the transparent ink! logo is barely visible.

I added a white background and some padding to the logo. It barely changes the layout when viewed via the GitHub website, but makes the logo visible in the app.

The GitHub website background is pure white, so making the background of the logo white also didn't change anything to how the logo appears when viewed on the GitHub website.

[Preview here](https://github.com/paritytech/ink/tree/cmichi-make-logo-ready-for-dark-mode)

## Before vs. After

<div style="float:left;">
<img src="https://user-images.githubusercontent.com/241530/99347558-b06c6a80-2897-11eb-86ec-69fa9fe97fe4.png" width="250" align="left" />
</div>
<div style="float:left;">
<img src="https://user-images.githubusercontent.com/241530/99347564-b19d9780-2897-11eb-8820-451d5dd29267.png" width="250" align="left" />
</div>

codecov-io: # [Codecov](https://codecov.io/gh/paritytech/ink/pull/582?src=pr&el=h1) Report
> Merging [#582](https://codecov.io/gh/paritytech/ink/pull/582?src=pr&el=desc) (38a7925) into [master](https://codecov.io/gh/paritytech/ink/commit/3a9301fbdd7f3ed2f07ef29f6724714580f3d58a?el=desc) (3a9301f) will **decrease** coverage by `0.65%`.
> The diff coverage is `n/a`.

[![Impacted file tree graph](https://codecov.io/gh/paritytech/ink/pull/582/graphs/tree.svg?width=650&height=150&src=pr&token=tYyVaCZb7o)](https://codecov.io/gh/paritytech/ink/pull/582?src=pr&el=tree)

```diff
@@            Coverage Diff             @@
##           master     #582      +/-   ##
==========================================
- Coverage   67.86%   67.20%   -0.66%     
==========================================
  Files         155      155              
  Lines        6895     6895              
==========================================
- Hits         4679     4634      -45     
- Misses       2216     2261      +45     
```


| [Impacted Files](https://codecov.io/gh/paritytech/ink/pull/582?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [crates/env/src/engine/off\_chain/chain\_extension.rs](https://codecov.io/gh/paritytech/ink/pull/582/diff?src=pr&el=tree#diff-Y3JhdGVzL2Vudi9zcmMvZW5naW5lL29mZl9jaGFpbi9jaGFpbl9leHRlbnNpb24ucnM=) | `60.00% <0.00%> (-40.00%)` | :arrow_down: |
| [crates/env/src/engine/off\_chain/db/chain\_spec.rs](https://codecov.io/gh/paritytech/ink/pull/582/diff?src=pr&el=tree#diff-Y3JhdGVzL2Vudi9zcmMvZW5naW5lL29mZl9jaGFpbi9kYi9jaGFpbl9zcGVjLnJz) | `80.00% <0.00%> (-20.00%)` | :arrow_down: |
| [crates/primitives/src/key.rs](https://codecov.io/gh/paritytech/ink/pull/582/diff?src=pr&el=tree#diff-Y3JhdGVzL3ByaW1pdGl2ZXMvc3JjL2tleS5ycw==) | `65.82% <0.00%> (-16.46%)` | :arrow_down: |
| [crates/env/src/engine/off\_chain/mod.rs](https://codecov.io/gh/paritytech/ink/pull/582/diff?src=pr&el=tree#diff-Y3JhdGVzL2Vudi9zcmMvZW5naW5lL29mZl9jaGFpbi9tb2QucnM=) | `77.92% <0.00%> (-11.69%)` | :arrow_down: |
| [crates/env/src/engine/off\_chain/db/console.rs](https://codecov.io/gh/paritytech/ink/pull/582/diff?src=pr&el=tree#diff-Y3JhdGVzL2Vudi9zcmMvZW5naW5lL29mZl9jaGFpbi9kYi9jb25zb2xlLnJz) | `15.78% <0.00%> (-10.53%)` | :arrow_down: |
| [crates/env/src/engine/off\_chain/db/accounts.rs](https://codecov.io/gh/paritytech/ink/pull/582/diff?src=pr&el=tree#diff-Y3JhdGVzL2Vudi9zcmMvZW5naW5lL29mZl9jaGFpbi9kYi9hY2NvdW50cy5ycw==) | `75.32% <0.00%> (-10.39%)` | :arrow_down: |
| [crates/env/src/engine/off\_chain/db/events.rs](https://codecov.io/gh/paritytech/ink/pull/582/diff?src=pr&el=tree#diff-Y3JhdGVzL2Vudi9zcmMvZW5naW5lL29mZl9jaGFpbi9kYi9ldmVudHMucnM=) | `9.67% <0.00%> (-6.46%)` | :arrow_down: |
| [...ates/storage/src/collections/hashmap/fuzz\_tests.rs](https://codecov.io/gh/paritytech/ink/pull/582/diff?src=pr&el=tree#diff-Y3JhdGVzL3N0b3JhZ2Uvc3JjL2NvbGxlY3Rpb25zL2hhc2htYXAvZnV6el90ZXN0cy5ycw==) | `94.52% <0.00%> (-5.48%)` | :arrow_down: |

------

[Continue to review full report at Codecov](https://codecov.io/gh/paritytech/ink/pull/582?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/paritytech/ink/pull/582?src=pr&el=footer). Last update [3a9301f...38a7925](https://codecov.io/gh/paritytech/ink/pull/582?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).

Robbepop: While I like this improvement we should do something else with our logo. Maybe paint it pink/purple or add some white glow around it that looks better than a white box.

Patch:
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 3f14489a1e..afad2c9c57 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -193,13 +193,6 @@ fmt:
 
 #### stage:                        examples
 
-.update-cargo-contract:            &update-cargo-contract
-  # `cargo install` returns an error if there is nothing to update, so have to suppress it here temporarily
-# restore this once ink! 3.0 is published and the new version of cargo-contract has been released to crates.io
-#  - cargo install cargo-contract || echo $?
-  - cargo install --git https://github.com/paritytech/cargo-contract --tag ink-ci || echo $?
-  - cargo contract -V
-
 examples-test:
   stage:                           examples
   <<:                              *docker-env
@@ -242,27 +235,13 @@ examples-contract-build:
   stage:                           examples
   <<:                              *docker-env
   script:
-    - *update-cargo-contract
+    - cargo contract -V
     - for example in examples/*/; do
         pushd $example &&
         cargo contract build &&
         popd;
       done
 
-examples-generate-metadata:
-  stage:                           examples
-  <<:                              *docker-env
-  needs:
-    - job:                         build-wasm
-      artifacts:                   false
-  script:
-    - *update-cargo-contract
-    - for example in examples/*/; do
-        pushd $example &&
-        cargo contract generate-metadata &&
-        popd;
-      done
-
 #### stage:                        publish
 
 publish-docs:
diff --git a/.images/ink-logo-glow.svg b/.images/ink-logo-glow.svg
new file mode 100644
index 0000000000..ded3a1842b
--- /dev/null
+++ b/.images/ink-logo-glow.svg
@@ -0,0 +1,14 @@
+<svg width="238" height="118" viewBox="0 0 238 118" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g opacity="0.8">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M208.389 90.3291C202.78 92.3591 199.658 98.2964 201.421 103.579C203.184 108.862 209.17 111.503 214.779 109.473C220.389 107.443 223.511 101.506 221.747 96.223C219.984 90.9401 213.998 88.299 208.389 90.3291ZM25.3277 36.6473C26.7921 36.6474 27.5243 37.3795 27.5243 38.844V107.672C27.5243 109.136 26.7921 109.868 25.3277 109.868H10.8299C9.36549 109.868 8.63323 109.136 8.63323 107.672V38.844C8.63323 37.3795 9.36549 36.6474 10.8299 36.6473H25.3277ZM84.9296 36.0616C100.892 36.0616 106.457 46.8982 106.457 61.8354V107.672C106.457 109.136 105.724 109.868 104.26 109.868H89.7622C88.2977 109.868 87.5656 109.136 87.5656 107.672V59.6387C87.5656 54.6597 83.9046 52.9024 79.6576 52.9024H77.9004C71.6034 52.9024 67.0636 55.5383 65.4528 58.1743V107.672C65.4528 109.136 64.7206 109.868 63.2562 109.868H48.7584C47.294 109.868 46.5618 109.136 46.5618 107.672V38.844C46.5618 37.3795 47.294 36.6474 48.7584 36.6473H63.2562C64.7206 36.6474 65.4528 37.3795 65.4528 38.844V45.2874C67.6494 41.6264 73.2142 36.0616 84.0509 36.0616H84.9296ZM140.724 7.35889C142.189 7.35889 142.921 8.09115 142.921 9.55547V60.371L163.715 38.4046C164.594 37.3795 165.912 36.6474 167.084 36.6473H182.167C184.071 36.6474 185.828 38.844 183.192 41.6264L161.372 65.057L186.853 105.914C187.732 107.525 187.585 109.868 185.096 109.868H171.33C169.427 109.868 167.669 109.283 166.498 107.232L148.632 77.651L142.921 83.3623V107.672C142.921 109.136 142.189 109.868 140.724 109.868H126.226C124.762 109.868 124.03 109.136 124.03 107.672V9.55547C124.03 8.09115 124.762 7.35889 126.226 7.35889L140.724 7.35889ZM15.2374 10.8382C9.74022 12.5003 6.4321 18.047 7.85473 23.2169C9.27747 28.3867 14.8955 31.2346 20.3927 29.5724C25.89 27.9103 29.198 22.3636 27.7754 17.1938C26.3528 12.0239 20.7347 9.17609 15.2374 10.8382Z" fill="black"/>
+<path d="M25.3277 36.1473H25.3277H10.8299H10.8299C10.0206 36.1473 9.32182 36.35 8.82887 36.8429C8.33591 37.3359 8.13323 38.0347 8.13323 38.844V107.672C8.13323 108.481 8.3359 109.18 8.82886 109.673C9.32182 110.166 10.0206 110.368 10.8299 110.368H25.3277C26.137 110.368 26.8358 110.166 27.3287 109.673C27.8216 109.18 28.0243 108.481 28.0243 107.672V38.844C28.0243 38.0347 27.8216 37.3359 27.3287 36.8429C26.8358 36.35 26.137 36.1473 25.3277 36.1473ZM187.292 105.675L187.285 105.662L187.278 105.65L161.999 65.1175L183.555 41.9702C183.556 41.9697 183.556 41.9692 183.557 41.9687C184.952 40.4947 185.29 39.0525 184.848 37.9127C184.417 36.7991 183.298 36.1473 182.167 36.1473H167.084C165.731 36.1474 164.289 36.9724 163.344 38.0698L143.421 59.1155V9.55547C143.421 8.74624 143.218 8.04745 142.725 7.55451C142.232 7.06156 141.533 6.85889 140.724 6.85889H126.226C125.417 6.85889 124.718 7.06156 124.225 7.55451C123.732 8.04745 123.53 8.74624 123.53 9.55547V107.672C123.53 108.481 123.732 109.18 124.225 109.673C124.718 110.166 125.417 110.368 126.226 110.368H140.724C141.533 110.368 142.232 110.166 142.725 109.673C143.218 109.18 143.421 108.481 143.421 107.672V83.5694L148.534 78.4561L166.064 107.48C166.065 107.482 166.066 107.484 166.067 107.486C166.698 108.589 167.502 109.319 168.42 109.768C169.333 110.215 170.33 110.368 171.33 110.368H185.096C185.797 110.368 186.379 110.203 186.831 109.887C187.285 109.569 187.569 109.126 187.716 108.64C188.004 107.689 187.775 106.561 187.292 105.675ZM15.0927 10.3596L15.2374 10.8382L15.0927 10.3596C9.36618 12.091 5.86993 17.8886 7.37265 23.3495L7.37265 23.3496C8.87871 28.8221 14.8038 31.7846 20.5375 30.051C26.2641 28.3195 29.7602 22.5219 28.2575 17.0611C26.7515 11.5884 20.8263 8.62603 15.0927 10.3596ZM208.219 89.8589C202.384 91.9705 199.088 98.1684 200.947 103.738C202.81 109.319 209.108 112.058 214.95 109.944C220.784 107.832 224.081 101.634 222.222 96.0647C220.359 90.4839 214.06 87.7448 208.219 89.8589ZM106.957 61.8354C106.957 54.3191 105.559 47.7499 102.081 43.0496C98.582 38.3214 93.0361 35.5616 84.9296 35.5616H84.0509C74.2886 35.5616 68.6892 40.0048 65.9528 43.6528V38.844C65.9528 38.0347 65.7501 37.3359 65.2572 36.8429C64.7643 36.35 64.0655 36.1473 63.2562 36.1473H48.7584C47.9491 36.1473 47.2503 36.35 46.7574 36.8429C46.2644 37.3359 46.0618 38.0347 46.0618 38.844V107.672C46.0618 108.481 46.2644 109.18 46.7574 109.673C47.2503 110.166 47.9491 110.368 48.7584 110.368H63.2562C64.0655 110.368 64.7643 110.166 65.2572 109.673C65.7501 109.18 65.9528 108.481 65.9528 107.672V58.3184C67.5101 55.9118 71.8144 53.4024 77.9004 53.4024H79.6576C81.7241 53.4024 83.5807 53.8318 84.9083 54.8065C86.2106 55.7626 87.0656 57.2881 87.0656 59.6387V107.672C87.0656 108.481 87.2682 109.18 87.7611 109.673C88.2541 110.166 88.9529 110.368 89.7622 110.368H104.26C105.069 110.368 105.768 110.166 106.261 109.673C106.754 109.18 106.957 108.481 106.957 107.672V61.8354Z" stroke="white" stroke-opacity="0.8"/>
+</g>
+<g opacity="0.8">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M206.599 73.2815L203.408 73.2579C201.944 73.2579 201.212 72.5256 201.212 71.0612V9.55547C201.212 8.09115 201.944 7.35889 203.408 7.35889H218.345C219.81 7.35889 220.542 8.09115 220.542 9.55547L220.533 11.631C214.852 13.0148 210.429 18.8034 210.075 26.0213C209.791 31.8185 212.204 37.07 216.018 40.0414C213.177 41.9747 211.088 45.2396 210.565 49.15C209.995 53.4076 211.412 57.4409 214.042 60.1077C211.388 61.2726 208.971 63.6535 207.595 66.793C206.623 69.0124 206.319 71.2728 206.599 73.2815Z" fill="black"/>
+<path d="M206.596 73.7815L207.174 73.7858L207.095 73.2125C206.828 71.3023 207.115 69.1349 208.053 66.9936C209.381 63.9618 211.711 61.6769 214.243 60.5655L214.908 60.2737L214.398 59.7566C211.881 57.2036 210.51 53.3259 211.06 49.2164L210.565 49.15L211.06 49.2164C211.565 45.4426 213.579 42.3058 216.3 40.4548L216.867 40.0688L216.326 39.647C212.652 36.785 210.297 31.6964 210.575 26.0458C210.92 19.0018 215.229 13.4378 220.651 12.1168L221.031 12.0242L221.033 11.6331L221.042 9.55763V9.55547C221.042 8.74624 220.839 8.04746 220.346 7.55451C219.853 7.06157 219.155 6.85889 218.345 6.85889H203.408C202.599 6.85889 201.9 7.06157 201.407 7.55451C200.914 8.04746 200.712 8.74624 200.712 9.55547V71.0612C200.712 71.8705 200.914 72.5693 201.407 73.0622C201.9 73.5549 202.598 73.7576 203.407 73.7579C203.407 73.7579 203.408 73.7579 203.408 73.7579L206.596 73.7815Z" stroke="white" stroke-opacity="0.8"/>
+</g>
+<g opacity="0.8">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M211.209 68.3066C210.12 70.7918 210.953 73.4161 213.068 74.1633C215.182 74.9103 217.783 73.499 218.872 71.0136C219.961 68.5282 219.128 65.9039 217.013 65.1569C214.899 64.4097 212.298 65.8212 211.209 68.3066ZM215.153 50.1107C214.426 53.9585 216.455 57.5709 219.681 58.1724C222.907 58.774 226.117 56.1384 226.844 52.2906C227.571 48.4428 225.542 44.8304 222.315 44.2289C219.089 43.6274 215.88 46.2629 215.153 50.1107ZM214.342 27.4322C214.084 32.6972 217.466 37.2256 221.89 37.5384C226.314 37.8512 230.116 33.8308 230.374 28.5658C230.632 23.3007 227.25 18.7723 222.826 18.4595C218.402 18.1467 214.6 22.1673 214.342 27.4322Z" fill="black"/>
+<path d="M219.33 71.2142L218.872 71.0136L219.33 71.2142C220.494 68.5582 219.658 65.5608 217.18 64.6854C214.746 63.8257 211.911 65.4574 210.751 68.1059H210.751C209.587 70.7619 210.423 73.7592 212.901 74.6347C215.335 75.4944 218.17 73.8628 219.33 71.2142ZM222.407 43.7373L222.407 43.7373C218.832 43.0709 215.423 45.9838 214.661 50.0179C213.899 54.0523 216.013 57.9972 219.589 58.664C223.164 59.3305 226.573 56.4175 227.335 52.3834C228.097 48.349 225.983 44.4041 222.407 43.7373ZM213.843 27.4077L213.843 27.4077C213.575 32.8627 217.085 37.6999 221.855 38.0372C226.639 38.3754 230.606 34.0482 230.873 28.5902C231.141 23.1352 227.631 18.298 222.861 17.9607L222.861 17.9607C218.077 17.6225 214.11 21.9498 213.843 27.4077Z" stroke="white" stroke-opacity="0.8"/>
+</g>
+</svg>
diff --git a/.images/ink-logo-white-bg.svg b/.images/ink-logo-white-bg.svg
new file mode 100644
index 0000000000..7de1a18701
--- /dev/null
+++ b/.images/ink-logo-white-bg.svg
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="2090"
+   height="1018"
+   viewBox="0 0 2090 1018"
+   version="1.1"
+   xml:space="preserve"
+   style="clip-rule:evenodd;fill-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:1.41421"
+   id="svg9"
+   sodipodi:docname="ink-logo-white-bg.svg"
+   inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)"><metadata
+     id="metadata15"><rdf:RDF><cc:Work
+         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
+     id="defs13" /><sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1918"
+     inkscape:window-height="1055"
+     id="namedview11"
+     showgrid="false"
+     inkscape:zoom="0.32769766"
+     inkscape:cx="676.97217"
+     inkscape:cy="1157.2619"
+     inkscape:window-x="0"
+     inkscape:window-y="23"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg9" /><rect
+     style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.927975"
+     id="rect840"
+     width="2090"
+     height="1018"
+     x="0"
+     y="0" /><g
+     id="g7"
+     transform="translate(39.890122,45.38172)"><path
+       id="inc"
+       d="m 1811.78,748.385 c -50.595,18.311 -78.758,71.865 -62.852,119.517 15.906,47.653 69.897,71.474 120.492,53.164 50.595,-18.311 78.758,-71.865 62.852,-119.518 -15.906,-47.652 -69.897,-71.474 -120.492,-53.163 z M 160.58,264.179 c 13.209,0.001 19.813,6.605 19.813,19.814 v 620.821 c 0,13.209 -6.604,19.813 -19.813,19.814 H 29.811 c -13.209,0 -19.814,-6.605 -19.814,-19.814 V 283.993 c 0,-13.209 6.605,-19.813 19.814,-19.814 z m 537.605,-5.283 c 143.978,0 194.171,97.746 194.171,232.478 v 413.44 c 0,13.209 -6.604,19.813 -19.813,19.814 H 741.774 c -13.209,0 -19.813,-6.605 -19.813,-19.814 V 471.56 c 0,-44.91 -33.022,-60.761 -71.329,-60.761 h -15.85 c -56.799,0 -97.747,23.776 -112.277,47.552 v 446.463 c 0,13.209 -6.604,19.813 -19.813,19.814 H 371.923 c -13.209,0 -19.813,-6.605 -19.813,-19.814 V 283.993 c 0,-13.209 6.604,-19.813 19.813,-19.814 h 130.769 c 13.209,0.001 19.813,6.605 19.813,19.814 v 58.119 c 19.814,-33.022 70.008,-83.216 167.754,-83.216 z M 1201.446,0 c 13.21,0 19.814,6.605 19.814,19.813 V 478.165 L 1408.827,280.03 c 7.925,-9.246 19.813,-15.85 30.381,-15.851 h 136.052 c 17.173,0.001 33.022,19.814 9.246,44.911 l -196.813,211.343 229.836,368.53 c 7.925,14.53 6.604,35.664 -15.851,35.665 h -124.164 c -17.172,0 -33.023,-5.284 -43.59,-23.776 L 1272.775,634.03 1221.26,685.545 v 219.269 c 0,13.209 -6.604,19.813 -19.814,19.814 h -130.768 c -13.209,0 -19.814,-6.605 -19.814,-19.814 V 19.813 C 1050.864,6.605 1057.468,0 1070.678,0 Z M 69.566,31.383 C 19.982,46.375 -9.857,96.406 2.975,143.038 15.808,189.669 66.482,215.357 116.067,200.364 165.652,185.372 195.49,135.341 182.658,88.71 169.826,42.078 119.151,16.391 69.566,31.383 Z"
+       style="fill:#0e0e0e" /><path
+       d="m 1795.61,594.617 -28.783,-0.213 c -13.209,0 -19.813,-6.605 -19.813,-19.814 V 19.813 C 1747.014,6.605 1753.618,0 1766.827,0 h 134.732 c 13.209,0 19.813,6.605 19.813,19.813 l -0.081,18.721 c -51.238,12.482 -91.137,64.695 -94.329,129.8 -2.564,52.29 19.2,99.658 53.607,126.46 -25.633,17.438 -44.472,46.887 -49.193,82.159 -5.141,38.403 7.648,74.783 31.364,98.837 -23.939,10.508 -45.741,31.983 -58.147,60.301 -8.77,20.019 -11.509,40.408 -8.983,58.526 z"
+       style="fill:#0e0e0e"
+       id="path3" /><path
+       d="m 1837.23,549.753 c -9.822,22.417 -2.309,46.088 16.766,52.827 19.074,6.738 42.534,-5.992 52.356,-28.41 9.821,-22.418 2.308,-46.089 -16.766,-52.827 -19.075,-6.739 -42.535,5.992 -52.356,28.41 z m 35.572,-164.125 c -6.558,34.707 11.744,67.29 40.844,72.716 29.1,5.426 58.05,-18.347 64.607,-53.054 6.558,-34.707 -11.744,-67.29 -40.844,-72.716 -29.1,-5.425 -58.05,18.347 -64.607,53.054 z m -7.312,-204.559 c -2.328,47.49 28.18,88.336 68.085,91.158 39.905,2.821 74.194,-33.443 76.522,-80.933 2.329,-47.49 -28.179,-88.336 -68.084,-91.158 -39.906,-2.821 -74.194,33.444 -76.523,80.933 z"
+       style="fill:#0e0e0e"
+       id="path5" /></g></svg>
diff --git a/README.md b/README.md
index ee8a0ac1da..08ec85445c 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 <div align="center">
-<img src="./.images/ink-logo.svg" alt="ink!" height="120" />
+    <img src="./.images/ink-logo-glow.svg" alt="ink!" height="136" />
 <h1 align="center">
     Parity's ink! for writing smart contracts
 </h1>
@@ -27,7 +27,7 @@
 [l1]: https://img.shields.io/discord/722223075629727774?style=flat-square&label=discord
 [l2]: https://discord.gg/ztCASQE
 
-> <img src="./.images/ink-squid.svg" alt="squid, the ink! mascot" style="vertical-align: middle" align="left" height="60" />ink! is an [eDSL](https://wiki.haskell.org/Embedded_domain_specific_language) to write WebAssembly based smart contracts using the Rust programming language. The compilation target are blockchains built on the [Substrate](https://github.com/paritytech/substrate) framework.
+> <img src="./.images/ink-squid.svg" alt="squink, the ink! mascot" style="vertical-align: middle" align="left" height="60" />ink! is an [eDSL](https://wiki.haskell.org/Embedded_domain_specific_language) to write WebAssembly based smart contracts using the Rust programming language. The compilation target are blockchains built on the [Substrate](https://github.com/paritytech/substrate) framework.
 
 <br/>
 
@@ -203,7 +203,7 @@ In a module annotated with `#[ink::contract]` these attributes are available:
 | `#[ink(payable)]` | Applicable to ink! messages. | Allows receiving value as part of the call of the ink! message. ink! constructors are implicitly payable. |
 | `#[ink(selector = "..")]` | Applicable to ink! messages and ink! constructors. | Specifies a concrete dispatch selector for the flagged entity. This allows a contract author to precisely control the selectors of their APIs making it possible to rename their API without breakage. |
 | `#[ink(namespace = "..")]` | Applicable to ink! trait implementation blocks. | Changes the resulting selectors of all the ink! messages and ink! constructors within the trait implementation. Allows to disambiguate between trait implementations with overlapping message or constructor names. Use only with great care and consideration! |
-| `#[ink(implementation)]` | Applicable to ink! implementation blocks. | Tells the ink! codegen that some implementation block shall be granted access to ink! internals even without it containing any ink! messages or ink! constructors. |
+| `#[ink(impl)]` | Applicable to ink! implementation blocks. | Tells the ink! codegen that some implementation block shall be granted access to ink! internals even without it containing any ink! messages or ink! constructors. |
 
 See [here](https://paritytech.github.io/ink/ink_lang/attr.contract.html) for a more detailed description of those and also for details on the `#[ink::contract]` macro.
 
diff --git a/RELEASES.md b/RELEASES.md
index 65a989991b..90f93fb386 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -260,7 +260,7 @@ pub struct OptedOut {
 ```
 
 The the above example `a` and `b` are normal storage entities, however, `c` on the other hand side will never load from or store to contract storage and will always be reset to the default value of its `i32` type for every contract call.
-It can be accesses from all ink! messages or methods via `self.c` but will never manipulate the contract storage and thus acts wonderfully as some shared local information.
+It can be accessed from all ink! messages or methods via `self.c` but will never manipulate the contract storage and thus acts wonderfully as some shared local information.
 
 ### Dynamic Storage Allocator
 
@@ -278,7 +278,7 @@ pub struct Matrix {
 }
 ```
 
-However, this will fail compilation with an error indicating that `StorageVec<T>` requires for its `T` to be packed (`T: PackedLayout`) which `StorageVec<T>` itself does not since it always stores all of its elements into different cells. The same applies to many other storage data sturctures provided by `ink_storage` and is a trade-off the ink! team decided for the case of efficiency of the overall system.
+However, this will fail compilation with an error indicating that `StorageVec<T>` requires for its `T` to be packed (`T: PackedLayout`) which `StorageVec<T>` itself does not since it always stores all of its elements into different cells. The same applies to many other storage data structures provided by `ink_storage` and is a trade-off the ink! team decided for the case of efficiency of the overall system.
 Instead what a user can do in order to get their vector-of-vector to be working is to make use of ink!'s dynamic storage allocator capabilities.
 
 For this the contract author has to first enable the feature via:
@@ -360,7 +360,7 @@ We won't be going into the details for any of those but will briefly present the
 | `#[ink(payable)]` **new** | Applicable to ink! messages. | Allows receiving value as part of the call of the ink! message. ink! constructors are implicitly payable. |
 | `#[ink(selector = "..")]` **new** | Applicable to ink! messages and ink! constructors. | Specifies a concrete dispatch selector for the flagged entity. This allows a contract author to precisely control the selectors of their APIs making it possible to rename their API without breakage. |
 | `#[ink(namespace = "..")]` **new** | Applicable to ink! trait implementation blocks. | Changes the resulting selectors of all the ink! messages and ink! constructors within the trait implementation. Allows to disambiguate between trait implementations with overlapping message or constructor names. Use only with great care and consideration! |
-| `#[ink(implementation)]` **new** | Applicable to ink! implementation blocks. | Tells the ink! codegen that some implementation block shall be granted access to ink! internals even without it containing any ink! messages or ink! constructors. |
+| `#[ink(impl)]` **new** | Applicable to ink! implementation blocks. | Tells the ink! codegen that some implementation block shall be granted access to ink! internals even without it containing any ink! messages or ink! constructors. |
 
 ## Merging of ink! Attributes
 
diff --git a/crates/env/src/engine/off_chain/db/accounts.rs b/crates/env/src/engine/off_chain/db/accounts.rs
index 93a767fe11..8ff61f3db6 100644
--- a/crates/env/src/engine/off_chain/db/accounts.rs
+++ b/crates/env/src/engine/off_chain/db/accounts.rs
@@ -267,6 +267,12 @@ impl Account {
     pub fn get_storage_rw(&self) -> Result<(usize, usize)> {
         self.contract_or_err().map(|contract| contract.get_rw())
     }
+
+    /// Returns the amount of used storage entries.
+    pub fn count_used_storage_cells(&self) -> Result<usize> {
+        self.contract_or_err()
+            .map(|contract| contract.count_used_storage_cells())
+    }
 }
 
 /// The kind of the account.
@@ -301,6 +307,11 @@ impl ContractAccount {
     pub fn get_rw(&self) -> (usize, usize) {
         self.storage.get_rw()
     }
+
+    /// Returns the number of used storage entries.
+    pub fn count_used_storage_cells(&self) -> usize {
+        self.storage.count_used_storage_cells()
+    }
 }
 
 /// The storage of a contract instance.
@@ -355,4 +366,9 @@ impl ContractStorage {
         self.count_writes += 1;
         self.entries.remove(&at);
     }
+
+    /// Returns the number of used storage entries.
+    pub fn count_used_storage_cells(&self) -> usize {
+        self.entries.len()
+    }
 }
diff --git a/crates/lang/ir/src/ir/attrs.rs b/crates/lang/ir/src/ir/attrs.rs
index 230a810129..023b52e026 100644
--- a/crates/lang/ir/src/ir/attrs.rs
+++ b/crates/lang/ir/src/ir/attrs.rs
@@ -268,8 +268,8 @@ impl Spanned for AttributeArg {
 pub enum AttributeArgKind {
     /// `#[ink(storage)]`
     ///
-    /// Applied on `struct` or `enum` types in order to flag them for being
-    /// the contract's storage definition.
+    /// Applied on `struct` types in order to flag them for being the
+    /// contract's storage definition.
     Storage,
     /// `#[ink(event)]`
     ///
diff --git a/crates/lang/ir/src/ir/item_impl/callable.rs b/crates/lang/ir/src/ir/item_impl/callable.rs
index bf85a0fc06..08b24221cf 100644
--- a/crates/lang/ir/src/ir/item_impl/callable.rs
+++ b/crates/lang/ir/src/ir/item_impl/callable.rs
@@ -289,7 +289,7 @@ pub trait Callable {
 ///
 /// These recommendation mainly apply to trait implementation blocks:
 ///
-/// - The recommandation by the ink! team is to use the full-path approach
+/// - The recommendation by the ink! team is to use the full-path approach
 /// wherever possible; OR import the trait and use only its identifier with
 /// an additional namespace if required to disambiguate selectors.
 /// - Try not to intermix the above recommendations.
diff --git a/crates/storage/src/collections/smallvec/mod.rs b/crates/storage/src/collections/smallvec/mod.rs
index f7f4bd3923..9463aa8772 100644
--- a/crates/storage/src/collections/smallvec/mod.rs
+++ b/crates/storage/src/collections/smallvec/mod.rs
@@ -85,7 +85,7 @@ where
     ///
     /// # Note
     ///
-    /// This completely invalidates the storage vector's invariances about
+    /// This completely invalidates the storage vector's invariants about
     /// the contents of its associated storage region.
     ///
     /// This API is used for the `Drop` implementation of [`Vec`] as well as
diff --git a/crates/storage/src/collections/stash/mod.rs b/crates/storage/src/collections/stash/mod.rs
index 7fb20ea8ab..f1efce12fd 100644
--- a/crates/storage/src/collections/stash/mod.rs
+++ b/crates/storage/src/collections/stash/mod.rs
@@ -262,7 +262,7 @@ where
     ///
     /// # Note
     ///
-    /// This completely invalidates the storage vector's invariances about
+    /// This completely invalidates the storage vector's invariants about
     /// the contents of its associated storage region.
     ///
     /// This API is used for the `Drop` implementation of [`Vec`] as well as
diff --git a/crates/storage/src/collections/vec/mod.rs b/crates/storage/src/collections/vec/mod.rs
index 8b4056415d..0a313bc75c 100644
--- a/crates/storage/src/collections/vec/mod.rs
+++ b/crates/storage/src/collections/vec/mod.rs
@@ -105,7 +105,7 @@ where
     ///
     /// # Note
     ///
-    /// This completely invalidates the storage vector's invariances about
+    /// This completely invalidates the storage vector's invariants about
     /// the contents of its associated storage region.
     ///
     /// This API is used for the `Drop` implementation of [`Vec`] as well as
diff --git a/crates/storage/src/lazy/lazy_cell.rs b/crates/storage/src/lazy/lazy_cell.rs
index 2534bc658e..e86df080db 100644
--- a/crates/storage/src/lazy/lazy_cell.rs
+++ b/crates/storage/src/lazy/lazy_cell.rs
@@ -151,8 +151,22 @@ where
 
     fn clear_spread(&self, ptr: &mut KeyPtr) {
         let root_key = ExtKeyPtr::next_for::<Self>(ptr);
-        if let Some(entry) = self.entry() {
-            entry.clear_spread_root(root_key)
+        match <T as SpreadLayout>::REQUIRES_DEEP_CLEAN_UP {
+            true => {
+                // The inner cell needs to be cleared, no matter if it has
+                // been loaded or not. Otherwise there might be leftovers.
+                // Load from storage and then clear:
+                clear_spread_root_opt::<T, _>(root_key, || self.get())
+            }
+            false => {
+                // Clear without loading from storage:
+                let footprint = <T as SpreadLayout>::FOOTPRINT;
+                assert!(footprint <= 16); // magic number
+                let mut key_ptr = KeyPtr::from(*root_key);
+                for _ in 0..footprint {
+                    ink_env::clear_contract_storage(key_ptr.advance_by(1));
+                }
+            }
         }
     }
 }
@@ -653,4 +667,37 @@ mod tests {
             Ok(())
         })
     }
+
+    #[test]
+    #[should_panic(expected = "encountered empty storage cell")]
+    fn nested_lazies_are_cleared_completely_after_pull() {
+        ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+            // given
+            let root_key = Key::from([0x42; 32]);
+            let nested_lazy: Lazy<Lazy<u32>> = Lazy::new(Lazy::new(13u32));
+            SpreadLayout::push_spread(&nested_lazy, &mut KeyPtr::from(root_key));
+            let pulled_lazy = <Lazy<Lazy<u32>> as SpreadLayout>::pull_spread(
+                &mut KeyPtr::from(root_key),
+            );
+
+            // when
+            SpreadLayout::clear_spread(&pulled_lazy, &mut KeyPtr::from(root_key));
+
+            // then
+            let contract_id = ink_env::test::get_current_contract_account_id::<
+                ink_env::DefaultEnvironment,
+            >()
+            .expect("Cannot yet contract id");
+            let used_cells = ink_env::test::count_used_storage_cells::<
+                ink_env::DefaultEnvironment,
+            >(&contract_id)
+            .expect("used cells must be returned");
+            assert_eq!(used_cells, 0);
+            let _ = *<Lazy<Lazy<u32>> as SpreadLayout>::pull_spread(&mut KeyPtr::from(
+                root_key,
+            ));
+            Ok(())
+        })
+        .unwrap()
+    }
 }
diff --git a/examples/contract-transfer/lib.rs b/examples/contract-transfer/lib.rs
index a130d1bd54..2fe2eec908 100644
--- a/examples/contract-transfer/lib.rs
+++ b/examples/contract-transfer/lib.rs
@@ -84,7 +84,7 @@ pub mod give_me {
         /// The method needs to be annotated with `payable`; only then it is
         /// allowed to receive value as part of the call.
         #[ink(message, payable, selector = "0xCAFEBABE")]
-        pub fn was_it_ten(&mut self) -> bool {
+        pub fn was_it_ten(&self) -> bool {
             self.env().transferred_balance() == 10
         }
     }


Test patch:
diff --git a/crates/env/src/engine/off_chain/test_api.rs b/crates/env/src/engine/off_chain/test_api.rs
index b47aca36f4..89437de276 100644
--- a/crates/env/src/engine/off_chain/test_api.rs
+++ b/crates/env/src/engine/off_chain/test_api.rs
@@ -352,6 +352,23 @@ where
     })
 }
 
+/// Returns the amount of storage cells used by the account `account_id`.
+///
+/// Returns `None` if the `account_id` is non-existent.
+pub fn count_used_storage_cells<T>(account_id: &T::AccountId) -> Result<usize>
+where
+    T: Environment,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        instance
+            .accounts
+            .get_account::<T>(account_id)
+            .ok_or_else(|| AccountError::no_account_for_id::<T>(account_id))
+            .map_err(Into::into)
+            .and_then(|account| account.count_used_storage_cells().map_err(Into::into))
+    })
+}
+
 /// Returns the account id of the currently executing contract.
 pub fn get_current_contract_account_id<T>() -> Result<T::AccountId>
 where
diff --git a/crates/storage/src/collections/hashmap/tests.rs b/crates/storage/src/collections/hashmap/tests.rs
index 542ae76e00..9a471dfcd8 100644
--- a/crates/storage/src/collections/hashmap/tests.rs
+++ b/crates/storage/src/collections/hashmap/tests.rs
@@ -13,9 +13,12 @@
 // limitations under the License.
 
 use super::HashMap as StorageHashMap;
-use crate::traits::{
-    KeyPtr,
-    SpreadLayout,
+use crate::{
+    traits::{
+        KeyPtr,
+        SpreadLayout,
+    },
+    Lazy,
 };
 use ink_primitives::Key;
 
@@ -35,6 +38,13 @@ fn pull_hmap() -> StorageHashMap<u8, i32> {
     <StorageHashMap<u8, i32> as SpreadLayout>::pull_spread(&mut key_ptr())
 }
 
+fn filled_hmap() -> StorageHashMap<u8, i32> {
+    [(b'A', 1), (b'B', 2), (b'C', 3), (b'D', 4)]
+        .iter()
+        .copied()
+        .collect::<StorageHashMap<u8, i32>>()
+}
+
 #[test]
 fn new_works() {
     // `StorageHashMap::new`
@@ -102,10 +112,7 @@ fn get_works() {
     assert_eq!(hmap.get(&b'A'), None);
     assert_eq!(hmap.get(&b'E'), None);
     // Filled hash map: `get`
-    let hmap = [(b'A', 1), (b'B', 2), (b'C', 3), (b'D', 4)]
-        .iter()
-        .copied()
-        .collect::<StorageHashMap<u8, i32>>();
+    let hmap = filled_hmap();
     assert_eq!(hmap.get(&b'A'), Some(&1));
     assert_eq!(hmap.get(&b'B'), Some(&2));
     assert_eq!(hmap.get(&b'C'), Some(&3));
@@ -150,10 +157,7 @@ fn take_works() {
     assert_eq!(hmap.take(&b'A'), None);
     assert_eq!(hmap.take(&b'E'), None);
     // Filled hash map: `get`
-    let mut hmap = [(b'A', 1), (b'B', 2), (b'C', 3), (b'D', 4)]
-        .iter()
-        .copied()
-        .collect::<StorageHashMap<u8, i32>>();
+    let mut hmap = filled_hmap();
     assert_eq!(hmap.len(), 4);
     assert_eq!(hmap.take(&b'A'), Some(1));
     assert_eq!(hmap.len(), 3);
@@ -171,10 +175,7 @@ fn take_works() {
 
 #[test]
 fn iter_next_works() {
-    let hmap = [(b'A', 1), (b'B', 2), (b'C', 3), (b'D', 4)]
-        .iter()
-        .copied()
-        .collect::<StorageHashMap<u8, i32>>();
+    let hmap = filled_hmap();
     // Test iterator over shared references:
     let mut iter = hmap.iter();
     assert_eq!(iter.count(), 4);
@@ -208,10 +209,7 @@ fn iter_next_works() {
 
 #[test]
 fn values_next_works() {
-    let hmap = [(b'A', 1), (b'B', 2), (b'C', 3), (b'D', 4)]
-        .iter()
-        .copied()
-        .collect::<StorageHashMap<u8, i32>>();
+    let hmap = filled_hmap();
     // Test iterator over shared references:
     let mut iter = hmap.values();
     assert_eq!(iter.count(), 4);
@@ -245,10 +243,7 @@ fn values_next_works() {
 
 #[test]
 fn keys_next_works() {
-    let hmap = [(b'A', 1), (b'B', 2), (b'C', 3), (b'D', 4)]
-        .iter()
-        .copied()
-        .collect::<StorageHashMap<u8, i32>>();
+    let hmap = filled_hmap();
     let mut iter = hmap.keys();
     assert_eq!(iter.count(), 4);
     assert_eq!(iter.size_hint(), (4, Some(4)));
@@ -272,10 +267,7 @@ fn defrag_works() {
         .copied()
         .collect::<StorageHashMap<u8, i32>>();
     // Defrag without limits:
-    let mut hmap = [(b'A', 1), (b'B', 2), (b'C', 3), (b'D', 4)]
-        .iter()
-        .copied()
-        .collect::<StorageHashMap<u8, i32>>();
+    let mut hmap = filled_hmap();
     assert_eq!(hmap.defrag(None), 0);
     assert_eq!(hmap.take(&b'B'), Some(2));
     assert_eq!(hmap.take(&b'C'), Some(3));
@@ -299,12 +291,9 @@ fn defrag_works() {
 #[test]
 fn spread_layout_push_pull_works() -> ink_env::Result<()> {
     ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
-        let hmap1 = [(b'A', 1), (b'B', 2), (b'C', 3), (b'D', 4)]
-            .iter()
-            .copied()
-            .collect::<StorageHashMap<u8, i32>>();
+        let hmap1 = filled_hmap();
         push_hmap(&hmap1);
-        // Load the pushed storage vector into another instance and check that
+        // Load the pushed storage hmap into another instance and check that
         // both instances are equal:
         let hmap2 = pull_hmap();
         assert_eq!(hmap1, hmap2);
@@ -316,10 +305,7 @@ fn spread_layout_push_pull_works() -> ink_env::Result<()> {
 #[should_panic(expected = "storage entry was empty")]
 fn spread_layout_clear_works() {
     ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
-        let hmap1 = [(b'A', 1), (b'B', 2), (b'C', 3), (b'D', 4)]
-            .iter()
-            .copied()
-            .collect::<StorageHashMap<u8, i32>>();
+        let hmap1 = filled_hmap();
         let root_key = Key::from([0x42; 32]);
         SpreadLayout::push_spread(&hmap1, &mut KeyPtr::from(root_key));
         // It has already been asserted that a valid instance can be pulled
@@ -327,7 +313,7 @@ fn spread_layout_clear_works() {
         //
         // Now clear the associated storage from `hmap1` and check whether
         // loading another instance from this storage will panic since the
-        // vector's length property cannot read a value:
+        // hmap's length property cannot read a value:
         SpreadLayout::clear_spread(&hmap1, &mut KeyPtr::from(root_key));
         let _ = <StorageHashMap<u8, i32> as SpreadLayout>::pull_spread(
             &mut KeyPtr::from(root_key),
@@ -336,3 +322,33 @@ fn spread_layout_clear_works() {
     })
     .unwrap()
 }
+
+#[test]
+fn storage_is_cleared_completely_after_pull_lazy() {
+    ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+        // given
+        let root_key = Key::from([0x42; 32]);
+        let lazy_hmap = Lazy::new(filled_hmap());
+        SpreadLayout::push_spread(&lazy_hmap, &mut KeyPtr::from(root_key));
+        let pulled_hmap = <Lazy<StorageHashMap<u8, i32>> as SpreadLayout>::pull_spread(
+            &mut KeyPtr::from(root_key),
+        );
+
+        // when
+        SpreadLayout::clear_spread(&pulled_hmap, &mut KeyPtr::from(root_key));
+
+        // then
+        let contract_id = ink_env::test::get_current_contract_account_id::<
+            ink_env::DefaultEnvironment,
+        >()
+        .expect("Cannot get contract id");
+        let used_cells = ink_env::test::count_used_storage_cells::<
+            ink_env::DefaultEnvironment,
+        >(&contract_id)
+        .expect("used cells must be returned");
+        assert_eq!(used_cells, 0);
+
+        Ok(())
+    })
+    .unwrap()
+}
diff --git a/crates/storage/src/collections/smallvec/tests.rs b/crates/storage/src/collections/smallvec/tests.rs
index 64666d8f1e..961e9721c2 100644
--- a/crates/storage/src/collections/smallvec/tests.rs
+++ b/crates/storage/src/collections/smallvec/tests.rs
@@ -13,9 +13,12 @@
 // limitations under the License.
 
 use super::SmallVec;
-use crate::traits::{
-    KeyPtr,
-    SpreadLayout,
+use crate::{
+    traits::{
+        KeyPtr,
+        SpreadLayout,
+    },
+    Lazy,
 };
 use generic_array::typenum::*;
 use ink_primitives::Key;
@@ -394,3 +397,67 @@ fn spread_layout_clear_works() {
     })
     .unwrap()
 }
+
+#[test]
+fn storage_is_cleared_completely_after_pull_lazy() {
+    ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+        // given
+        let root_key = Key::from([0x42; 32]);
+        let lazy_vec = Lazy::new(vec_from_slice(&[b'a', b'b', b'c', b'd']));
+        SpreadLayout::push_spread(&lazy_vec, &mut KeyPtr::from(root_key));
+        let pulled_vec = <Lazy<SmallVec<u8, U4>> as SpreadLayout>::pull_spread(
+            &mut KeyPtr::from(root_key),
+        );
+
+        // when
+        SpreadLayout::clear_spread(&pulled_vec, &mut KeyPtr::from(root_key));
+
+        // then
+        let contract_id = ink_env::test::get_current_contract_account_id::<
+            ink_env::DefaultEnvironment,
+        >()
+        .expect("contract id must exist");
+        let used_cells = ink_env::test::count_used_storage_cells::<
+            ink_env::DefaultEnvironment,
+        >(&contract_id)
+        .expect("used cells must be returned");
+        assert_eq!(used_cells, 0);
+
+        Ok(())
+    })
+    .unwrap()
+}
+
+#[test]
+#[should_panic(expected = "encountered empty storage cell")]
+fn drop_works() {
+    ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+        let root_key = Key::from([0x42; 32]);
+
+        // if the setup panics it should not cause the test to pass
+        let setup_result = std::panic::catch_unwind(|| {
+            let vec = vec_from_slice(&[b'a', b'b', b'c', b'd']);
+            SpreadLayout::push_spread(&vec, &mut KeyPtr::from(root_key));
+            let _ = <SmallVec<u8, U4> as SpreadLayout>::pull_spread(&mut KeyPtr::from(
+                root_key,
+            ));
+            // vec is dropped which should clear the cells
+        });
+        assert!(setup_result.is_ok(), "setup should not panic");
+
+        let contract_id = ink_env::test::get_current_contract_account_id::<
+            ink_env::DefaultEnvironment,
+        >()
+        .expect("Cannot get contract id");
+        let used_cells = ink_env::test::count_used_storage_cells::<
+            ink_env::DefaultEnvironment,
+        >(&contract_id)
+        .expect("used cells must be returned");
+        assert_eq!(used_cells, 0);
+
+        let _ =
+            <SmallVec<u8, U4> as SpreadLayout>::pull_spread(&mut KeyPtr::from(root_key));
+        Ok(())
+    })
+    .unwrap()
+}
diff --git a/crates/storage/src/collections/stash/tests.rs b/crates/storage/src/collections/stash/tests.rs
index 92e3aa6e8d..7f95a7de16 100644
--- a/crates/storage/src/collections/stash/tests.rs
+++ b/crates/storage/src/collections/stash/tests.rs
@@ -13,9 +13,12 @@
 // limitations under the License.
 
 use super::Stash as StorageStash;
-use crate::traits::{
-    KeyPtr,
-    SpreadLayout,
+use crate::{
+    traits::{
+        KeyPtr,
+        SpreadLayout,
+    },
+    Lazy,
 };
 use ink_primitives::Key;
 
@@ -748,3 +751,33 @@ fn spread_layout_clear_works() {
     })
     .unwrap()
 }
+
+#[test]
+fn storage_is_cleared_completely_after_pull_lazy() {
+    ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+        // given
+        let root_key = Key::from([0x42; 32]);
+        let lazy_stash = Lazy::new(create_holey_stash());
+        SpreadLayout::push_spread(&lazy_stash, &mut KeyPtr::from(root_key));
+        let pulled_stash = <Lazy<StorageStash<u8>> as SpreadLayout>::pull_spread(
+            &mut KeyPtr::from(root_key),
+        );
+
+        // when
+        SpreadLayout::clear_spread(&pulled_stash, &mut KeyPtr::from(root_key));
+
+        // then
+        let contract_id = ink_env::test::get_current_contract_account_id::<
+            ink_env::DefaultEnvironment,
+        >()
+        .expect("Cannot yet contract id");
+        let storage_used = ink_env::test::count_used_storage_cells::<
+            ink_env::DefaultEnvironment,
+        >(&contract_id)
+        .expect("used cells must be returned");
+        assert_eq!(storage_used, 0);
+
+        Ok(())
+    })
+    .unwrap()
+}
diff --git a/crates/storage/src/collections/vec/tests.rs b/crates/storage/src/collections/vec/tests.rs
index 00d997d51d..53e17b285e 100644
--- a/crates/storage/src/collections/vec/tests.rs
+++ b/crates/storage/src/collections/vec/tests.rs
@@ -19,6 +19,7 @@ use crate::{
         KeyPtr,
         SpreadLayout,
     },
+    Lazy,
 };
 use ink_primitives::Key;
 
@@ -425,3 +426,72 @@ fn clear_works_on_empty_vec() {
     vec.clear();
     assert!(vec.is_empty());
 }
+
+#[test]
+#[should_panic(expected = "encountered empty storage cell")]
+fn storage_is_cleared_completely_after_pull_lazy() {
+    ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+        // given
+        let root_key = Key::from([0x42; 32]);
+        let mut lazy_vec: Lazy<StorageVec<u32>> = Lazy::new(StorageVec::new());
+        lazy_vec.push(13u32);
+        lazy_vec.push(13u32);
+        SpreadLayout::push_spread(&lazy_vec, &mut KeyPtr::from(root_key));
+        let pulled_vec = <Lazy<StorageVec<u32>> as SpreadLayout>::pull_spread(
+            &mut KeyPtr::from(root_key),
+        );
+
+        // when
+        SpreadLayout::clear_spread(&pulled_vec, &mut KeyPtr::from(root_key));
+
+        // then
+        let contract_id = ink_env::test::get_current_contract_account_id::<
+            ink_env::DefaultEnvironment,
+        >()
+        .expect("Cannot get contract id");
+        let used_cells = ink_env::test::count_used_storage_cells::<
+            ink_env::DefaultEnvironment,
+        >(&contract_id)
+        .expect("used cells must be returned");
+        assert_eq!(used_cells, 0);
+        let _ =
+            *<Lazy<Lazy<u32>> as SpreadLayout>::pull_spread(&mut KeyPtr::from(root_key));
+
+        Ok(())
+    })
+    .unwrap()
+}
+
+#[test]
+#[should_panic(expected = "encountered empty storage cell")]
+fn drop_works() {
+    ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+        let root_key = Key::from([0x42; 32]);
+
+        // if the setup panics it should not cause the test to pass
+        let setup_result = std::panic::catch_unwind(|| {
+            let vec = vec_from_slice(&[b'a', b'b', b'c', b'd']);
+            SpreadLayout::push_spread(&vec, &mut KeyPtr::from(root_key));
+            let _ = <StorageVec<u8> as SpreadLayout>::pull_spread(&mut KeyPtr::from(
+                root_key,
+            ));
+            // vec is dropped which should clear the cells
+        });
+        assert!(setup_result.is_ok(), "setup should not panic");
+
+        let contract_id = ink_env::test::get_current_contract_account_id::<
+            ink_env::DefaultEnvironment,
+        >()
+        .expect("Cannot yet contract id");
+        let used_cells = ink_env::test::count_used_storage_cells::<
+            ink_env::DefaultEnvironment,
+        >(&contract_id)
+        .expect("used cells must be returned");
+        assert_eq!(used_cells, 0);
+
+        let _ =
+            <StorageVec<u8> as SpreadLayout>::pull_spread(&mut KeyPtr::from(root_key));
+        Ok(())
+    })
+    .unwrap()
+}