diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index ed5927c..5b25f97 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -24,3 +24,14 @@ The following changes have been made:
 <!--Delete everything after the "#" symbol and replace it with a number. No spaces between hash and number-->
 
 Closes #\<issue number\>
+
+## Checklist
+
+- [ ] I have linked to any relevant issues.
+- [ ] I have commented my code, particularly in hard-to-understand areas.
+- [ ] I have updated the documentation where relevant (API docs, the reference, and the Sway book).
+   - [ ] If my change requires substantial documentation changes, I have [requested support from the DevRel team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
+- [ ] I have added tests that prove my fix is effective or that my feature works.
+- [ ] I have added (or requested a maintainer to add) the necessary `Breaking*` or `New Feature` labels where relevant.
+- [ ] I have done my best to ensure that my PR adheres to [the Fuel Labs Code Review Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
+- [ ] I have requested a review from the relevant team or maintainers.
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index ea85bbe..08621d4 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -15,9 +15,9 @@ concurrency:
 env:
   CARGO_TERM_COLOR: always
   REGISTRY: ghcr.io
-  RUST_VERSION: 1.75.0
-  FORC_VERSION: 0.56.0
-  CORE_VERSION: 0.24.2
+  RUST_VERSION: 1.77.0
+  FORC_VERSION: 0.60.0
+  CORE_VERSION: 0.26.0
   PATH_TO_SCRIPTS: .github/scripts
 
 jobs:
diff --git a/README.md b/README.md
index 0e5ea80..1b62f12 100644
--- a/README.md
+++ b/README.md
@@ -9,8 +9,8 @@
     <a href="https://github.com/FuelLabs/sway-standards/actions/workflows/ci.yml" alt="CI">
         <img src="https://github.com/FuelLabs/sway-standards/actions/workflows/ci.yml/badge.svg" />
     </a>
-    <a href="https://crates.io/crates/forc/0.49.1" alt="forc">
-        <img src="https://img.shields.io/badge/forc-v0.49.1-orange" />
+    <a href="https://crates.io/crates/forc/0.60.0" alt="forc">
+        <img src="https://img.shields.io/badge/forc-v0.60.0-orange" />
     </a>
     <a href="./LICENSE" alt="forc">
         <img src="https://img.shields.io/github/license/FuelLabs/sway-standards" />
@@ -22,9 +22,9 @@
 
 ## Overview
 
-The purpose of this repository is to contain standards for the Sway Language which users can import and use. 
+The purpose of this repository is to contain standards for the Sway Language which users can import and use.
 
-Standards in this repository may be in various stages of development. Use of draft standards and feedback on the proposed standards is encouraged. To use a draft, search for a standard using the appropriate GitHub label and implement the standard abi into your contract. 
+Standards in this repository may be in various stages of development. Use of draft standards and feedback on the proposed standards is encouraged. To use a draft, search for a standard using the appropriate GitHub label and implement the standard abi into your contract.
 
 If you don't find what you're looking for, feel free to create an issue and propose a new standard!
 
@@ -36,7 +36,7 @@ If you don't find what you're looking for, feel free to create an issue and prop
 ### Native Assets
 
 - [SRC-20; Native Asset Standard](./SRCs/src-20.md) defines the implementation of a standard API for [Native Assets](https://docs.fuel.network/docs/sway/blockchain-development/native_assets) using the Sway Language.
-- [SRC-3; Mint and Burn](./SRCs/src-3.md) is used to enable mint and burn functionality for Native Assets.
+- [SRC-3; Mint and Burn](./SRCs/src-3.md) is used to enable mint and burn functionality for fungible assets.
 - [SRC-7; Arbitrary Asset Metadata Standard](./SRCs/src-7.md) is used to store metadata for [Native Assets](https://docs.fuel.network/docs/sway/blockchain-development/native_assets).
 - [SRC-9; Metadata Keys Standard](./SRCs/src-9.md) is used to store standardized metadata keys for [Native Assets](https://docs.fuel.network/docs/sway/blockchain-development/native_assets) in combination with the SRC-7 standard.
 - [SRC-6; Vault Standard](./SRCs/src-6.md) defines the implementation of a standard API for asset vaults developed in Sway.
@@ -66,7 +66,7 @@ To import a standard the following should be added to the project's `Forc.toml`
 standards = { git = "https://github.com/FuelLabs/sway-standards", tag = "v0.5.0" }
 ```
 
-> **NOTE:** 
+> **NOTE:**
 > Be sure to set the tag to the latest release.
 
 You may then import your desired standard in your Sway Smart Contract as so:
@@ -87,7 +87,7 @@ Minimal example implementations for every standard can be found in the [`example
 
 #### SRC-20; Native Asset Standard Examples
 
-##### - [Single Native Assset](./examples/src20-native-asset/single_asset/src/single_asset.sw)
+##### - [Single Native Asset](./examples/src20-native-asset/single_asset/src/single_asset.sw)
 
 Example of the SRC-20 implementation where a contract contains a single asset with one `SubId`. This implementation is recommended for users that intend to deploy a single asset with their contract.
 
@@ -119,15 +119,15 @@ Example of the SRC-5 implementation where a contract has an owner set at compile
 
 ##### [Multi Asset Vault](./examples/src6-vault/multi_asset_vault/)
 
-A basic implementation of the vault standard that supports any number of sub vaults being created for every AssetId.
+A basic implementation of the vault standard that supports any number of sub vaults being created for every `AssetId`.
 
 ##### [Single Asset Vault](./examples/src6-vault/single_asset_vault/)
 
-A basic implementation of the vault standard demonstrating how to restrict deposits and withdrawals to a single AssetId.
+A basic implementation of the vault standard demonstrating how to restrict deposits and withdrawals to a single `AssetId`.
 
 ##### [Single Asset Single Sub Vault](./examples/src6-vault/single_asset_single_sub_vault/)
 
-A basic implementation of the vault standard demonstrating how to restrict deposits and withdrawals to a single AssetId, and to a single Sub vault.
+A basic implementation of the vault standard demonstrating how to restrict deposits and withdrawals to a single `AssetId`, and to a single Sub vault.
 
 #### SRC-7; Arbitrary Asset Metadata Standard Examples
 
@@ -147,10 +147,10 @@ Example of the SRC-12 implementation where contract deployments contain configur
 
 ##### [Without Configurables](./examples/src12-contract-factory/without_configurables/src/without_configurables.sw)
 
-Example of the SRC-12 implementation where all contract deployments are identitcal and thus have the same bytecode and root.
+Example of the SRC-12 implementation where all contract deployments are identical and thus have the same bytecode and root.
 
 > **Note**
-> All standards currently use `forc v0.56.0`.
+> All standards currently use `forc v0.60.0`.
 
 <!-- TODO:
 ## Contributing
diff --git a/SRCs/src-10.md b/SRCs/src-10.md
index d2be57e..c887886 100644
--- a/SRCs/src-10.md
+++ b/SRCs/src-10.md
@@ -98,7 +98,7 @@ The `token_address` field MUST represent the bridged token's address on the cano
 
 #### - token_id: `b256`
 
-The `token_id` field MUST represent the token's ID on the canonical chain. The `ZERO_B256` MUST be used if this is a fungible token and no token ID exists.
+The `token_id` field MUST represent the token's ID on the canonical chain. The `b256::zero()` MUST be used if this is a fungible token and no token ID exists.
 
 #### - decimals: `u8`
 
@@ -132,7 +132,7 @@ The `token_address` field MUST represent the bridged token's address on the cano
 
 #### token_id: `b256`
 
-The `token_id` field MUST represent the token's ID on the canonical chain. The `ZERO_B256` MUST be used if this is a fungible token and no token ID exists.
+The `token_id` field MUST represent the token's ID on the canonical chain. The `b256::zero()` MUST be used if this is a fungible token and no token ID exists.
 
 #### name: `String`
 
diff --git a/SRCs/src-14.md b/SRCs/src-14.md
new file mode 100644
index 0000000..5918a8e
--- /dev/null
+++ b/SRCs/src-14.md
@@ -0,0 +1,80 @@
+# Simple Upgradable Proxies
+
+## Abstract
+
+The following proposes a standard for simple upgradable proxies.
+
+## Motivation
+
+We seek to standardize proxy implementation to improve developer experience and enable tooling to automatically deploy or update proxies as needed.
+
+## Prior Art
+
+[This OpenZeppelin blog post](https://blog.openzeppelin.com/the-state-of-smart-contract-upgrades#proxies-and-implementations) is a good survey of the state of the art at this time.
+
+Proxy designs fall into three essential categories:
+1. Immutable proxies which are lightweight clones of other contracts but can't change targets
+2. Upgradable proxies such as [UUPS](https://eips.ethereum.org/EIPS/eip-1822) which store a target in storage and delegate all calls to it
+3. [Diamonds](https://eips.ethereum.org/EIPS/eip-2535) which are both upgradable and can point to multiple targets on a per method basis
+
+This document falls in the second category. We want to standardize the implementation of simple upgradable passthrough contracts.
+
+The FuelVM provides an `LDC` instruction that is used by Sway's `std::execution::run_external` to provide a similar behavior to EVM's `delegatecall` and execute instructions from another contract while retaining one's own storage context. This is the intended means of implementation of this standard.
+
+## Specification
+
+### Required Behavior
+
+The proxy contract MUST maintain the address of its target in its storage at slot `0x7bb458adc1d118713319a5baa00a2d049dd64d2916477d2688d76970c898cd55` (equivalent to `sha256("storage_SRC14_0")`).
+It SHOULD base other proxy specific storage fields at `sha256("storage_SRC14")` to avoid collisions with target storage.
+It MAY have its storage definition overlap with that of its target if necessary.
+
+The proxy contract MUST delegate any method call not part of its interface to the target contract.
+
+This delegation MUST retain the storage context of the proxy contract.
+
+### Required Public Functions
+
+The following functions MUST be implemented by a proxy contract to follow the SRC-14 standard:
+
+#### `fn set_proxy_target(new_target: ContractId);`
+
+If a valid call is made to this function it MUST change the target address of the proxy to `new_target`.
+This method SHOULD implement access controls such that the target can only be changed by a user that possesses the right permissions (typically the proxy owner).
+
+## Rationale
+
+This standard is meant to provide simple upgradability, it is deliberately minimalistic and does not provide the level of functionality of diamonds.
+
+Unlike in [UUPS](https://eips.ethereum.org/EIPS/eip-1822), this standard requires that the upgrade function is part of the proxy and not its target.
+This prevents irrecoverable updates if a proxy is made to point to another proxy and no longer has access to upgrade logic.
+
+## Backwards Compatibility
+
+SRC-14 is intended to be compatible with SRC-5 and other standards of contract functionality.
+
+As it is the first attempt to standardize proxy implementation, we do not consider interoperability with other proxy standards.
+
+## Security Considerations
+
+Permissioning proxy target changes is the primary consideration here.
+This standard is not opinionated about means of achieving this, use of [SRC-5](https://github.com/FuelLabs/sway-standards/blob/master/SRCs/src-5.md) is recommended.
+
+## Example ABI
+
+```sway
+abi SRC14 {
+    #[storage(write)]
+    fn set_proxy_target(new_target: ContractId);
+}
+```
+
+## Example Implementation
+
+### [Minimal Proxy](../examples/examples/src14-simple-proxy/owned/src/minimal.sw)
+
+Example of a minimal SRC-14 implementation with no access control.
+
+### [Owned Proxy](../examples/examples/src14-simple-proxy/owned/src/owned.sw)
+
+Example of a SRC-14 implementation that also implements [SRC-5](https://github.com/FuelLabs/sway-standards/blob/master/SRCs/src-5.md).
diff --git a/SRCs/src-2.md b/SRCs/src-2.md
index a7e7838..bd1210d 100644
--- a/SRCs/src-2.md
+++ b/SRCs/src-2.md
@@ -331,7 +331,7 @@ This standard will improve security by providing developers with relevant inform
 /// use ownable::Ownership;
 ///
 /// storage {
-///     owner: Ownership = Ownership::initalized(Identity::Address(Address::from(ZERO_B256))),
+///     owner: Ownership = Ownership::initalized(Identity::Address(Address::zero())),
 /// }
 ///
 /// fn foo() {
diff --git a/SRCs/src-20.md b/SRCs/src-20.md
index 49bcdbb..c68ed9c 100644
--- a/SRCs/src-20.md
+++ b/SRCs/src-20.md
@@ -11,13 +11,13 @@ The following standard allows for the implementation of a standard API for [Nati
 
 # Motivation
 
-A standard interface for [Native Assets](https://docs.fuel.network/docs/sway/blockchain-development/native_assets) on Fuel allows external applications to interact with the native asset, whether that be decentralized exchanges, wallets, or Fuel's [Scripts](https://docs.fuel.network/docs/sway/sway-program-types/scripts/) and [Predicates](https://docs.fuel.network/docs/sway/sway-program-types/predicates/). 
+A standard interface for [Native Assets](https://docs.fuel.network/docs/sway/blockchain-development/native_assets) on Fuel allows external applications to interact with the native asset, whether that be decentralized exchanges, wallets, or Fuel's [Scripts](https://docs.fuel.network/docs/sway/sway-program-types/scripts/) and [Predicates](https://docs.fuel.network/docs/sway/sway-program-types/predicates/).
 
 # Prior Art
 
 The SRC-20 Native Asset Standard naming pays homage to the [ERC-20 Token Standard](https://eips.ethereum.org/EIPS/eip-20) seen on Ethereum. While there is functionality we may use as a reference, it is noted that Fuel's [Native Assets](https://docs.fuel.network/docs/sway/blockchain-development/native_assets) are fundamentally different than Ethereum's tokens.
 
-There has been a discussion of the Fungile Token Standard on the [Fuel Forum](https://forum.fuel.network/). This discussion can be found [here](https://forum.fuel.network/t/src-20-fungible-token-standard/186). 
+There has been a discussion of the Fungible Token Standard on the [Fuel Forum](https://forum.fuel.network/). This discussion can be found [here](https://forum.fuel.network/t/src-20-fungible-token-standard/186). 
 
 There has also been a Fungible Token Standard and Non-Fungible Token Standard implementations added to the [Sway-Libs](https://github.com/FuelLabs/sway-libs) repository before the creation of the [Sway-Standards](https://github.com/FuelLabs/sway-standards) repository. The introduction of this standard in the [Sway-Standards](https://github.com/FuelLabs/sway-standards) repository will deprecate the Sway-Libs Fungible Token Standard.
 
@@ -47,7 +47,7 @@ This function must return the symbol of the asset, such as “ETH”. This funct
 
 This function must return the number of decimals the asset uses - e.g. 8, which means to divide the coin amount by 100000000 to get its user representation. This function MUST return `Some` for any assets minted by the contract.
 
-## Non-Fungible Asset Restrictions 
+## Non-Fungible Asset Restrictions
 
 Non-Fungible Tokens (NFT) or Non-Fungible Assets on Fuel are Native Assets and thus follow the same standard as Fungible Native Assets with some restrictions. For a Native Asset on Fuel to be deemed an NFT, the following must be applied:
 
@@ -56,9 +56,9 @@ Non-Fungible Tokens (NFT) or Non-Fungible Assets on Fuel are Native Assets and t
 
 # Rationale
 
-As the SRC-20 Native Asset Standard leverages Native Assets on Fuel, we do not require the implementation of certain functions such as transfer or approval. This is done directly within the FuelVM and there is no smart contract that requires updating of balances. As Fuel is UTXO based, any transfer events may be indexed on transaction receipts. 
+As the SRC-20 Native Asset Standard leverages Native Assets on Fuel, we do not require the implementation of certain functions such as transfer or approval. This is done directly within the FuelVM and there is no smart contract that requires updating of balances. As Fuel is UTXO based, any transfer events may be indexed on transaction receipts.
 
-Following this, we have omitted the inclusion of any transfer functions or events. The provided specification outlines only the required functions and events to implement fully functional native assets on the Fuel Network. Additional functionality and properties may be added as needed.
+Following this, we have omitted the inclusion of any transfer functions or events. The provided specification outlines only the functions necessary to implement fully functional native assets on the Fuel Network. Additional functionality and properties may be added as needed.
 
 # Backwards Compatibility
 
@@ -87,7 +87,7 @@ abi MyAsset {
 
 # Example Implementation
 
-## [Single Native Assset](../examples/src20-native-asset/multi_asset/src/multi_asset.sw)
+## [Single Native Asset](../examples/src20-native-asset/multi_asset/src/multi_asset.sw)
 
 Example of the SRC-20 implementation where a contract contains a single asset with one `SubId`. This implementation is recommended for users that intend to deploy a single asset with their contract.
 
diff --git a/SRCs/src-3.md b/SRCs/src-3.md
index 5c97d0d..0b9cb78 100644
--- a/SRCs/src-3.md
+++ b/SRCs/src-3.md
@@ -1,6 +1,6 @@
 # Abstract
 
-The following standard enables the minting and burning of native assets for any fungible assets within the Sway Language. It seeks to define mint and burn functions defined separately from the [SRC-20](./src-20.md) standard. Any contract that implements the SRC-3 standard MUST implement the [SRC-20](./src-20.md) standard.
+The following standard enables the minting and burning of native assets for any fungible assets within the Sway Language. It seeks to define mint and burn functions defined separately from the [SRC-20](./src-20.md) standard.
 
 # Motivation
 
@@ -16,27 +16,27 @@ Minting and burning were initially added to the [SRC-20](./src-20.md) standard.
 
 The following functions MUST be implemented to follow the SRC-3 standard:
 
-### `fn mint(recipient: Identity, vault_sub_id: SubId, amount: u64)`
+### `fn mint(recipient: Identity, sub_id: SubId, amount: u64)`
 
-This function MUST mint `amount` coins with sub-identifier `vault_sub_id` and transfer them to the `recipient`. 
+This function MUST mint `amount` coins with sub-identifier `sub_id` and transfer them to the `recipient`. 
 This function MAY contain arbitrary conditions for minting, and revert if those conditions are not met.
 
 ##### Arguments
 
 * `recipient` - The `Identity` to which the newly minted asset is transferred to.
-* `vault_sub_id` - The sub-identifier of the asset to mint.
+* `sub_id` - The sub-identifier of the asset to mint.
 * `amount` - The quantity of coins to mint.
 
-### `fn burn(vault_sub_id: SubId, amount: u64)`
+### `fn burn(sub_id: SubId, amount: u64)`
 
-This function MUST burn `amount` coins with the sub-identifier `vault_sub_id` and MUST ensure the `AssetId` of the asset is the sha-256 hash of `(ContractId, SubId)` for the implementing contract. 
+This function MUST burn `amount` coins with the sub-identifier `sub_id` and MUST ensure the `AssetId` of the asset is the sha-256 hash of `(ContractId, SubId)` for the implementing contract. 
 This function MUST ensure at least `amount` coins have been transferred to the implementing contract. 
 This function MUST update the total supply defined in the [SRC-20](./src-20.md) standard. 
 This function MAY contain arbitrary conditions for burning, and revert if those conditions are not met.
 
 ##### Arguments
 
-* `vault_sub_id` - The sub-identifier of the asset to burn.
+* `sub_id` - The sub-identifier of the asset to burn.
 * `amount` - The quantity of coins to burn.
 
 # Rationale
@@ -57,10 +57,10 @@ The burn function may also introduce a security consideration if the total suppl
 ```rust
 abi MySRC3Asset {
     #[storage(read, write)]
-    fn mint(recipient: Identity, vault_sub_id: SubId, amount: u64);
+    fn mint(recipient: Identity, sub_id: SubId, amount: u64);
     #[payable]
     #[storage(read, write)]
-    fn burn(vault_sub_id: SubId, amount: u64);
+    fn burn(sub_id: SubId, amount: u64);
 }
 ```
 
diff --git a/SRCs/src-8.md b/SRCs/src-8.md
index 1b61ddf..cc336b9 100644
--- a/SRCs/src-8.md
+++ b/SRCs/src-8.md
@@ -26,7 +26,7 @@ The `SubId` of the asset MUST be the digest of the `sha256(origin_chain_id, orig
 
 - `origin_chain_id` is a `String` of the chain ID where the asset was originally minted.
 - `origin_asset_address` is a `b256` of the asset's address on the chain where the asset was originally minted.
-- `origin_asset_id` is a `b256` of the asset's ID such as an NFT's ID on the chain where the asset was originally minted. IF there is no ID, `ZERO_B256` SHALL be used.
+- `origin_asset_id` is a `b256` of the asset's ID such as an NFT's ID on the chain where the asset was originally minted. IF there is no ID, `b256::zero()` SHALL be used.
 
 ## SRC-20 Metadata
 
@@ -40,7 +40,7 @@ The key `bridged:chain` SHALL return an `String` variant of the chain ID where t
 
 ### - `bridged:address`
 
-The key `bridged:address` SHALL return a `B256` variant of the asset's address on the chain where the asset was originally minted. Native assets of a chain that do not have an address such as Ether on Ethereum SHALL use `ZERO_B256`.
+The key `bridged:address` SHALL return a `B256` variant of the asset's address on the chain where the asset was originally minted. Native assets of a chain that do not have an address such as Ether on Ethereum SHALL use `b256::zero()`.
 
 ### - `bridged:id`
 
@@ -69,7 +69,7 @@ This standard does not call external contracts, nor does it define any mutations
 ```rust
 impl SRC7 for Contract {
     fn metadata(asset: AssetId, key: String) -> Option<Metadata> {
-        if (asset != AssetId::from(ZERO_B256)) {
+        if (asset != AssetId::default()) {
             return Option::None;
         }
 
@@ -78,11 +78,11 @@ impl SRC7 for Contract {
                 Option::Some(String::from_ascii_str("1"))
             },
             String::from_ascii_str("bridged:address") => {
-                let origin_asset_address = ZERO_B256;
+                let origin_asset_address = b256::zero();
                 Option::Some(Metadata::B256(origin_asset_address))
             },
             String::from_ascii_str("bridged:id") => {
-                let origin_asset_id = ZERO_B256;
+                let origin_asset_id = b256::zero();
                 Option::Some(Metadata::B256(origin_asset_id))
             },
             String::from_ascii_str("bridged:decimals") => {
@@ -100,28 +100,28 @@ impl SRC20 for Contract {
 
     fn total_supply(asset: AssetId) -> Option<u64> {
         match asset { 
-            AssetId::from(ZERO_B256) => Option::Some(1),
+            AssetId::default() => Option::Some(1),
             _ => Option::None,
         }
     }
 
     fn name(asset: AssetId) -> Option<String> {
         match asset { 
-            AssetId::from(ZERO_B256) => Option::Some(String::from_ascii_str("Name")),
+            AssetId::default() => Option::Some(String::from_ascii_str("Name")),
             _ => Option::None,
         }
     }
 
     fn symbol(asset: AssetId) -> Option<String> {
         match asset { 
-            AssetId::from(ZERO_B256) => Option::Some(String::from_ascii_str("Symbol")),
+            AssetId::default() => Option::Some(String::from_ascii_str("Symbol")),
             _ => Option::None,
         }
     }
 
     fn decimals(asset: AssetId) -> Option<u8> {
         match asset { 
-            AssetId::from(ZERO_B256) => Option::Some(0u8),
+            AssetId::default() => Option::Some(0u8),
             _ => Option::None,
         }
     }
diff --git a/SRCs/src-9.md b/SRCs/src-9.md
index fafc2b1..a355ba1 100644
--- a/SRCs/src-9.md
+++ b/SRCs/src-9.md
@@ -357,7 +357,7 @@ This standard does not call external contracts, nor does it define any mutations
 ```rust
 impl SRC7 for Contract {
     fn metadata(asset: AssetId, key: String) -> Option<Metadata> {
-        if (asset != AssetId::from(ZERO_B256)) {
+        if (asset != AssetId::default()) {
             return Option::None;
         }
 
diff --git a/examples/Forc.toml b/examples/Forc.toml
index 6521e5a..4f5338f 100644
--- a/examples/Forc.toml
+++ b/examples/Forc.toml
@@ -13,6 +13,8 @@ members = [
   "src11-security-information/variable-information",
   "src12-contract-factory/with_configurables",
   "src12-contract-factory/without_configurables",
+  "src14-simple-proxy/owned",
+  "src14-simple-proxy/minimal",
   "src20-native-asset/single_asset",
   "src20-native-asset/multi_asset",
 ]
diff --git a/examples/src11-security-information/hardcoded-information/src/main.sw b/examples/src11-security-information/hardcoded-information/src/main.sw
index 13e1178..fcabcae 100644
--- a/examples/src11-security-information/hardcoded-information/src/main.sw
+++ b/examples/src11-security-information/hardcoded-information/src/main.sw
@@ -4,25 +4,24 @@ use standards::src11::{SecurityInformation, SRC11};
 
 use std::{string::String, vec::Vec,};
 
-configurable {
-    /// The name of the project
-    NAME: str[7] = __to_str_array("Example"),
-    /// The URL of the project
-    PROJECT_URL: str[19] = __to_str_array("https://example.com"),
-    /// The contact information of the project
-    CONTACT1: str[25] = __to_str_array("email:example@example.com"),
-    CONTACT2: str[41] = __to_str_array("link:https://example.com/security_contact"),
-    CONTACT3: str[20] = __to_str_array("discord:example#1234"),
-    /// The security policy of the project
-    POLICY: str[35] = __to_str_array("https://example.com/security_policy"),
-    /// The preferred languages of the project
-    PREFERRED_LANGUAGES1: str[2] = __to_str_array("en"),
-    PREFERRED_LANGUAGES2: str[2] = __to_str_array("ja"),
-    PREFERRED_LANGUAGES3: str[2] = __to_str_array("zh"),
-    PREFERRED_LANGUAGES4: str[2] = __to_str_array("hi"),
-    /// The encryption key of the project
-    ENCRYPTION: str[751] = __to_str_array(
-        "-----BEGIN PGP PUBLIC KEY BLOCK-----
+/// The name of the project
+const NAME: str[7] = __to_str_array("Example");
+/// The URL of the project
+const PROJECT_URL: str[19] = __to_str_array("https://example.com");
+/// The contact information of the project
+const CONTACT1: str[25] = __to_str_array("email:example@example.com");
+const CONTACT2: str[41] = __to_str_array("link:https://example.com/security_contact");
+const CONTACT3: str[20] = __to_str_array("discord:example#1234");
+/// The security policy of the project
+const POLICY: str[35] = __to_str_array("https://example.com/security_policy");
+/// The preferred languages of the project
+const PREFERRED_LANGUAGES1: str[2] = __to_str_array("en");
+const PREFERRED_LANGUAGES2: str[2] = __to_str_array("ja");
+const PREFERRED_LANGUAGES3: str[2] = __to_str_array("zh");
+const PREFERRED_LANGUAGES4: str[2] = __to_str_array("hi");
+/// The encryption key of the project
+const ENCRYPTION: str[751] = __to_str_array(
+    "-----BEGIN PGP PUBLIC KEY BLOCK-----
 Comment: Alice's OpenPGP certificate
 Comment: https://www.ietf.org/id/draft-bre-openpgp-samples-01.html
 
@@ -37,20 +36,20 @@ DAAKCRDyMVUMT0fjjlnQAQDFHUs6TIcxrNTtEZFjUFm1M0PJ1Dng/cDW4xN80fsn
 0QEA22Kr7VkCjeAEC08VSTeV+QFsmz55/lntWkwYWhmvOgE=
 =iIGO
 -----END PGP PUBLIC KEY BLOCK-----",
-    ),
-    /// The URL of the project's source code
-    SOURCE_CODE: str[31] = __to_str_array("https://github.com/example/test"),
-    /// The release identifier of this build
-    SOURCE_RELEASE: str[6] = __to_str_array("v1.0.0"),
-    /// The revision identifier of this build
-    SOURCE_REVISION: str[12] = __to_str_array("a1b2c3d4e5f6"),
-    /// The URL of the project's auditors
-    AUDITORS: str[28] = __to_str_array("https://example.com/auditors"),
-    /// The URL of the project's acknowledgements
-    ACKNOWLEDGEMENTS: str[36] = __to_str_array("https://example.com/acknowledgements"),
-    /// The URL of the project's additional information
-    ADDITIONAL_INFORMATION: str[42] = __to_str_array("https://example.com/additional_information"),
-}
+);
+/// The URL of the project's source code
+const SOURCE_CODE: str[31] = __to_str_array("https://github.com/example/test");
+/// The release identifier of this build
+const SOURCE_RELEASE: str[6] = __to_str_array("v1.0.0");
+/// The revision identifier of this build
+const SOURCE_REVISION: str[12] = __to_str_array("a1b2c3d4e5f6");
+/// The URL of the project's auditors
+const AUDITORS: str[28] = __to_str_array("https://example.com/auditors");
+/// The URL of the project's acknowledgements
+const ACKNOWLEDGEMENTS: str[36] = __to_str_array("https://example.com/acknowledgements");
+/// The URL of the project's additional information
+const ADDITIONAL_INFORMATION: str[42] = __to_str_array("https://example.com/additional_information");
+
 impl SRC11 for Contract {
     #[storage(read)]
     fn security_information() -> SecurityInformation {
diff --git a/examples/src11-security-information/variable-information/src/main.sw b/examples/src11-security-information/variable-information/src/main.sw
index a3e078b..b2d3f88 100644
--- a/examples/src11-security-information/variable-information/src/main.sw
+++ b/examples/src11-security-information/variable-information/src/main.sw
@@ -4,21 +4,20 @@ use standards::src11::{SecurityInformation, SRC11};
 
 use std::{storage::{storage_string::*, storage_vec::*,}, string::String, vec::Vec,};
 
-configurable {
-    /// The name of the project
-    NAME: str[7] = __to_str_array("Example"),
-    /// The URL of the project
-    PROJECT_URL: str[19] = __to_str_array("https://example.com"),
-    /// The security policy of the project
-    POLICY: str[35] = __to_str_array("https://example.com/security_policy"),
-    /// The preferred languages of the project
-    PREFERRED_LANGUAGES1: str[2] = __to_str_array("en"),
-    PREFERRED_LANGUAGES2: str[2] = __to_str_array("ja"),
-    PREFERRED_LANGUAGES3: str[2] = __to_str_array("zh"),
-    PREFERRED_LANGUAGES4: str[2] = __to_str_array("hi"),
-    /// The encryption key of the project
-    ENCRYPTION: str[751] = __to_str_array(
-        "-----BEGIN PGP PUBLIC KEY BLOCK-----
+/// The name of the project
+const NAME: str[7] = __to_str_array("Example");
+/// The URL of the project
+const PROJECT_URL: str[19] = __to_str_array("https://example.com");
+/// The security policy of the project
+const POLICY: str[35] = __to_str_array("https://example.com/security_policy");
+/// The preferred languages of the project
+const PREFERRED_LANGUAGES1: str[2] = __to_str_array("en");
+const PREFERRED_LANGUAGES2: str[2] = __to_str_array("ja");
+const PREFERRED_LANGUAGES3: str[2] = __to_str_array("zh");
+const PREFERRED_LANGUAGES4: str[2] = __to_str_array("hi");
+/// The encryption key of the project
+const ENCRYPTION: str[751] = __to_str_array(
+    "-----BEGIN PGP PUBLIC KEY BLOCK-----
 Comment: Alice's OpenPGP certificate
 Comment: https://www.ietf.org/id/draft-bre-openpgp-samples-01.html
 
@@ -33,20 +32,19 @@ DAAKCRDyMVUMT0fjjlnQAQDFHUs6TIcxrNTtEZFjUFm1M0PJ1Dng/cDW4xN80fsn
 0QEA22Kr7VkCjeAEC08VSTeV+QFsmz55/lntWkwYWhmvOgE=
 =iIGO
 -----END PGP PUBLIC KEY BLOCK-----",
-    ),
-    /// The URL of the project's source code
-    SOURCE_CODE: str[31] = __to_str_array("https://github.com/example/test"),
-    /// The release identifier of this build
-    SOURCE_RELEASE: str[6] = __to_str_array("v1.0.0"),
-    /// The revision identifier of this build
-    SOURCE_REVISION: str[12] = __to_str_array("a1b2c3d4e5f6"),
-    /// The URL of the project's auditors
-    AUDITORS: str[28] = __to_str_array("https://example.com/auditors"),
-    /// The URL of the project's acknowledgements
-    ACKNOWLEDGEMENTS: str[36] = __to_str_array("https://example.com/acknowledgements"),
-    /// The URL of the project's additional information
-    ADDITIONAL_INFORMATION: str[42] = __to_str_array("https://example.com/additional_information"),
-}
+);
+/// The URL of the project's source code
+const SOURCE_CODE: str[31] = __to_str_array("https://github.com/example/test");
+/// The release identifier of this build
+const SOURCE_RELEASE: str[6] = __to_str_array("v1.0.0");
+/// The revision identifier of this build
+const SOURCE_REVISION: str[12] = __to_str_array("a1b2c3d4e5f6");
+/// The URL of the project's auditors
+const AUDITORS: str[28] = __to_str_array("https://example.com/auditors");
+/// The URL of the project's acknowledgements
+const ACKNOWLEDGEMENTS: str[36] = __to_str_array("https://example.com/acknowledgements");
+/// The URL of the project's additional information
+const ADDITIONAL_INFORMATION: str[42] = __to_str_array("https://example.com/additional_information");
 
 storage {
     /// The contact information for the security contact.
diff --git a/examples/src12-contract-factory/with_configurables/src/with_configurables.sw b/examples/src12-contract-factory/with_configurables/src/with_configurables.sw
index 841c48e..a867b80 100644
--- a/examples/src12-contract-factory/with_configurables/src/with_configurables.sw
+++ b/examples/src12-contract-factory/with_configurables/src/with_configurables.sw
@@ -4,18 +4,10 @@ mod utils;
 
 use utils::{_compute_bytecode_root, _swap_configurables};
 use standards::src12::*;
-use std::{
-    constants::ZERO_B256,
-    external::bytecode_root,
-    hash::{
-        Hash,
-        sha256,
-    },
-    storage::storage_vec::*,
-};
+use std::{external::bytecode_root, hash::{Hash, sha256,}, storage::storage_vec::*,};
 
 configurable {
-    TEMPLATE_BYTECODE_ROOT: b256 = ZERO_B256,
+    TEMPLATE_BYTECODE_ROOT: b256 = b256::zero(),
 }
 
 storage {
@@ -149,12 +141,11 @@ impl SRC12 for Contract {
     ///
     /// ```sway
     /// use src12::SRC12;
-    /// use std::constants::ZERO_B256;
     ///
     /// fn foo(my_src_12_contract: ContractId) {
     ///     let src_12_contract_abi = abi(SRC12, my_src_12_contract.bits());
     ///     let root = src_12_contract_abi.factory_bytecode_root();
-    ///     assert(root.unwrap() != ZERO_B256);
+    ///     assert(root.unwrap() != b256::zero());
     /// }
     /// ```
     #[storage(read)]
diff --git a/examples/src12-contract-factory/without_configurables/src/without_configurables.sw b/examples/src12-contract-factory/without_configurables/src/without_configurables.sw
index 932c443..a30de7f 100644
--- a/examples/src12-contract-factory/without_configurables/src/without_configurables.sw
+++ b/examples/src12-contract-factory/without_configurables/src/without_configurables.sw
@@ -1,10 +1,10 @@
 contract;
 
 use standards::src12::*;
-use std::{constants::ZERO_B256, external::bytecode_root, hash::Hash,};
+use std::{external::bytecode_root, hash::Hash,};
 
 configurable {
-    TEMPLATE_BYTECODE_ROOT: b256 = ZERO_B256,
+    TEMPLATE_BYTECODE_ROOT: b256 = b256::zero(),
 }
 
 storage {
@@ -105,12 +105,11 @@ impl SRC12 for Contract {
     ///
     /// ```sway
     /// use src12::SRC12;
-    /// use std::constants::ZERO_B256;
     ///
     /// fn foo(my_src_12_contract: ContractId) {
     ///     let src_12_contract_abi = abi(SRC12, my_src_12_contract.bits());
     ///     let root = src_12_contract_abi.factory_bytecode_root();
-    ///     assert(root.unwrap() != ZERO_B256);
+    ///     assert(root.unwrap() != b256::zero());
     /// }
     /// ```
     #[storage(read)]
diff --git a/examples/src14-simple-proxy/minimal/Forc.toml b/examples/src14-simple-proxy/minimal/Forc.toml
new file mode 100644
index 0000000..927fbc1
--- /dev/null
+++ b/examples/src14-simple-proxy/minimal/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "minimal.sw"
+license = "Apache-2.0"
+name = "minimal_src14"
+
+[dependencies]
+standards = { path = "../../../standards" }
diff --git a/examples/src14-simple-proxy/minimal/src/minimal.sw b/examples/src14-simple-proxy/minimal/src/minimal.sw
new file mode 100644
index 0000000..89b490d
--- /dev/null
+++ b/examples/src14-simple-proxy/minimal/src/minimal.sw
@@ -0,0 +1,26 @@
+contract;
+
+use std::execution::run_external;
+use std::constants::ZERO_B256;
+use standards::src14::SRC14;
+
+// use sha256("storage_SRC14") as base to avoid collisions
+#[namespace(SRC14)]
+storage {
+    // target is at sha256("storage_SRC14_0")
+    target: ContractId = ContractId::from(ZERO_B256),
+}
+
+impl SRC14 for Contract {
+    #[storage(write)]
+    fn set_proxy_target(new_target: ContractId) {
+        storage.target.write(new_target);
+    }
+}
+
+#[fallback]
+#[storage(read)]
+fn fallback() {
+    // pass through any other method call to the target
+    run_external(storage.target.read())
+}
diff --git a/examples/src14-simple-proxy/owned/Forc.toml b/examples/src14-simple-proxy/owned/Forc.toml
new file mode 100644
index 0000000..b6f3f00
--- /dev/null
+++ b/examples/src14-simple-proxy/owned/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "owned.sw"
+license = "Apache-2.0"
+name = "owned_src14"
+
+[dependencies]
+standards = { path = "../../../standards" }
diff --git a/examples/src14-simple-proxy/owned/src/owned.sw b/examples/src14-simple-proxy/owned/src/owned.sw
new file mode 100644
index 0000000..bbba63a
--- /dev/null
+++ b/examples/src14-simple-proxy/owned/src/owned.sw
@@ -0,0 +1,49 @@
+contract;
+
+use std::execution::run_external;
+use std::constants::ZERO_B256;
+use standards::src5::{AccessError, SRC5, State};
+use standards::src14::SRC14;
+
+/// The owner of this contract at deployment.
+const INITIAL_OWNER: Identity = Identity::Address(Address::from(ZERO_B256));
+
+// use sha256("storage_SRC14") as base to avoid collisions
+#[namespace(SRC14)]
+storage {
+    // target is at sha256("storage_SRC14_0")
+    target: ContractId = ContractId::from(ZERO_B256),
+    owner: State = State::Initialized(INITIAL_OWNER),
+}
+
+impl SRC5 for Contract {
+    #[storage(read)]
+    fn owner() -> State {
+        storage.owner.read()
+    }
+}
+
+impl SRC14 for Contract {
+    #[storage(write)]
+    fn set_proxy_target(new_target: ContractId) {
+        only_owner();
+        storage.target.write(new_target);
+    }
+}
+
+#[fallback]
+#[storage(read)]
+fn fallback() {
+    // pass through any other method call to the target
+    run_external(storage.target.read())
+}
+
+#[storage(read)]
+fn only_owner() {
+    require(
+        storage
+            .owner
+            .read() == State::Initialized(msg_sender().unwrap()),
+        AccessError::NotOwner,
+    );
+}
diff --git a/examples/src5-ownership/initialized_example/src/initialized_example.sw b/examples/src5-ownership/initialized_example/src/initialized_example.sw
index dae9f36..f9cfe60 100644
--- a/examples/src5-ownership/initialized_example/src/initialized_example.sw
+++ b/examples/src5-ownership/initialized_example/src/initialized_example.sw
@@ -1,12 +1,9 @@
 contract;
 
 use standards::src5::{SRC5, State};
-use std::constants::ZERO_B256;
 
-configurable {
-    /// The owner of this contract at deployment.
-    INITIAL_OWNER: Identity = Identity::Address(Address::from(ZERO_B256)),
-}
+/// The owner of this contract at deployment.
+const INITIAL_OWNER: Identity = Identity::Address(Address::zero());
 
 storage {
     /// The owner in storage.
diff --git a/examples/src6-vault/single_asset_single_sub_vault/src/main.sw b/examples/src6-vault/single_asset_single_sub_vault/src/main.sw
index f5e8b8e..fedd56d 100644
--- a/examples/src6-vault/single_asset_single_sub_vault/src/main.sw
+++ b/examples/src6-vault/single_asset_single_sub_vault/src/main.sw
@@ -3,7 +3,6 @@ contract;
 use std::{
     asset::transfer,
     call_frames::msg_asset_id,
-    constants::ZERO_B256,
     context::msg_amount,
     hash::{
         Hash,
@@ -17,7 +16,7 @@ use standards::{src20::SRC20, src6::{Deposit, SRC6, Withdraw}};
 
 configurable {
     /// The only sub vault that can be deposited and withdrawn from this vault.
-    ACCEPTED_SUB_VAULT: SubId = ZERO_B256,
+    ACCEPTED_SUB_VAULT: SubId = SubId::zero(),
     PRE_CALCULATED_SHARE_VAULT_SUB_ID: SubId = 0xf5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b,
 }
 
diff --git a/standards/src/src12.sw b/standards/src/src12.sw
index c261171..6304599 100644
--- a/standards/src/src12.sw
+++ b/standards/src/src12.sw
@@ -68,12 +68,11 @@ abi SRC12 {
     ///
     /// ```sway
     /// use src12::SRC12;
-    /// use std::constants::ZERO_B256;
     ///
     /// fn foo(my_src_12_contract: ContractId) {
     ///     let src_12_contract_abi = abi(SRC12, my_src_12_contract.bits());
     ///     let root = src_12_contract_abi.factory_bytecode_root();
-    ///     assert(root.unwrap() != ZERO_B256);
+    ///     assert(root.unwrap() != b256::zero());
     /// }
     /// ```
     #[storage(read)]
diff --git a/standards/src/src14.sw b/standards/src/src14.sw
new file mode 100644
index 0000000..0ee667e
--- /dev/null
+++ b/standards/src/src14.sw
@@ -0,0 +1,28 @@
+library;
+
+abi SRC14 {
+    /// Change the target address of a proxy contract.
+    ///
+    /// # Arguments
+    ///
+    /// * `new_target`: [ContractId] - The new proxy contract to which all fallback calls will be passed.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// use src14::SRC14;
+    ///
+    /// fn foo(contract_id: ContractId) {
+    ///     let contract_abi = abi(SRC14, contract_id.bits());
+    ///     let new_target = ContractId::from(0x4a778acfad1abc155a009dc976d2cf0db6197d3d360194d74b1fb92b96986b00);
+    ///     contract_abi.set_proxy_target(new_target);
+    /// }
+    /// ```
+    #[storage(write)]
+    fn set_proxy_target(new_target: ContractId);
+}
+
+/// The standard storage slot to store proxy target address.
+///
+/// Value is `sha256("storage_SRC14_0")`.
+pub const SRC14_TARGET_STORAGE: b256 = 0x7bb458adc1d118713319a5baa00a2d049dd64d2916477d2688d76970c898cd55;
diff --git a/standards/src/src3.sw b/standards/src/src3.sw
index eb52e00..f8c42b8 100644
--- a/standards/src/src3.sw
+++ b/standards/src/src3.sw
@@ -1,12 +1,12 @@
 library;
 
 abi SRC3 {
-    /// Mints new assets using the `vault_sub_id` sub-identifier.
+    /// Mints new assets using the `sub_id` sub-identifier.
     ///
     /// # Arguments
     ///
     /// * `recipient`: [Identity] - The user to which the newly minted asset is transferred to.
-    /// * `vault_sub_id`: [SubId] - The sub-identifier of the newly minted asset.
+    /// * `sub_id`: [SubId] - The sub-identifier of the newly minted asset.
     /// * `amount`: [u64] - The quantity of coins to mint.
     ///
     /// # Examples
@@ -16,22 +16,22 @@ abi SRC3 {
     ///
     /// fn foo(contract_id: ContractId) {
     ///     let contract_abi = abi(SR3, contract);
-    ///     contract_abi.mint(Identity::ContractId(contract_id), ZERO_B256, 100);
+    ///     contract_abi.mint(Identity::ContractId(contract_id), SubId::zero(), 100);
     /// }
     /// ```
     #[storage(read, write)]
-    fn mint(recipient: Identity, vault_sub_id: SubId, amount: u64);
+    fn mint(recipient: Identity, sub_id: SubId, amount: u64);
 
-    /// Burns assets sent with the given `vault_sub_id`.
+    /// Burns assets sent with the given `sub_id`.
     ///
     /// # Additional Information
     ///
     /// NOTE: The sha-256 hash of `(ContractId, SubId)` must match the `AssetId` where `ContractId` is the id of
-    /// the implementing contract and `SubId` is the given `vault_sub_id` argument.
+    /// the implementing contract and `SubId` is the given `sub_id` argument.
     ///
     /// # Arguments
     ///
-    /// * `vault_sub_id`: [SubId] - The sub-identifier of the asset to burn.
+    /// * `sub_id`: [SubId] - The sub-identifier of the asset to burn.
     /// * `amount`: [u64] - The quantity of coins to burn.
     ///
     /// # Examples
@@ -45,10 +45,10 @@ abi SRC3 {
     ///         gas: 10000,
     ///         coins: 100,
     ///         asset_id: asset_id,
-    ///     }.burn(ZERO_B256, 100);
+    ///     }.burn(SubId::zero(), 100);
     /// }
     /// ```
     #[payable]
     #[storage(read, write)]
-    fn burn(vault_sub_id: SubId, amount: u64);
+    fn burn(sub_id: SubId, amount: u64);
 }
diff --git a/standards/src/standards.sw b/standards/src/standards.sw
index b181044..0fea34b 100644
--- a/standards/src/standards.sw
+++ b/standards/src/standards.sw
@@ -7,4 +7,5 @@ pub mod src7;
 pub mod src10;
 pub mod src11;
 pub mod src12;
+pub mod src14;
 pub mod src20;