# Contributing / Development -There are several angles that people can take to contribute to this effort.+There are several ways that people can help `offchain::ipfs`. -TODO: Enumerate them+## Create a dApp or custom Substrate pallet, and tell us about it++Now that the proof-of-concept is complete and this manual is published, our goal is to be+laser-focused on user needs and to build out the capabilities of `offchain::ipfs` based on those.+So, **if you end up trying this out, we would love to know how, and for what.**++- Tell us about what you're doing by opening an information issue at [rs-ipfs/substrate]+- Share feedback on this manual by opening an issue at [rs-ipfs/offchain-ipfs-manual]+- Share feedback on `offchain::ipfs` itself by open an issue at [rs-ipfs/substrate]++## Support `offchain::ipfs` financially++[Equilibrium] is a consultancy that builds, and helps you build _on_, the distributed web. If+you're part of an organization and want help implementing or improving `offchain::ipfs`,+get in touch with us.++- If you're an individual and want to support us financially, visit our [OpenCollective].++## Implement more IPFS functionality++Some of the functionality exists in [Rust IPFS] and is not exposed via `offchain::ipfs`, and some

 # Contributing / Development -There are several angles that people can take to contribute to this effort.+There are several ways that people can help `offchain::ipfs`. -TODO: Enumerate them+## Create a dApp or custom Substrate pallet, and tell us about it++Now that the proof-of-concept is complete and this manual is published, our goal is to be+laser-focused on user needs and to build out the capabilities of `offchain::ipfs` based on those.+So, **if you end up trying this out, we would love to know how, and for what.**++- Tell us about what you're doing by opening an information issue at [rs-ipfs/substrate]+- Share feedback on this manual by opening an issue at [rs-ipfs/offchain-ipfs-manual]+- Share feedback on `offchain::ipfs` itself by open an issue at [rs-ipfs/substrate]++## Support `offchain::ipfs` financially++[Equilibrium] is a consultancy that builds, and helps you build _on_, the distributed web. If+you're part of an organization and want help implementing or improving `offchain::ipfs`,+get in touch with us.++- If you're an individual and want to support us financially, visit our [OpenCollective].++## Implement more IPFS functionality++Some of the functionality exists in [Rust IPFS] and is not exposed via `offchain::ipfs`, and some+of the functionality is not implemented in Rust IPFS at all. If there's something that another

 # Contributing / Development -There are several angles that people can take to contribute to this effort.+There are several ways that people can help `offchain::ipfs`. -TODO: Enumerate them+## Create a dApp or custom Substrate pallet, and tell us about it++Now that the proof-of-concept is complete and this manual is published, our goal is to be+laser-focused on user needs and to build out the capabilities of `offchain::ipfs` based on those.+So, **if you end up trying this out, we would love to know how, and for what.**++- Tell us about what you're doing by opening an information issue at [rs-ipfs/substrate]+- Share feedback on this manual by opening an issue at [rs-ipfs/offchain-ipfs-manual]+- Share feedback on `offchain::ipfs` itself by open an issue at [rs-ipfs/substrate]++## Support `offchain::ipfs` financially++[Equilibrium] is a consultancy that builds, and helps you build _on_, the distributed web. If

 # Contributing / Development -There are several angles that people can take to contribute to this effort.+There are several ways that people can help `offchain::ipfs`. -TODO: Enumerate them+## Create a dApp or custom Substrate pallet, and tell us about it++Now that the proof-of-concept is complete and this manual is published, our goal is to be+laser-focused on user needs and to build out the capabilities of `offchain::ipfs` based on those.+So, **if you end up trying this out, we would love to know how, and for what.**++- Tell us about what you're doing by opening an information issue at [rs-ipfs/substrate]+- Share feedback on this manual by opening an issue at [rs-ipfs/offchain-ipfs-manual]+- Share feedback on `offchain::ipfs` itself by open an issue at [rs-ipfs/substrate]

 # Contributing / Development -There are several angles that people can take to contribute to this effort.+There are several ways that people can help `offchain::ipfs`. -TODO: Enumerate them+## Create a dApp or custom Substrate pallet, and tell us about it++Now that the proof-of-concept is complete and this manual is published, our goal is to be+laser-focused on user needs and to build out the capabilities of `offchain::ipfs` based on those.+So, **if you end up trying this out, we would love to know how, and for what.**

 # Contributing / Development -There are several angles that people can take to contribute to this effort.+There are several ways that people can help `offchain::ipfs`. -TODO: Enumerate them+## Create a dApp or custom Substrate pallet, and tell us about it++Now that the proof-of-concept is complete and this manual is published, our goal is to be+laser-focused on user needs and to build out the capabilities of `offchain::ipfs` based on those.

 # Contributing / Development -There are several angles that people can take to contribute to this effort.+There are several ways that people can help `offchain::ipfs`. -TODO: Enumerate them+## Create a dApp or custom Substrate pallet, and tell us about it

+use codec::Encode;+use sp_keyring::AccountKeyring;+use substrate_subxt::{Call, ClientBuilder, EventsDecoder, NodeTemplateRuntime, PairSigner};++#[async_std::main]+async fn main() -> Result<(), Box<dyn std::error::Error>> {+    // Signer for the extrinsic+    let signer = PairSigner::<NodeTemplateRuntime, _>::new(AccountKeyring::Alice.pair());+    // API client, default to connect to 127.0.0.1:9944+    let client = ClientBuilder::<NodeTemplateRuntime>::new().build().await?;++    // Example CID for the example bytes added vec![1, 2, 3, 4]+    let cid = String::from("QmRgctVSR8hvGRDLv7c5H7BCji7m1VXRfEE1vW78CFagD7")+        .into_bytes()+        .to_vec();+    // Example multiaddr to connect IPFS with+    let multiaddr = String::from(+        "/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",+    )+    .into_bytes()+    .to_vec();+    // Example Peer Id+    let peer_id = String::from("QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ")+        .into_bytes()+        .to_vec();

+use sp_core::crypto::Pair;+use sp_keyring::AccountKeyring;+use std::{convert::TryFrom, string::String};+use substrate_api_client::{+    compose_call, compose_extrinsic_offline, extrinsic::xt_primitives::UncheckedExtrinsicV4,+    node_metadata::Metadata, Api, XtStatus,+};++fn main() {+    // instantiate an Api that connects to the given address+    let url = "127.0.0.1:9944";+    // if no signer is set in the whole program, we need to give to Api a specific type instead of an associated type+    // as during compilation the type needs to be defined.+    let signer = AccountKeyring::Bob.pair();++    // sets up api client and retrieves the node metadata+    let api = Api::new(format!("ws://{}", url)).set_signer(signer.clone());+    // gets the current nonce of Bob so we can increment it manually later+    let mut nonce = api.get_nonce().unwrap();++    // data from the node required in extrinsic+    let meta = Metadata::try_from(api.get_metadata()).unwrap();+    let genesis_hash = api.genesis_hash;+    let spec_version = api.runtime_version.spec_version;+    let transaction_version = api.runtime_version.transaction_version;++    // Example bytes to add+    let bytes_to_add: Vec<u8> = vec![1, 2, 3, 4];+    // Example CID for the example bytes added vec![1, 2, 3, 4]+    let cid = String::from("QmRgctVSR8hvGRDLv7c5H7BCji7m1VXRfEE1vW78CFagD7")+        .into_bytes()+        .to_vec();+    // Example multiaddr to connect IPFS with+    let multiaddr = String::from(+        "/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",+    )+    .into_bytes()+    .to_vec();+    // Example Peer Id+    let peer_id = String::from("QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ")+        .into_bytes()+        .to_vec();

+use sp_core::crypto::Pair;+use sp_keyring::AccountKeyring;+use std::{convert::TryFrom, string::String};+use substrate_api_client::{+    compose_call, compose_extrinsic_offline, extrinsic::xt_primitives::UncheckedExtrinsicV4,+    node_metadata::Metadata, Api, XtStatus,+};++fn main() {+    // instantiate an Api that connects to the given address+    let url = "127.0.0.1:9944";+    // if no signer is set in the whole program, we need to give to Api a specific type instead of an associated type+    // as during compilation the type needs to be defined.+    let signer = AccountKeyring::Bob.pair();++    // sets up api client and retrieves the node metadata+    let api = Api::new(format!("ws://{}", url)).set_signer(signer.clone());+    // gets the current nonce of Bob so we can increment it manually later+    let mut nonce = api.get_nonce().unwrap();++    // data from the node required in extrinsic+    let meta = Metadata::try_from(api.get_metadata()).unwrap();+    let genesis_hash = api.genesis_hash;+    let spec_version = api.runtime_version.spec_version;+    let transaction_version = api.runtime_version.transaction_version;++    // Example bytes to add+    let bytes_to_add: Vec<u8> = vec![1, 2, 3, 4];+    // Example CID for the example bytes added vec![1, 2, 3, 4]+    let cid = String::from("QmRgctVSR8hvGRDLv7c5H7BCji7m1VXRfEE1vW78CFagD7")+        .into_bytes()+        .to_vec();+    // Example multiaddr to connect IPFS with+    let multiaddr = String::from(+        "/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",+    )+    .into_bytes()+    .to_vec();

+use sp_core::crypto::Pair;+use sp_keyring::AccountKeyring;+use std::{convert::TryFrom, string::String};+use substrate_api_client::{+    compose_call, compose_extrinsic_offline, extrinsic::xt_primitives::UncheckedExtrinsicV4,+    node_metadata::Metadata, Api, XtStatus,+};++fn main() {+    // instantiate an Api that connects to the given address+    let url = "127.0.0.1:9944";+    // if no signer is set in the whole program, we need to give to Api a specific type instead of an associated type+    // as during compilation the type needs to be defined.+    let signer = AccountKeyring::Bob.pair();++    // sets up api client and retrieves the node metadata+    let api = Api::new(format!("ws://{}", url)).set_signer(signer.clone());+    // gets the current nonce of Bob so we can increment it manually later+    let mut nonce = api.get_nonce().unwrap();++    // data from the node required in extrinsic+    let meta = Metadata::try_from(api.get_metadata()).unwrap();+    let genesis_hash = api.genesis_hash;+    let spec_version = api.runtime_version.spec_version;+    let transaction_version = api.runtime_version.transaction_version;++    // Example bytes to add+    let bytes_to_add: Vec<u8> = vec![1, 2, 3, 4];+    // Example CID for the example bytes added vec![1, 2, 3, 4]+    let cid = String::from("QmRgctVSR8hvGRDLv7c5H7BCji7m1VXRfEE1vW78CFagD7")+        .into_bytes()+        .to_vec();

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+++### `decl_storage!`++Here, we define the data that will actually be stored on-chain as **extrinsics**.++Since the offchain-worker can't perform I/O outside of the wasm context, we store our requests as+queues, to be processed on a periodic basis, consumed, and ultimately performed by the native+runtime.++This is where we use the `ConnectionQueue`, `DataQueue`, and `DhtQueue` command types from above.++```rust,ignore+// This pallet's storage items.+decl_storage! {+    trait Store for Module<T: Trait> as TemplateModule {+        // A list of addresses to connect to and disconnect from.+        pub ConnectionQueue: Vec<ConnectionCommand>;+        // A queue of data to publish or obtain on IPFS.+        pub DataQueue: Vec<DataCommand>;+        // A list of requests to the DHT.+        pub DhtQueue: Vec<DhtCommand>;+    }+}+```++### `decl_event!`++This is where we define what those events are, when they happen, and what they contain.++Once a command is received by the off-chain worker, the corresponding handler from the `decl_module!`

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+++### `decl_storage!`++Here, we define the data that will actually be stored on-chain as **extrinsics**.++Since the offchain-worker can't perform I/O outside of the wasm context, we store our requests as+queues, to be processed on a periodic basis, consumed, and ultimately performed by the native+runtime.++This is where we use the `ConnectionQueue`, `DataQueue`, and `DhtQueue` command types from above.++```rust,ignore+// This pallet's storage items.+decl_storage! {+    trait Store for Module<T: Trait> as TemplateModule {+        // A list of addresses to connect to and disconnect from.+        pub ConnectionQueue: Vec<ConnectionCommand>;+        // A queue of data to publish or obtain on IPFS.+        pub DataQueue: Vec<DataCommand>;+        // A list of requests to the DHT.+        pub DhtQueue: Vec<DhtCommand>;+    }+}+```++### `decl_event!`++This is where we define what those events are, when they happen, and what they contain.++Once a command is received by the off-chain worker, the corresponding handler from the `decl_module!`+section will "deposit" the event in its storage, to be processed by the native runtime.++```rust,ignore+// The pallet's events+decl_event!(+    pub enum Event<T> where AccountId = <T as system::Trait>::AccountId {+        ConnectionRequested(AccountId),+        DisconnectRequested(AccountId),+        QueuedDataToAdd(AccountId),+        QueuedDataToCat(AccountId),+        QueuedDataToPin(AccountId),+        QueuedDataToRemove(AccountId),+        QueuedDataToUnpin(AccountId),+        FindPeerIssued(AccountId),+        FindProvidersIssued(AccountId),+    }+);+```++### `decl_module!`++This section, perhaps the most critical section of any given pallet, is where you can define+functions that are exposed as via JSON-RPC to client libraries and, by proxy, your users.++In practice, the bulk of what these functions do is to modify the `DataQueue`, `DhtQueue`, and

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+++### `decl_storage!`++Here, we define the data that will actually be stored on-chain as **extrinsics**.++Since the offchain-worker can't perform I/O outside of the wasm context, we store our requests as+queues, to be processed on a periodic basis, consumed, and ultimately performed by the native+runtime.++This is where we use the `ConnectionQueue`, `DataQueue`, and `DhtQueue` command types from above.++```rust,ignore+// This pallet's storage items.+decl_storage! {+    trait Store for Module<T: Trait> as TemplateModule {+        // A list of addresses to connect to and disconnect from.+        pub ConnectionQueue: Vec<ConnectionCommand>;+        // A queue of data to publish or obtain on IPFS.+        pub DataQueue: Vec<DataCommand>;+        // A list of requests to the DHT.+        pub DhtQueue: Vec<DhtCommand>;+    }+}+```++### `decl_event!`++This is where we define what those events are, when they happen, and what they contain.++Once a command is received by the off-chain worker, the corresponding handler from the `decl_module!`+section will "deposit" the event in its storage, to be processed by the native runtime.++```rust,ignore+// The pallet's events+decl_event!(+    pub enum Event<T> where AccountId = <T as system::Trait>::AccountId {+        ConnectionRequested(AccountId),+        DisconnectRequested(AccountId),+        QueuedDataToAdd(AccountId),+        QueuedDataToCat(AccountId),+        QueuedDataToPin(AccountId),+        QueuedDataToRemove(AccountId),+        QueuedDataToUnpin(AccountId),+        FindPeerIssued(AccountId),+        FindProvidersIssued(AccountId),+    }+);+```++### `decl_module!`++This section, perhaps the most critical section of any given pallet, is where you can define+functions that are exposed as via JSON-RPC to client libraries and, by proxy, your users.++In practice, the bulk of what these functions do is to modify the `DataQueue`, `DhtQueue`, and+`ConnectionQueue` storage objects by pushing signed command requests to their respective queues.++Some default types functions are omitted, but we've kept the `#[weight]` attributes around.++> The Substrate docs define defines one unit of weight as "one picosecond of execution time on+fixed reference hardware." These are essentially _time limits_ for block creation, and can be+(indirectly) mapped to transaction fees analogous to something like "gas fees." Read more about

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+++### `decl_storage!`++Here, we define the data that will actually be stored on-chain as **extrinsics**.++Since the offchain-worker can't perform I/O outside of the wasm context, we store our requests as+queues, to be processed on a periodic basis, consumed, and ultimately performed by the native+runtime.++This is where we use the `ConnectionQueue`, `DataQueue`, and `DhtQueue` command types from above.++```rust,ignore+// This pallet's storage items.+decl_storage! {+    trait Store for Module<T: Trait> as TemplateModule {+        // A list of addresses to connect to and disconnect from.+        pub ConnectionQueue: Vec<ConnectionCommand>;+        // A queue of data to publish or obtain on IPFS.+        pub DataQueue: Vec<DataCommand>;+        // A list of requests to the DHT.+        pub DhtQueue: Vec<DhtCommand>;+    }+}+```++### `decl_event!`++This is where we define what those events are, when they happen, and what they contain.++Once a command is received by the off-chain worker, the corresponding handler from the `decl_module!`+section will "deposit" the event in its storage, to be processed by the native runtime.++```rust,ignore+// The pallet's events+decl_event!(+    pub enum Event<T> where AccountId = <T as system::Trait>::AccountId {+        ConnectionRequested(AccountId),+        DisconnectRequested(AccountId),+        QueuedDataToAdd(AccountId),+        QueuedDataToCat(AccountId),+        QueuedDataToPin(AccountId),+        QueuedDataToRemove(AccountId),+        QueuedDataToUnpin(AccountId),+        FindPeerIssued(AccountId),+        FindProvidersIssued(AccountId),+    }+);+```++### `decl_module!`++This section, perhaps the most critical section of any given pallet, is where you can define+functions that are exposed as via JSON-RPC to client libraries and, by proxy, your users.++In practice, the bulk of what these functions do is to modify the `DataQueue`, `DhtQueue`, and+`ConnectionQueue` storage objects by pushing signed command requests to their respective queues.++Some default types functions are omitted, but we've kept the `#[weight]` attributes around.++> The Substrate docs define defines one unit of weight as "one picosecond of execution time on+fixed reference hardware." These are essentially _time limits_ for block creation, and can be

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+++### `decl_storage!`++Here, we define the data that will actually be stored on-chain as **extrinsics**.++Since the offchain-worker can't perform I/O outside of the wasm context, we store our requests as+queues, to be processed on a periodic basis, consumed, and ultimately performed by the native+runtime.++This is where we use the `ConnectionQueue`, `DataQueue`, and `DhtQueue` command types from above.++```rust,ignore+// This pallet's storage items.+decl_storage! {+    trait Store for Module<T: Trait> as TemplateModule {+        // A list of addresses to connect to and disconnect from.+        pub ConnectionQueue: Vec<ConnectionCommand>;+        // A queue of data to publish or obtain on IPFS.+        pub DataQueue: Vec<DataCommand>;+        // A list of requests to the DHT.+        pub DhtQueue: Vec<DhtCommand>;+    }+}+```++### `decl_event!`++This is where we define what those events are, when they happen, and what they contain.++Once a command is received by the off-chain worker, the corresponding handler from the `decl_module!`+section will "deposit" the event in its storage, to be processed by the native runtime.++```rust,ignore+// The pallet's events+decl_event!(+    pub enum Event<T> where AccountId = <T as system::Trait>::AccountId {+        ConnectionRequested(AccountId),+        DisconnectRequested(AccountId),+        QueuedDataToAdd(AccountId),+        QueuedDataToCat(AccountId),+        QueuedDataToPin(AccountId),+        QueuedDataToRemove(AccountId),+        QueuedDataToUnpin(AccountId),+        FindPeerIssued(AccountId),+        FindProvidersIssued(AccountId),+    }+);+```++### `decl_module!`++This section, perhaps the most critical section of any given pallet, is where you can define+functions that are exposed as via JSON-RPC to client libraries and, by proxy, your users.++In practice, the bulk of what these functions do is to modify the `DataQueue`, `DhtQueue`, and+`ConnectionQueue` storage objects by pushing signed command requests to their respective queues.++Some default types functions are omitted, but we've kept the `#[weight]` attributes around.++> The Substrate docs define defines one unit of weight as "one picosecond of execution time on

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+++### `decl_storage!`++Here, we define the data that will actually be stored on-chain as **extrinsics**.++Since the offchain-worker can't perform I/O outside of the wasm context, we store our requests as+queues, to be processed on a periodic basis, consumed, and ultimately performed by the native+runtime.++This is where we use the `ConnectionQueue`, `DataQueue`, and `DhtQueue` command types from above.++```rust,ignore+// This pallet's storage items.+decl_storage! {+    trait Store for Module<T: Trait> as TemplateModule {+        // A list of addresses to connect to and disconnect from.+        pub ConnectionQueue: Vec<ConnectionCommand>;+        // A queue of data to publish or obtain on IPFS.+        pub DataQueue: Vec<DataCommand>;+        // A list of requests to the DHT.+        pub DhtQueue: Vec<DhtCommand>;+    }+}+```++### `decl_event!`++This is where we define what those events are, when they happen, and what they contain.++Once a command is received by the off-chain worker, the corresponding handler from the `decl_module!`+section will "deposit" the event in its storage, to be processed by the native runtime.

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+++### `decl_storage!`++Here, we define the data that will actually be stored on-chain as **extrinsics**.++Since the offchain-worker can't perform I/O outside of the wasm context, we store our requests as+queues, to be processed on a periodic basis, consumed, and ultimately performed by the native+runtime.++This is where we use the `ConnectionQueue`, `DataQueue`, and `DhtQueue` command types from above.++```rust,ignore+// This pallet's storage items.+decl_storage! {+    trait Store for Module<T: Trait> as TemplateModule {+        // A list of addresses to connect to and disconnect from.+        pub ConnectionQueue: Vec<ConnectionCommand>;+        // A queue of data to publish or obtain on IPFS.+        pub DataQueue: Vec<DataCommand>;+        // A list of requests to the DHT.+        pub DhtQueue: Vec<DhtCommand>;+    }+}+```++### `decl_event!`++This is where we define what those events are, when they happen, and what they contain.++Once a command is received by the off-chain worker, the corresponding handler from the `decl_module!`+section will "deposit" the event in its storage, to be processed by the native runtime.++```rust,ignore+// The pallet's events+decl_event!(+    pub enum Event<T> where AccountId = <T as system::Trait>::AccountId {+        ConnectionRequested(AccountId),+        DisconnectRequested(AccountId),+        QueuedDataToAdd(AccountId),+        QueuedDataToCat(AccountId),+        QueuedDataToPin(AccountId),+        QueuedDataToRemove(AccountId),+        QueuedDataToUnpin(AccountId),+        FindPeerIssued(AccountId),+        FindProvidersIssued(AccountId),+    }+);+```++### `decl_module!`++This section, perhaps the most critical section of any given pallet, is where you can define+functions that are exposed as via JSON-RPC to client libraries and, by proxy, your users.++In practice, the bulk of what these functions do is to modify the `DataQueue`, `DhtQueue`, and+`ConnectionQueue` storage objects by pushing signed command requests to their respective queues.++Some default types functions are omitted, but we've kept the `#[weight]` attributes around.

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+++### `decl_storage!`++Here, we define the data that will actually be stored on-chain as **extrinsics**.++Since the offchain-worker can't perform I/O outside of the wasm context, we store our requests as+queues, to be processed on a periodic basis, consumed, and ultimately performed by the native+runtime.++This is where we use the `ConnectionQueue`, `DataQueue`, and `DhtQueue` command types from above.++```rust,ignore+// This pallet's storage items.+decl_storage! {+    trait Store for Module<T: Trait> as TemplateModule {+        // A list of addresses to connect to and disconnect from.+        pub ConnectionQueue: Vec<ConnectionCommand>;+        // A queue of data to publish or obtain on IPFS.+        pub DataQueue: Vec<DataCommand>;+        // A list of requests to the DHT.+        pub DhtQueue: Vec<DhtCommand>;+    }+}+```++### `decl_event!`++This is where we define what those events are, when they happen, and what they contain.

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+++### `decl_storage!`++Here, we define the data that will actually be stored on-chain as **extrinsics**.

+# Example Pallet++`offchain::ipfs` comes with a showcase **[pallet]**, which is essentially a Rust module that+complies with the requirements to be included within a substrate **runtime**.++> **This pallet is meant only as an example.** We're including it to be helpful for future pallet authors+that want to use the embedded native IPFS node to suit their needs.++If you're familiar with Substrate and the Framework for Runtime Aggregation of Modularized Entities+(FRAME), you can simply view the [source code] for this pallet. Otherwise, read on as we go through+the code step by step.++Please note the order in which these concepts are explained here is not necessarily the order that+they appear in the code.++You can also learn more by following the [Building a Custom Pallet] tutorial.++[Building a Custom Pallet]: https://substrate.dev/docs/en/tutorials/build-a-dapp/pallet+[source code]: https://github.com/rs-ipfs/substrate/blob/offchain_ipfs_bleeding_edge/bin/node-template/pallets/template/src/lib.rs+[pallet]: https://substrate.dev/docs/en/knowledgebase/runtime/pallets++## Prelude++We start by using items from the native runtime. Our pallet is `no_std` since we're targeting `Wasm`++```rust,ignore+#![cfg_attr(not(feature = "std"), no_std)]+// ...+use sp_core::offchain::{+  Duration, IpfsRequest, IpfsResponse, OpaqueMultiaddr, Timestamp+};+// ...+use sp_runtime::offchain::ipfs;+```++## Command Types++When your JSON-RPC calls are received by the pallet, the requests are+expressed as `___Command` enums and stored in the off-chain worker storage as+a queue, to be ingested by your native runtime and passed to IPFS.++Derive attributes are omitted.++```rust,ignore+// Commands involved in peer-to-peer connections+enum ConnectionCommand {+    ConnectTo(OpaqueMultiaddr),+    DisconnectFrom(OpaqueMultiaddr),+}++// Commands that add, remove, pin, unpin, and output data+enum DataCommand {+    AddBytes(Vec<u8>),+    CatBytes(Vec<u8>),+    InsertPin(Vec<u8>),+    RemoveBlock(Vec<u8>),+    RemovePin(Vec<u8>),+}++// Commands that query the distributed hash table (DHT)+// for peers and content+enum DhtCommand {+    FindPeer(Vec<u8>),+    GetProviders(Vec<u8>),+}+```++## The runtime configuration trait++The `system::Trait` trait (not to be confused with the Rust `trait` keyword), allows you to define+which capabilities from the runtime you want to include, and how you want to use them. You can also+"tightly couple" your pallet to other pallets by adding their `Trait`s to your pallet's+inherited trait list.++Here, however, we keep things simple by:++1. Loosely coupling this pallet by leaving out inherited traits+2. Including only the required `Event` type++```rust,ignore+/// The pallet's configuration trait.+pub trait Trait: system::Trait { // Use traits here to tightly couple to runtime+    /// The overarching event type.+    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;+}+```++Later in the code, we implement some helper functions on this trait. The function bodies are+omitted for brevity's sake.++```rust,ignore+impl<T: Trait> Module<T> {+    // "Sends" a request to the local IPFS node by adding it to the offchain storage+    fn ipfs_request(req: IpfsRequest, deadline: impl Into<Option<Timestamp>>)+      -> Result<IpfsResponse, Error<T>>++    // Reads from the `ConnectionQueue` and connects / disconnects+    // from desired / undesired peers, respectively+    fn connection_housekeeping() -> Result<(), Error<T>>++    // Reads `FindPeer` and `GetProviders` commands from the `DhtQueue`,+    // and requests their execution from the native runtime+    fn handle_dht_requests() -> Result<(), Error<T>>++    // Reads `AddBytes`, `CatBytes`, `DataCommand`, `RemoveBlock`, `InsertPin`,+    // and `RemovePin` commands from the `DataQueue` and requests their+    // execution from the native runtime.+    fn handle_data_requests() -> Result<(), Error<T>>++    // Logs metadata (the number of connected peers) to the console at the DEBUG log level+    fn print_metadata() -> Result<(), Error<T>>+```++## The `decl_` macros++Pallets included in Substrate runtimes must adhere to the conventions of [FRAME].+In practice, this means you must implement `decl_` macros:++- `decl_module!`+- `decl_event!`+- `decl_storage!`+- `decl_error!`++[FRAME]: https://substrate.dev/docs/en/knowledgebase/runtime/frame+

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository++**Frequency:** Every other block<br />+**Weight**: 200,000<br />++#### Arguments++- `bytes` - `Vec<u8>`, e.g. `vec![1, 2, 3, 4]` or `b"1234"`++#### Returns++A Content ID (CID) string, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++### `ipfs_cat_bytes`++Displays the bytes behind a given CID

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository++**Frequency:** Every other block<br />+**Weight**: 200,000<br />++#### Arguments++- `bytes` - `Vec<u8>`, e.g. `vec![1, 2, 3, 4]` or `b"1234"`++#### Returns++A Content ID (CID) string, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++### `ipfs_cat_bytes`++Displays the bytes behind a given CID++**Frequency:** Every other block<br />+**Weight**: 100,000++#### Arguments++- `cid`: A `Vec<u8>` CID, e.g. `b"QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa"`++#### Returns++The requested bytes - UTF-8 as a string, non-UTF-8 as hexidecimal string++### `ipfs_connect`++Connects the embedded node to the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++Nothing, or an error.++### `ipfs_disconnect`++Disconnects from the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 500,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++Nothing, or an error.++### `ipfs_dht_findpeer`++Performs a search for the addresses associated with the provided PeerId.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `peerID`: A `PeerId` string, e.g. `QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++An "opaque" multiaddr, i.e. one without a `PeerId`, such as `/ip4/104.131.131.82/tcp/4001`.++### `ipfs_dht_findproviders`++Search for PeerIds known to be providing the given Cid. You must connected to at least one peer!

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository++**Frequency:** Every other block<br />+**Weight**: 200,000<br />++#### Arguments++- `bytes` - `Vec<u8>`, e.g. `vec![1, 2, 3, 4]` or `b"1234"`++#### Returns++A Content ID (CID) string, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++### `ipfs_cat_bytes`++Displays the bytes behind a given CID++**Frequency:** Every other block<br />+**Weight**: 100,000++#### Arguments++- `cid`: A `Vec<u8>` CID, e.g. `b"QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa"`++#### Returns++The requested bytes - UTF-8 as a string, non-UTF-8 as hexidecimal string++### `ipfs_connect`++Connects the embedded node to the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++Nothing, or an error.++### `ipfs_disconnect`++Disconnects from the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 500,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++Nothing, or an error.++### `ipfs_dht_findpeer`++Performs a search for the addresses associated with the provided PeerId.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `peerID`: A `PeerId` string, e.g. `QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++An "opaque" multiaddr, i.e. one without a `PeerId`, such as `/ip4/104.131.131.82/tcp/4001`.++### `ipfs_dht_findproviders`++Search for PeerIds known to be providing the given Cid. You must connected to at least one peer!++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `cid`: The CID string of your desired content, e.g. `QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU`++#### Returns++- `peerID`: An array `PeerId` string, e.g. `[QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ]`++### `ipfs_insert_pin`++Non-recursively pins a block with the specified Cid, protecting it from removal.++**Frequency:** Every other block<br />+**Weight**: 100,000++#### Arguments++- `cid`: The CID string data you want to pin, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++#### Returns++Nothing, or an error.++### `ipfs_remove_pin`++Removes a pin from a block, so that it is no longer persistent and can be removed.++**Frequency:** Every other block<br />+**Weight**: 100,000++#### Arguments++- `cid`: The CID string data you want to unpin, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++#### Returns++### `ipfs_remove_block`++Removes a block from the node’s repository

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository++**Frequency:** Every other block<br />+**Weight**: 200,000<br />++#### Arguments++- `bytes` - `Vec<u8>`, e.g. `vec![1, 2, 3, 4]` or `b"1234"`++#### Returns++A Content ID (CID) string, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++### `ipfs_cat_bytes`++Displays the bytes behind a given CID++**Frequency:** Every other block<br />+**Weight**: 100,000++#### Arguments++- `cid`: A `Vec<u8>` CID, e.g. `b"QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa"`++#### Returns++The requested bytes - UTF-8 as a string, non-UTF-8 as hexidecimal string++### `ipfs_connect`++Connects the embedded node to the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository++**Frequency:** Every other block<br />+**Weight**: 200,000<br />++#### Arguments++- `bytes` - `Vec<u8>`, e.g. `vec![1, 2, 3, 4]` or `b"1234"`++#### Returns++A Content ID (CID) string, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++### `ipfs_cat_bytes`++Displays the bytes behind a given CID++**Frequency:** Every other block<br />+**Weight**: 100,000++#### Arguments++- `cid`: A `Vec<u8>` CID, e.g. `b"QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa"`++#### Returns++The requested bytes - UTF-8 as a string, non-UTF-8 as hexidecimal string++### `ipfs_connect`++Connects the embedded node to the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++Nothing, or an error.++### `ipfs_disconnect`++Disconnects from the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 500,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++Nothing, or an error.++### `ipfs_dht_findpeer`++Performs a search for the addresses associated with the provided PeerId.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `peerID`: A `PeerId` string, e.g. `QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++An "opaque" multiaddr, i.e. one without a `PeerId`, such as `/ip4/104.131.131.82/tcp/4001`.

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository++**Frequency:** Every other block<br />+**Weight**: 200,000<br />++#### Arguments++- `bytes` - `Vec<u8>`, e.g. `vec![1, 2, 3, 4]` or `b"1234"`++#### Returns++A Content ID (CID) string, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++### `ipfs_cat_bytes`++Displays the bytes behind a given CID++**Frequency:** Every other block<br />+**Weight**: 100,000++#### Arguments++- `cid`: A `Vec<u8>` CID, e.g. `b"QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa"`++#### Returns++The requested bytes - UTF-8 as a string, non-UTF-8 as hexidecimal string++### `ipfs_connect`++Connects the embedded node to the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++Nothing, or an error.++### `ipfs_disconnect`++Disconnects from the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 500,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++Nothing, or an error.++### `ipfs_dht_findpeer`++Performs a search for the addresses associated with the provided PeerId.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `peerID`: A `PeerId` string, e.g. `QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository++**Frequency:** Every other block<br />+**Weight**: 200,000<br />++#### Arguments++- `bytes` - `Vec<u8>`, e.g. `vec![1, 2, 3, 4]` or `b"1234"`

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository++**Frequency:** Every other block<br />+**Weight**: 200,000<br />++#### Arguments++- `bytes` - `Vec<u8>`, e.g. `vec![1, 2, 3, 4]` or `b"1234"`++#### Returns++A Content ID (CID) string, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++### `ipfs_cat_bytes`++Displays the bytes behind a given CID++**Frequency:** Every other block<br />+**Weight**: 100,000++#### Arguments++- `cid`: A `Vec<u8>` CID, e.g. `b"QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa"`++#### Returns++The requested bytes - UTF-8 as a string, non-UTF-8 as hexidecimal string++### `ipfs_connect`++Connects the embedded node to the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 100,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`++#### Returns++Nothing, or an error.++### `ipfs_disconnect`++Disconnects from the given Multiaddr.++**Frequency:** Every block<br />+**Weight**: 500,000++#### Arguments++- `multiaddr`: A string, e.g. `/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ`

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.++Finally, while we list "return" values for simplicity's sake, the template pallet does not actually+return any values from the RPC calls. What this really means in the context of Substrate is that the+values will be _eventually_ emitted returned in the runtime logs, which you'll need to monitor.++### `ipfs_add_bytes`++Adds the given bytes to the IPFS repository++**Frequency:** Every other block<br />+**Weight**: 200,000<br />++#### Arguments++- `bytes` - `Vec<u8>`, e.g. `vec![1, 2, 3, 4]` or `b"1234"`++#### Returns++A Content ID (CID) string, e.g. `QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa`++### `ipfs_cat_bytes`++Displays the bytes behind a given CID++**Frequency:** Every other block<br />+**Weight**: 100,000++#### Arguments++- `cid`: A `Vec<u8>` CID, e.g. `b"QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa"`

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at+[rs-ipfs/substrate].++[rs-ipfs/substrate]: https://github.com/rs-ipfs/substrate++## Callables++What follows is a list of callables, their frequency in terms of block creation, their weights,+their arguments and return values. As explained in the previous section on the example pallet,+weights are essentially picosecond representations of a time limit for a given transaction,+and can be loosely correlated to transaction fees.++> **Rust's `snake_case` is used here.** However, as you'll see in the upcoming polkadot.js example,+JavaScript will use `camelCase` for function and variable names. Generally, the exposed JSON-RPC+functions will adhere to the conventions of the programming language that the client code is+written in.++Also, the weights here and block frequencies here are chosen rather arbitrarily without tokenomics+in mind. You will need to tune these values in your own custom pallet.

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions+available in the native runtime, and therefore do not represent the full extent of functionality+available to you.++Regardless, we still detail the example template functions here as a helpful reference. If you have+feedback about these existing functions, or would like to request new functions, please open an issue at

-# offchain::ipfs callables--The following callables are available to you. These were chosen due to popularity and to try-and give substrate uses the most cohesive and familiar experience using IPFS within their node.--- api.tx.templateModule.ipfsAddBytes - add the given bytes to the IPFS repository; the off-chain worker interval for this activity is every block with an odd BlockNumber (i.e. every other block). For example adding 1234 gives you the CID QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsCatBytes - display the bytes (UTF-8 is displayed as a string, while non-UTF-8 bytes are displayed in their hexadecimal representation) with the given Cid; the off-chain worker interval for this activity is also every block with an odd BlockNumber. In the inverse of the last item, requesting the CID above will return 1234-- api.tx.templateModule.ipfsConnect - connect to the given Multiaddr; the off-chain worker interval for this activity is every block (the queue of connection requests is processed with every block in the chain). Try it with /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.-- api.tx.templateModule.ipfsDisconnect - disconnect from the given Multiaddr; the off-chain worker interval for this activity is also every block. You can try disconnecting from multiaddr from the previous item.-- api.tx.templateModule.ipfsDhtFindPeer - perform a search for the addresses associated with the provided PeerId; the off-chain worker interval for this activity is every block. If you use the peerID from two items prior, QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ, it will return /ip4/104.131.131.82/tcp/4001.-- api.tx.templateModule.ipfsDhtFindProviders - search for PeerIds known to be providing the given Cid; the off-chain worker interval for this activity is every block. Try it with the hash of the IPFS CID Inspector, QmY7Yh4UquoXHLPFo2XbhXkhBvFoPwmQUSa92pxnxjQuPU. Make sure you’re connected to at least one peer though!-- api.tx.templateModule.ipfsInsertPin - pin a block with the specified Cid, making it persistent; a pinned block can’t be removed. Try pinning the 1234 CID above: QmU1f6ngsoHvwtViihzLQPXCA8j3sagmvY9GJJDY7Ao7Aa-- api.tx.templateModule.ipfsRemovePin - remove a pin from a block, i.e. unpin it, so that it is no longer persistent and can be removed too. Trey removing the pin from the previous item.-- api.tx.templateModule.ipfsRemoveBlock - remove a block from the node’s repository+# Example pallet callable reference++The following callable functions are exposed via JSON-RPC by the example pallet.+These specific functions were chosen due to popularity, to give you a familiar experience.++However, as we explain at the bottom of this page, these functions are not the only functions

-# Building an offchain::ipfs app+# Building an `offchain::ipfs` app -In this book we’ll cover the bare essentials on what you need to start building out your dApp-with offchain::ipfs. We cover two Rust clients and one JavaScript client, but there are-many other clients in other languages.+In this section we’ll cover the essentials on what you'll need to start building your+application with `offchain::ipfs`. We do so by way of an example.++1. First, we walk you through the example Substrate pallet that's included with `offchain::ipfs`+2. Then, we provide example code from two Rust clients (`substrate-subxt` and+`substrat-api-client`), and one JavaScript client (`polkadot.js`) as they relate++We expect feedback on this pallet, but also we hope that the reference implementation will inspire+builders to create their own pallets, expose their own JSON-RPC endpoints, and call them from+their applications similarly.++## How it all works++It helps, first, to have a basic understanding of how a request flows from a user of your+application, through the Substrate offchain-worker, to the native runtime, over to IPFS,+and then all the way back up to your application again.++1. Once the chain is initialized or blocks are synced, the embedded Rust IPFS+node is launched and connected to the offchain worker runtime. It will stay running+in the background.+2. The user makes JSON-RPC call to submit an extrinsic to the node's runtime, using+the callable functions exposed from the custom pallet.+3. The requests is added to the relevant queue in the Substrate storage database.+This is also defined in the custom pallet.+4. On block import the node's runtime passes some requests from the queues to a+new offchain worker.+5. The request offchain worker performs future requests to the Rust IPFS node, and+the returned results resolve the futures+6. The request offchain worker registers the result in its API the the node's+runtime, which reads it and emits events declared in the custom pallet.+7. The request offchain worker stops running

-# Building an offchain::ipfs app+# Building an `offchain::ipfs` app -In this book we’ll cover the bare essentials on what you need to start building out your dApp-with offchain::ipfs. We cover two Rust clients and one JavaScript client, but there are-many other clients in other languages.+In this section we’ll cover the essentials on what you'll need to start building your+application with `offchain::ipfs`. We do so by way of an example.++1. First, we walk you through the example Substrate pallet that's included with `offchain::ipfs`+2. Then, we provide example code from two Rust clients (`substrate-subxt` and+`substrat-api-client`), and one JavaScript client (`polkadot.js`) as they relate++We expect feedback on this pallet, but also we hope that the reference implementation will inspire+builders to create their own pallets, expose their own JSON-RPC endpoints, and call them from+their applications similarly.++## How it all works++It helps, first, to have a basic understanding of how a request flows from a user of your+application, through the Substrate offchain-worker, to the native runtime, over to IPFS,+and then all the way back up to your application again.++1. Once the chain is initialized or blocks are synced, the embedded Rust IPFS+node is launched and connected to the offchain worker runtime. It will stay running+in the background.+2. The user makes JSON-RPC call to submit an extrinsic to the node's runtime, using+the callable functions exposed from the custom pallet.+3. The requests is added to the relevant queue in the Substrate storage database.+This is also defined in the custom pallet.+4. On block import the node's runtime passes some requests from the queues to a+new offchain worker.+5. The request offchain worker performs future requests to the Rust IPFS node, and+the returned results resolve the futures+6. The request offchain worker registers the result in its API the the node's+runtime, which reads it and emits events declared in the custom pallet.