LaconicNetwork/canine-docs
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

markdown structure formatting, rendered pages unchanged

Browse Source
This commit is contained in:
Erin Rivas 2023-08-11 09:44:24 -05:00
parent 5ef50c6768
commit b103539ad4
61 changed files with 584 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/contributors/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Community and Contributors",
"position":5
"position": 5
}

4
docs/contributors/foundation.md
View File

@ -1,11 +1,13 @@
---
sidebar_position: 2
---
# Jackal Foundation
## What is the Jackal Foundation?
The Jackal Foundation serves as the cornerstone of the Jackal Community. As a non-profit organization, it propels development forward by conducting research, testing software, championing projects, and promoting decentralization.
The Jackal Foundation serves as the cornerstone of the Jackal Community. As a non-profit organization, it propels
development forward by conducting research, testing software, championing projects, and promoting decentralization.
### What is the scope of the Jackal Foundation?

9
docs/contributors/join.md
View File

@ -1,10 +1,15 @@
---
sidebar_position: 1
---
# Join the Community!
## The Jackal Community is open to all.
The Jackal Protocol is a transparent, open source, and community-driven project. We welcome all who want to help build a self-custodial and secure digital future.
### To contribute; please join below.
The Jackal Protocol is a transparent, open source, and community-driven project. We welcome all who want to help build a
self-custodial and secure digital future.
### To contribute; please join below.
- [Twitter](https://twitter.com/home)

5
docs/contributors/labs.md
View File

@ -1,11 +1,14 @@
---
sidebar_position: 3
---
# Jackal Labs
## Who is Jackal Labs?
Jackal Labs, a Canadian software development company, played a pivotal role in the early development of the Jackal Protocol. As a decentralized and autonomous entity, the Jackal Protocol is not owned or operated by Jackal Labs. Instead, Jackal Labs contributes to the protocol's evolution by proposing changes through on-chain governance.
Jackal Labs, a Canadian software development company, played a pivotal role in the early development of the Jackal
Protocol. As a decentralized and autonomous entity, the Jackal Protocol is not owned or operated by Jackal Labs.
Instead, Jackal Labs contributes to the protocol's evolution by proposing changes through on-chain governance.
### What is the scope of Jackal Labs?

7
docs/developers/_category_.json
View File

@ -1,5 +1,4 @@
{
"label": "Developers",
"position":12
}
"label": "Developers",
"position": 12
}

39
docs/developers/apis/1_intro.md
View File

@ -1,6 +1,7 @@
+---
sidebar_position: 1
---
# About
## Quickstart
@ -17,15 +18,19 @@ To get started using Jackal in the browser, you'll need a few things!
### Setting Up
To get started, make sure you [start your project using Vite](https://vitejs.dev/guide). If you have an existing React app for example, re-init the project using Vite.
To get started, make sure you [start your project using Vite](https://vitejs.dev/guide). If you have an existing React
app for example, re-init the project using Vite.
Install dependencies:
```shell
npm install jackal.js
npm install -D vite-plugin-node-stdlib-browser
```
Jackal.js requires Node v20+. The easiest way to manage this is with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
Jackal.js requires Node v20+. The easiest way to manage this is
with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
```shell
nvm use 20
```
@ -46,12 +51,15 @@ export default defineConfig({
### Connecting Your Wallet
Custom chain configurations are required for [Testnet](#testnet-configuration), and for Keplr on [Mainnet](#mainnet-configuration). The following are the correct options to use.
Jackal.js additionally supports app-level overrides to the chain default settings. This requires some redundancy, but allows for greater flexibility in projects.
Custom chain configurations are required for [Testnet](#testnet-configuration), and for Keplr
on [Mainnet](#mainnet-configuration). The following are the correct options to use.
Jackal.js additionally supports app-level overrides to the chain default settings. This requires some redundancy, but
allows for greater flexibility in projects.
#### Wallet Selection
Currently Jackal,js supports Keplr and Leap wallets. Only a single wallet can be used at any time, but you can switch between them as desired.
Currently Jackal,js supports Keplr and Leap wallets. Only a single wallet can be used at any time, but you can switch
between them as desired.
```js
const selectedWallet = 'keplr'
@ -181,7 +189,6 @@ const finalWalletConfig = {
...appConfig,
chainConfig
}
// Hooking up the wallet to your app
const wallet = await WalletHandler.trackWallet(finalWalletConfig)
```
@ -199,10 +206,8 @@ This means giving the protocol $8 USD per month per tb. We can do this with Jack
```js
const storage = await StorageHandler.trackStorage(wallet)
// (Wallet address, duration in months (min 1),
// space in terabytes (min .001)
// 2 TB for 1 year:
await storage.buyStorage(WALLET_ADDRESS, 12, 2)
```
@ -211,15 +216,12 @@ await storage.buyStorage(WALLET_ADDRESS, 12, 2)
```js
const fileIo = await FileIo.trackIo(wallet)
const listOfRootFolders = ["Home", ...]
const listOfRootFolders = ["Home", ...]
// you can create as many root folders as you would like this way. Home is the dashboard default root directory.
// The first time a user connects, they must init the system
const storage = await StorageHandler.trackStorage(wallet)
const msg = storage.makeStorageInitMsg()
await fileIo.generateInitialDirs(msg, listOfRootFolders)
// after the first time, this code can be used instead. this will only create new root folders if they don't already exist
const newFolderCount = await fileIo.verifyFoldersExist(listOfRootFolders)
```
@ -228,12 +230,9 @@ const newFolderCount = await fileIo.verifyFoldersExist(listOfRootFolders)
```js
const fileIo = await FileIo.trackIo(wallet)
const parentFolderPath = PARENT_FOLDER_NAME // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const listOfChildFolders = ["Movies", "Pictures", ...]
await fileIo.createFolders(parent, listOfChildFolders)
```
@ -241,14 +240,11 @@ await fileIo.createFolders(parent, listOfChildFolders)
```js
const fileIo = await FileIo.trackIo(wallet)
const parentFolderPath = PARENT_FOLDER_NAME // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const file = FILE_OBJECT // this MUST be an instance of File() that is in the browser memory
const fileName = file.name
const handler = await FileUploadHandler.trackFile(file, parentFolderPath)
const uploadList = {}
uploadList[fileName] = {
data: null,
@ -257,7 +253,6 @@ uploadList[fileName] = {
key: fileName,
uploadable: await handler.getForUpload()
}
await fileIo.staggeredUploadFiles(uploadList, parent, {counter: 0, complete: 0})
```
@ -265,22 +260,18 @@ await fileIo.staggeredUploadFiles(uploadList, parent, {counter: 0, complete: 0})
```js
const fileIo = await FileIo.trackIo(wallet)
/* optional */
const parentFolderPath = PARENT_FOLDER_NAME // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const childrenFiles = parent.getChildFiles()
const pathOfFirstChild = parent.getMyChildPath(childrenFiles[0].name)
/* end optional */
const downloadDetails = {
rawPath: FILE_PATH, // manual complete file path OR pathOfFirstChild
owner: OWNER_ADDRESS, // JKL address of file owner
isFolder: false
}
const fileHanlder = await fileIo.downloadFile(downloadDetails, { track: 0 })
const fileHanlder = await fileIo.downloadFile(downloadDetails, {track: 0})
const file = fileHanlder.receiveBacon()
// do what you want with the File object returned by receiveBacon
```

39
docs/developers/apis/2_apis.md
View File

@ -1,6 +1,7 @@
---
sidebar_position: 2
---
# APIs
## Quickstart
@ -17,15 +18,19 @@ To get started using Jackal in the browser, you'll need a few things!
### Setting Up
To get started, make sure you [start your project using Vite](https://vitejs.dev/guide). If you have an existing React app for example, re-init the project using Vite.
To get started, make sure you [start your project using Vite](https://vitejs.dev/guide). If you have an existing React
app for example, re-init the project using Vite.
Install dependencies:
```shell
npm install jackal.js
npm install -D vite-plugin-node-stdlib-browser
```
Jackal.js requires Node v20+. The easiest way to manage this is with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
Jackal.js requires Node v20+. The easiest way to manage this is
with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
```shell
nvm use 20
```
@ -46,12 +51,15 @@ export default defineConfig({
### Connecting Your Wallet
Custom chain configurations are required for [Testnet](#testnet-configuration), and for Keplr on [Mainnet](#mainnet-configuration). The following are the correct options to use.
Jackal.js additionally supports app-level overrides to the chain default settings. This requires some redundancy, but allows for greater flexibility in projects.
Custom chain configurations are required for [Testnet](#testnet-configuration), and for Keplr
on [Mainnet](#mainnet-configuration). The following are the correct options to use.
Jackal.js additionally supports app-level overrides to the chain default settings. This requires some redundancy, but
allows for greater flexibility in projects.
#### Wallet Selection
Currently Jackal,js supports Keplr and Leap wallets. Only a single wallet can be used at any time, but you can switch between them as desired.
Currently Jackal,js supports Keplr and Leap wallets. Only a single wallet can be used at any time, but you can switch
between them as desired.
```js
const selectedWallet = 'keplr'
@ -181,7 +189,6 @@ const finalWalletConfig = {
...appConfig,
chainConfig
}
// Hooking up the wallet to your app
const wallet = await WalletHandler.trackWallet(finalWalletConfig)
```
@ -199,10 +206,8 @@ This means giving the protocol $8 USD per month per tb. We can do this with Jack
```js
const storage = await StorageHandler.trackStorage(wallet)
// (Wallet address, duration in months (min 1),
// space in terabytes (min .001)
// 2 TB for 1 year:
await storage.buyStorage(WALLET_ADDRESS, 12, 2)
```
@ -211,15 +216,12 @@ await storage.buyStorage(WALLET_ADDRESS, 12, 2)
```js
const fileIo = await FileIo.trackIo(wallet)
const listOfRootFolders = ["Home", ...]
const listOfRootFolders = ["Home", ...]
// you can create as many root folders as you would like this way. Home is the dashboard default root directory.
// The first time a user connects, they must init the system
const storage = await StorageHandler.trackStorage(wallet)
const msg = storage.makeStorageInitMsg()
await fileIo.generateInitialDirs(msg, listOfRootFolders)
// after the first time, this code can be used instead. this will only create new root folders if they don't already exist
const newFolderCount = await fileIo.verifyFoldersExist(listOfRootFolders)
```
@ -228,12 +230,9 @@ const newFolderCount = await fileIo.verifyFoldersExist(listOfRootFolders)
```js
const fileIo = await FileIo.trackIo(wallet)
const parentFolderPath = PARENT_FOLDER_NAME // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const listOfChildFolders = ["Movies", "Pictures", ...]
await fileIo.createFolders(parent, listOfChildFolders)
```
@ -241,14 +240,11 @@ await fileIo.createFolders(parent, listOfChildFolders)
```js
const fileIo = await FileIo.trackIo(wallet)
const parentFolderPath = PARENT_FOLDER_NAME // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const file = FILE_OBJECT // this MUST be an instance of File() that is in the browser memory
const fileName = file.name
const handler = await FileUploadHandler.trackFile(file, parentFolderPath)
const uploadList = {}
uploadList[fileName] = {
data: null,
@ -257,7 +253,6 @@ uploadList[fileName] = {
key: fileName,
uploadable: await handler.getForUpload()
}
await fileIo.staggeredUploadFiles(uploadList, parent, {counter: 0, complete: 0})
```
@ -265,22 +260,18 @@ await fileIo.staggeredUploadFiles(uploadList, parent, {counter: 0, complete: 0})
```js
const fileIo = await FileIo.trackIo(wallet)
/* optional */
const parentFolderPath = PARENT_FOLDER_NAME // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const childrenFiles = parent.getChildFiles()
const pathOfFirstChild = parent.getMyChildPath(childrenFiles[0].name)
/* end optional */
const downloadDetails = {
rawPath: FILE_PATH, // manual complete file path OR pathOfFirstChild
owner: OWNER_ADDRESS, // JKL address of file owner
isFolder: false
}
const fileHanlder = await fileIo.downloadFile(downloadDetails, { track: 0 })
const fileHanlder = await fileIo.downloadFile(downloadDetails, {track: 0})
const file = fileHanlder.receiveBacon()
// do what you want with the File object returned by receiveBacon
```

6
docs/developers/apis/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "APIs",
"position":2
}
"label": "APIs",
"position": 2
}

39
docs/developers/dAppLibraries/1_intro.md
View File

@ -1,6 +1,7 @@
---
sidebar_position: 1
---
# About These Libraries
## Quickstart
@ -17,15 +18,19 @@ To get started using Jackal in the browser, you'll need a few things!
### Setting Up
To get started, make sure you [start your project using Vite](https://vitejs.dev/guide). If you have an existing React app for example, re-init the project using Vite.
To get started, make sure you [start your project using Vite](https://vitejs.dev/guide). If you have an existing React
app for example, re-init the project using Vite.
Install dependencies:
```shell
npm install jackal.js
npm install -D vite-plugin-node-stdlib-browser
```
Jackal.js requires Node v20+. The easiest way to manage this is with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
Jackal.js requires Node v20+. The easiest way to manage this is
with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
```shell
nvm use 20
```
@ -46,12 +51,15 @@ export default defineConfig({
### Connecting Your Wallet
Custom chain configurations are required for [Testnet](#testnet-configuration), and for Keplr on [Mainnet](#mainnet-configuration). The following are the correct options to use.
Jackal.js additionally supports app-level overrides to the chain default settings. This requires some redundancy, but allows for greater flexibility in projects.
Custom chain configurations are required for [Testnet](#testnet-configuration), and for Keplr
on [Mainnet](#mainnet-configuration). The following are the correct options to use.
Jackal.js additionally supports app-level overrides to the chain default settings. This requires some redundancy, but
allows for greater flexibility in projects.
#### Wallet Selection
Currently Jackal,js supports Keplr and Leap wallets. Only a single wallet can be used at any time, but you can switch between them as desired.
Currently Jackal,js supports Keplr and Leap wallets. Only a single wallet can be used at any time, but you can switch
between them as desired.
```js
const selectedWallet = 'keplr'
@ -181,7 +189,6 @@ const finalWalletConfig = {
...appConfig,
chainConfig
}
// Hooking up the wallet to your app
const wallet = await WalletHandler.trackWallet(finalWalletConfig)
```
@ -199,10 +206,8 @@ This means giving the protocol $8 USD per month per tb. We can do this with Jack
```js
const storage = await StorageHandler.trackStorage(wallet)
// (Wallet address, duration in months (min 1),
// space in terabytes (min .001)
// 2 TB for 1 year:
await storage.buyStorage(WALLET_ADDRESS, 12, 2)
```
@ -211,15 +216,12 @@ await storage.buyStorage(WALLET_ADDRESS, 12, 2)
```js
const fileIo = await FileIo.trackIo(wallet)
const listOfRootFolders = ["Home", ...]
const listOfRootFolders = ["Home", ...]
// you can create as many root folders as you would like this way. Home is the dashboard default root directory.
// The first time a user connects, they must init the system
const storage = await StorageHandler.trackStorage(wallet)
const msg = storage.makeStorageInitMsg()
await fileIo.generateInitialDirs(msg, listOfRootFolders)
// after the first time, this code can be used instead. this will only create new root folders if they don't already exist
const newFolderCount = await fileIo.verifyFoldersExist(listOfRootFolders)
```
@ -228,12 +230,9 @@ const newFolderCount = await fileIo.verifyFoldersExist(listOfRootFolders)
```js
const fileIo = await FileIo.trackIo(wallet)
const parentFolderPath = PARENT_FOLDER_NAME // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const listOfChildFolders = ["Movies", "Pictures", ...]
await fileIo.createFolders(parent, listOfChildFolders)
```
@ -241,14 +240,11 @@ await fileIo.createFolders(parent, listOfChildFolders)
```js
const fileIo = await FileIo.trackIo(wallet)
const parentFolderPath = PARENT_FOLDER_NAME // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const file = FILE_OBJECT // this MUST be an instance of File() that is in the browser memory
const fileName = file.name
const handler = await FileUploadHandler.trackFile(file, parentFolderPath)
const uploadList = {}
uploadList[fileName] = {
data: null,
@ -257,7 +253,6 @@ uploadList[fileName] = {
key: fileName,
uploadable: await handler.getForUpload()
}
await fileIo.staggeredUploadFiles(uploadList, parent, {counter: 0, complete: 0})
```
@ -265,22 +260,18 @@ await fileIo.staggeredUploadFiles(uploadList, parent, {counter: 0, complete: 0})
```js
const fileIo = await FileIo.trackIo(wallet)
/* optional */
const parentFolderPath = PARENT_FOLDER_NAME // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const childrenFiles = parent.getChildFiles()
const pathOfFirstChild = parent.getMyChildPath(childrenFiles[0].name)
/* end optional */
const downloadDetails = {
rawPath: FILE_PATH, // manual complete file path OR pathOfFirstChild
owner: OWNER_ADDRESS, // JKL address of file owner
isFolder: false
}
const fileHanlder = await fileIo.downloadFile(downloadDetails, { track: 0 })
const fileHanlder = await fileIo.downloadFile(downloadDetails, {track: 0})
const file = fileHanlder.receiveBacon()
// do what you want with the File object returned by receiveBacon
```

21
docs/developers/dAppLibraries/2_jackal_protos.md
View File

@ -1,13 +1,15 @@
---
sidebar_position: 2
---
# Jackal.js-protos / Jackal.nodejs-protos
## About
The Protos modules for Jackal.js and Jackal.nodejs ("Protos") is the conversion layer the accepts raw protobufs from the
Jackal chain and converts them to useable typescrypt code. The differences between these 2 packages are only in the
compatibility with either browser or Nodejs Javascript APIs and how they are packaged for consumption. Protos is designed
compatibility with either browser or Nodejs Javascript APIs and how they are packaged for consumption. Protos is
designed
for those that wish to write their own Jackal-compatible library instead of using Jackal.js / Jackal.nodejs.
## Quickstart
@ -17,30 +19,37 @@ To get started using Protos, you'll need a few things!
### Pre-requesites
Both:
* Nodejs v20+
* [ECIESJS](https://www.npmjs.com/package/eciesjs)
Jackal.js-protos:
* [Vite](https://vitejs.dev)
* Chromium-family browser (Chrome, Brave, Edge, etc)
* [Keplr](https://www.keplr.app) or [Leap](https://www.leapwallet.io/cosmos) wallet extension
Jackal.nodejs-protos:
* None
Protos requires Node v20+. The easiest way to manage this is with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
Protos requires Node v20+. The easiest way to manage this is
with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
```shell
nvm use 20
```
### Setting Up
To get started, make sure your Jackal.js-protos based project has [Vite installed](https://vitejs.dev/guide). Jackal.nodejs-protos
To get started, make sure your Jackal.js-protos based project has [Vite installed](https://vitejs.dev/guide).
Jackal.nodejs-protos
does not need this.
Install dependencies:
(Jackal.js-protos)
```shell
npm create vite@latest
npm install jackal.js-protos eciesjs @cosmjs/launchpad @cosmjs/proto-signing @cosmjs/stargate
@ -50,13 +59,16 @@ npm install -D vite-plugin-node-stdlib-browser
OR
(Jackal.nodejs-protos)
```shell
npm install jackal.nodejs-protos eciesjs @cosmjs/launchpad @cosmjs/proto-signing @cosmjs/stargate
npm install -D @types/node typescript tscpaths
```
#### Updating Vite Config
(Jackal.js-protos)
```js
// In vite.config.js:
import { defineConfig } from 'vite'
@ -71,5 +83,6 @@ export default defineConfig({
## Next Steps
Once everything is set up as detailed above, you are free to create as little or as much using the methods exposed by Protos.
Once everything is set up as detailed above, you are free to create as little or as much using the methods exposed by
Protos.
Full documentation of these methods coming soon.

43
docs/developers/dAppLibraries/3_jackal_js.md
View File

@ -1,6 +1,7 @@
---
sidebar_position: 3
---
# Jackal.js
Implements [Jacakl.js-protos](https://www.npmjs.com/package/@jackallabs/jackal.js-protos)
@ -13,6 +14,7 @@ To get started using Jackal in the browser, you'll need a few things!
### Pre-requesites
* Nodejs v20+
* [Vue.js](https://vuejs.org/guide/introduction.html) or [React](https://react.dev/learn)
* [Jackal.js](https://www.npmjs.com/package/@jackallabs/jackal.js)
* [Vite](https://vitejs.dev)
@ -21,16 +23,20 @@ To get started using Jackal in the browser, you'll need a few things!
### Setting Up
To get started, make sure you [start your project using Vite](https://vitejs.dev/guide). If you have an existing React app for example, re-init the project using Vite.
To get started, make sure you [start your project using Vite](https://vitejs.dev/guide). If you have an existing React
app for example, re-init the project using Vite.
Install dependencies:
```shell
npm create vite@latest
npm install @jackallabs/jackal.js-protos @cosmjs/proto-signing
npm install -D vite-plugin-node-stdlib-browser
```
Jackal.js requires Node v20+. The easiest way to manage this is with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
Jackal.js requires Node v20+. The easiest way to manage this is
with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
```shell
nvm use 20
```
@ -51,12 +57,15 @@ export default defineConfig({
### Connecting Your Wallet
Custom chain configurations are required for [Testnet](#testnet-configuration), and for Keplr on [Mainnet](#mainnet-configuration). The following are the correct options to use.
Jackal.js additionally supports app-level overrides to the chain default settings. This requires some redundancy, but allows for greater flexibility in projects.
Custom chain configurations are required for [Testnet](#testnet-configuration), and for Keplr
on [Mainnet](#mainnet-configuration).
The following are the correct options to use. Jackal.js additionally supports app-level overrides to the chain default
settings. This requires some redundancy, but allows for greater flexibility in projects.
#### Wallet Selection
Currently Jackal,js supports Keplr and Leap wallets. Only a single wallet can be used at any time, but you can switch between them as desired.
Currently Jackal,js supports Keplr and Leap wallets. Only a single wallet can be used at any time, but you can switch
between them as desired.
```js
const selectedWallet = 'keplr'
@ -186,7 +195,6 @@ const finalWalletConfig = {
...appConfig,
chainConfig
}
// Hooking up the wallet to your app
const wallet = await WalletHandler.trackWallet(finalWalletConfig)
```
@ -204,11 +212,9 @@ This means giving the protocol $8 USD per month per tb. We can do this with Jack
```js
const storage = await StorageHandler.trackStorage(wallet)
// (Wallet address)
// duration in months (min 1)
// space in terabytes (min .001)
// 2 TB for 1 year:
await storage.buyStorage(WALLET_ADDRESS, 12, 2)
```
@ -216,16 +222,14 @@ await storage.buyStorage(WALLET_ADDRESS, 12, 2)
### Creating a Root Folder
```js
const fileIo = await FileIo.trackIo(wallet)
const listOfRootFolders = ["Home", ...]
const minimumProviderVersion = '1.0.9'
const fileIo = await FileIo.trackIo(wallet, minimumProviderVersion)
const listOfRootFolders = ["Home", ...]
// you can create as many root folders as you would like this way. Home is the Jackal Dashboard default root directory.
// The first time a user connects, they must init the system
const storage = await StorageHandler.trackStorage(wallet)
const msg = storage.makeStorageInitMsg()
await fileIo.generateInitialDirs(msg, listOfRootFolders)
// after the first time, this code can be used instead. this will only create new root folders if they don't already exist
const newFolderCount = await fileIo.verifyFoldersExist(listOfRootFolders)
```
@ -234,12 +238,9 @@ const newFolderCount = await fileIo.verifyFoldersExist(listOfRootFolders)
```js
const fileIo = await FileIo.trackIo(wallet)
const parentFolderPath = PARENT_FOLDER_NAME_AND_PATH // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const listOfChildFolders = ["Movies", "Pictures", ...]
await fileIo.createFolders(parent, listOfChildFolders)
```
@ -247,14 +248,11 @@ await fileIo.createFolders(parent, listOfChildFolders)
```js
const fileIo = await FileIo.trackIo(wallet)
const parentFolderPath = PARENT_FOLDER_NAME_AND_PATH // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const file = FILE_OBJECT // this MUST be an instance of File() that is in the browser memory
const fileName = file.name
const handler = await FileUploadHandler.trackFile(file, parentFolderPath)
const uploadList = {}
uploadList[fileName] = {
data: null,
@ -263,7 +261,6 @@ uploadList[fileName] = {
key: fileName,
uploadable: await handler.getForUpload()
}
await fileIo.staggeredUploadFiles(uploadList, parent, {counter: 0, complete: 0})
```
@ -271,22 +268,18 @@ await fileIo.staggeredUploadFiles(uploadList, parent, {counter: 0, complete: 0})
```js
const fileIo = await FileIo.trackIo(wallet)
/* optional */
const parentFolderPath = PARENT_FOLDER_NAME_AND_PATH // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const childrenFiles = parent.getChildFiles()
const pathOfFirstChild = parent.getMyChildPath(childrenFiles[0].name)
/* end optional */
const downloadDetails = {
rawPath: FILE_PATH, // manual complete file path OR pathOfFirstChild
owner: OWNER_ADDRESS, // JKL address of file owner
isFolder: false
}
const fileHanlder = await fileIo.downloadFile(downloadDetails, { track: 0 })
const fileHanlder = await fileIo.downloadFile(downloadDetails, {track: 0})
const file = fileHanlder.receiveBacon()
// do what you want with the File object returned by receiveBacon
```

9
docs/developers/dAppLibraries/4_jackal_nodejs.md
View File

@ -1,6 +1,7 @@
---
sidebar_position: 4
---
# Jackal.nodejs
## Quickstart
@ -18,12 +19,15 @@ A working demo repo can be found [on GitHub](https://github.com/JackalLabs/pup-d
### Setting Up
Install dependencies:
```shell
npm install @jackallabs/jackal.nodejs
npm install -D @types/node typescript tscpaths
```
Jackal.js requires Node v20+. The easiest way to manage this is with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
Jackal.js requires Node v20+. The easiest way to manage this is
with [NVM](https://github.com/nvm-sh/nvm#installing-and-updating).
```shell
nvm use 20
```
@ -88,12 +92,9 @@ const newFolderCount = await fileIo.verifyFoldersExist(listOfRootFolders)
```js
const fileIo = await FileIo.trackIo(wallet)
const parentFolderPath = PARENT_FOLDER_NAME_AND_PATH // for example Dashboard's root folder path is s/Home
const parent = await fileIo.downloadFolder(parentFolderPath)
const listOfChildFolders = ["Movies", "Pictures", ...]
await fileIo.createFolders(parent, listOfChildFolders)
```

1
docs/developers/dAppLibraries/5_jackal_go.md
View File

@ -1,6 +1,7 @@
---
sidebar_position: 5
---
# Jackal.go
## Quickstart

6
docs/developers/dAppLibraries/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "dApp Libraries",
"position":1
}
"label": "dApp Libraries",
"position": 1
}

5
docs/developers/intro.md
View File

@ -1,8 +1,11 @@
---
sidebar_position: 2
---
# Getting Started
## Web-Apps
To get started building web apps that leverage Jackal, head over to the [Jackal.js Quickstart](./jackaljs/intro.md)
<!-- ## Dependencies
@ -30,4 +33,4 @@ Golang is required to build the [canined](#canined) binary. Get [Golang](https:/
## Docker -->
# dApp Docs Coming Soon
# dApp Docs Coming Soon

2
docs/ecosystem/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Ecosystem",
"position":10
"position": 10
}

17
docs/ecosystem/grants-funding.md
View File

@ -1,9 +1,11 @@
---
sidebar_position: 1
---
# Grants and Funding
The Jackal Foundation facilitates non-equity grants, seed funding, and beyond through our various funding programs. Ecosystem funding aims to focus on the following categories;
The Jackal Foundation facilitates non-equity grants, seed funding, and beyond through our various funding programs.
Ecosystem funding aims to focus on the following categories;
- Research and Development
- Infrastructure
@ -14,11 +16,12 @@ The Jackal Foundation facilitates non-equity grants, seed funding, and beyond th
For grants, applications will be reviewed based on the following criteria.
| <100k | 100k - 200k | 200k+ |
| ------------- |:-------------| :-----|
| One round of review.| Two rounds of review. | Interviews, formal committee review, full pitch.
For seed funding, the Jackal Foundation or Investment Network may support an ecosystem project with equity or token investments. For innovative founders that bring strategic value and adoption to the Jackal Ecosystem, please reach out directly to our team.
| <100k | 100k - 200k | 200k+ |
|----------------------|:----------------------|:-------------------------------------------------|
| One round of review. | Two rounds of review. | Interviews, formal committee review, full pitch.
For seed funding, the Jackal Foundation or Investment Network may support an ecosystem project with equity or token
investments. For innovative founders that bring strategic value and adoption to the Jackal Ecosystem, please reach out
directly to our team.

7
docs/ecosystem/partnerships.md
View File

@ -1,8 +1,13 @@
---
sidebar_position: 2
---
# Partnerships
Blockchain and web3 native software engineering teams often wish to become core contributors through a partnership with the Jackal Foundation. In a partnership role, the team would be assigned direct tasks and held to a high standard of execution, professionalism, and accountability. If your team desires to partner with the Jackal Foundation, please reach out directly, we look forward to working with you.
Blockchain and web3 native software engineering teams often wish to become core contributors through a partnership with
the Jackal Foundation. In a partnership role, the team would be assigned direct tasks and held to a high standard of
execution, professionalism, and accountability. If your team desires to partner with the Jackal Foundation, please reach
out directly, we look forward to working with you.

12
docs/intro.md
View File

@ -4,8 +4,14 @@ sidebar_position: 1
# Welcome to Jackal Wiki
Welcome, explorer, to the Jackal Wiki, where you'll embark on a journey to discover a more secure, simple, and self-custodial digital world.
Welcome, explorer, to the Jackal Wiki, where you'll embark on a journey to discover a more secure, simple, and
self-custodial digital world.
The Jackal Protocol, an [open-source](https://github.com/JackalLabs/canine-chain) and community-driven innovation, fosters a transparent and trustless ecosystem. You've found the ultimate hub for all things Jackal: protocol insights, usage tips, infrastructure knowledge, and unique opportunities.
The Jackal Protocol, an [open-source](https://github.com/JackalLabs/canine-chain) and community-driven innovation,
fosters a transparent and trustless ecosystem. You've found the ultimate hub for all things Jackal: protocol insights,
usage tips, infrastructure knowledge, and unique opportunities.
Our enthusiastic teams at [Jackal Labs](/docs/official-links/jackal-labs) and the [Jackal Foundation](/docs/contributors/foundation.md) diligently maintain the Jackal Wiki. If you happen to spot outdated information, don't hesitate to reach out—your input helps us ensure accuracy for the entire community. Let's shape the future of digital experiences together!
Our enthusiastic teams at [Jackal Labs](/docs/official-links/jackal-labs) and
the [Jackal Foundation](/docs/contributors/foundation.md) diligently maintain the Jackal Wiki. If you happen to spot
outdated information, don't hesitate to reach out—your input helps us ensure accuracy for the entire community. Let's
shape the future of digital experiences together!

14
docs/nodes/1_install.md
View File

@ -1,16 +1,19 @@
---
sidebar_position: 0
---
# Setting Up
## Pre-Requisites
## Pre-Requisites
There are a few things needed before installing.
There are a few things needed before installing.
While logged in as the 'root' or 'admin' user, we add a 'jackal' user and give them root privileges.
### Enable Firewall Rules
Enabling the firewall is important to ensure your hardware remains secure. The following commands will add rules required for access on both validators and providers:
Enabling the firewall is important to ensure your hardware remains secure. The following commands will add rules
required for access on both validators and providers:
```sh
sudo ufw allow 22
@ -31,7 +34,8 @@ The only additional port required for a provider is 3333:
sudo ufw allow 3333
```
If you are running a combined validator/provider, you need to allow all of the above ports. After adding ports to the rules list, you will need to start the firewall:
If you are running a combined validator/provider, you need to allow all of the above ports. After adding ports to the
rules list, you will need to start the firewall:
```sh
sudo ufw enable
@ -73,6 +77,7 @@ sudo su - jackal
```
### Installing required tools
This will install the necessary tools to build the jackal chain source, along with lz4 compression tool and jquery tool.
```sh
@ -81,6 +86,7 @@ sudo apt install build-essential lz4 jq
```
### Installing Go
Follow more in-depth instructions to install Go v1.19 or higher [here](https://golang.org/doc/install).
On Ububtu you can install it with:

2
docs/nodes/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Nodes & Providers",
"position":11
"position": 11
}

1
docs/nodes/nodes/1_hardware.md
View File

@ -1,6 +1,7 @@
---
sidebar_position: 1
---
# Hardware
We recommend a minimum hardware requirement of:

17
docs/nodes/nodes/2_installation.md
View File

@ -1,12 +1,15 @@
---
sidebar_position: 2
---
# Installing Canined
## Pre-Requisites
## Pre-Requisites
See [Set-up](../1_install.md).
### Firewall Configuration
Configure UFW to only accept traffic on ports we use.
```bash
@ -20,12 +23,14 @@ ufw enable
:::tip
Perform the next follow steps as your `jackal` user with 'sudo' permissions
Perform the next follow steps as your `jackal` user with 'sudo' permissions
:::
### Creating a Service
You may want the daemon to run without you needing to supervise it. To turn the executable into a service follow these steps.
You may want the daemon to run without you needing to supervise it. To turn the executable into a service follow these
steps.
First create the service file `/etc/systemd/system/canined.service`
@ -33,7 +38,8 @@ First create the service file `/etc/systemd/system/canined.service`
sudo nano /etc/systemd/system/canined.service
```
Copy and paste the follow into the service file: (you may need to edit it if you've set a custom home directory location)
Copy and paste the follow into the service file: (you may need to edit it if you've set a custom home directory
location)
```conf
[Unit]
@ -54,6 +60,7 @@ WantedBy=multi-user.target
```
Update systemd and enable the service file.
```sh
sudo systemctl daemon-reload
sudo systemctl enable canined.service
@ -62,6 +69,7 @@ sudo systemctl enable canined.service
## Building from Source
Replace `<VERSION>` with the current running version.
```sh
git clone https://github.com/JackalLabs/canine-chain.git
cd canine-chain
@ -72,6 +80,7 @@ make install
```
From there you will be able to use `canined`, ex:
```sh
canined version
```

11
docs/nodes/nodes/3_testnet.md
View File

@ -1,6 +1,7 @@
---
sidebar_position: 3
---
# Joining Testnet
After installing `canined`. You can join the testnet by following these steps:
@ -15,9 +16,11 @@ canined init <alias> --chain-id=<chain-id>
:::
Then we want to replace our generated genesis file with the one used to start the network. We also need to set our peers and seeds.
Then we want to replace our generated genesis file with the one used to start the network. We also need to set our peers
and seeds.
For an updated list of peers & seeds, please check [this page](https://github.com/JackalLabs/jackal-chain-assets/blob/main/testnet/seeds.md).
For an updated list of peers & seeds, please
check [this page](https://github.com/JackalLabs/jackal-chain-assets/blob/main/testnet/seeds.md).
```sh
wget -O ~/.canine/config/genesis.json https://raw.githubusercontent.com/JackalLabs/jackal-chain-assets/main/testnet/genesis.json
@ -26,9 +29,9 @@ export SEEDS="84f520678ef59ea02f942fa6323ec562ca5a3249@45.79.161.178:26656,cecc0
sed -i.bak -e "s/^seeds *=.*/seeds = \"$SEEDS\"/" ~/.canine/config/config.toml
```
As a validator, you'll need to set a minimum gas price like so:
```sh
GAS="0.002ujkl"
sed -i.bak -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"$GAS\"/" $HOME/.canine/config/app.toml
```
```

25
docs/nodes/nodes/4_mainnet.md
View File

@ -1,6 +1,7 @@
---
sidebar_position: 4
---
# Joining Mainnet
:::tip
@ -26,9 +27,10 @@ GAS="0.002ujkl"
sed -i.bak -e "s/^seeds *=.*/seeds = \"$SEEDS\"/; s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" $HOME/.canine/config/config.toml
```
## Backing up key files
The created `node_key.json` and `priv_validator_key.json` cannot be recovered. These files ***must*** be backed up.
The created `node_key.json` and `priv_validator_key.json` cannot be recovered. These files ***must*** be backed up.
```sh
mkdir ~/key_backup
@ -36,16 +38,19 @@ cp ~/.canine/config/node_key.json ~/key_backup
cp ~/.canine/config/priv_validator_key.json ~/key_backup
```
You should also keep an offline backup. Using a program like `WinSCP`, you can easily copy these files to your personal desktop for safe storage/backup.
You should also keep an offline backup. Using a program like `WinSCP`, you can easily copy these files to your personal
desktop for safe storage/backup.
## Syncing to Current Height
### Snapshot method
Get a snapshot [here](http://snapshots.autostake.net/jackal-1/).
For the sake of this guide, the snapshot we download is named `jackal.tar.lz4`
If you plan on becoming a validator, before using the `unsafe-reset-all` flag, always besure to back up your `priv_validator_state.json` file.
If you plan on becoming a validator, before using the `unsafe-reset-all` flag, always besure to back up
your `priv_validator_state.json` file.
```sh
canined unsafe-reset-all --keep-addr-book
@ -55,8 +60,10 @@ lz4 -c -d jackal.tar.lz4 | tar -x -C $HOME/.canine
Then start the chain again.
### State Sync Method
There are a couple of ways to go about doing state sync.
First is the easier route. Visit [Ping.pub](https://ping.pub/jackal/statesync) for Jackals State Sync configuration settings.
First is the easier route. Visit [Ping.pub](https://ping.pub/jackal/statesync) for Jackals State Sync configuration
settings.
Next, copy these settings from Ping.pub to your `config.toml` in the `[statesync]` section.
@ -100,17 +107,19 @@ chunk_request_timeout = "10s"
chunk_fetchers = "42"
```
State syncing can take up to a few minutes to complete. Watch the logs to ensure it's happening. When a snapshot is found, you will see output in your log that is similar to this:
State syncing can take up to a few minutes to complete. Watch the logs to ensure it's happening. When a snapshot is
found, you will see output in your log that is similar to this:
```sh
1PM INF Discovered new snapshot format=1 hash="S.<2E>h<EFBFBD>F<EFBFBD><46><EFBFBD>\"\x1d6+\x1e<31><65><EFBFBD>ޅ<EFBFBD><DE85>`v@<40>ц<EFBFBD><D186><EFBFBD><EFBFBD><EFBFBD>" height=1810000 module=statesync
```
It will download, verify, and apply chuncks of blockchain data. When it finishes you will see it catching up to blocks
It will download, verify, and apply chuncks of blockchain data. When it finishes you will see it catching up to blocks
### State Sync Method 2
The follow commandline code will edit your `config.toml` with the proper information for state syncing to the most recent snapshot 3000 blocks and beyond.
The follow commandline code will edit your `config.toml` with the proper information for state syncing to the most
recent snapshot 3000 blocks and beyond.
```sh
STATE_SYNC_RPC=https://rpc.jackalprotocol.com:443
@ -145,4 +154,4 @@ sudo systemctl start jackal
sudo journalctl -u jackal -f
```
Watch the logs and ensure you are either state syncing correctly, or are syncing up to the current height.
Watch the logs and ensure you are either state syncing correctly, or are syncing up to the current height.

2
docs/nodes/nodes/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Full Nodes",
"position":0
"position": 0
}

24
docs/nodes/providers/1_building.md
View File

@ -1,27 +1,38 @@
---
sidebar_position: 1
---
# Creating Provider
## Disclaimer
This guide assumes you either have access to a full node over a network connection or are using the same machine as the full node.
This guide assumes you either have access to a full node over a network connection or are using the same machine as the
full node.
## Networking
To allow your provider to be used by the Jackal Protocol Dashboard, please ensure you have a reverse proxy system setup and have a registered domain name pointing to your provider. We recommend using [Nginx](https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/).
If you have UPNP enabled on your router, your provider will be open to the internet by default at port `3333`. You can find the address it can be connected to by running `canined network ip`.
To allow your provider to be used by the Jackal Protocol Dashboard, please ensure you have a reverse proxy system setup
and have a registered domain name pointing to your provider. We recommend
using [Nginx](https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/).
If you have UPNP enabled on your router, your provider will be open to the internet by default at port `3333`. You can
find the address it can be connected to by running `canined network ip`.
## Setting up ZFS Without Mirroring
Setting up ZFS allows us to combine multiple drives together, in this case we are merging two drives. We don't recommend you only merge drives with striping and instead we recommend mirroring. However mirroring is a longer process and different for each configuration. In our case, this machine is only running with 24TB across 2 drives. We are less concerned about a drive failing as that would wipe half our storage anyways.
Setting up ZFS allows us to combine multiple drives together, in this case we are merging two drives. We don't recommend
you only merge drives with striping and instead we recommend mirroring. However mirroring is a longer process and
different for each configuration. In our case, this machine is only running with 24TB across 2 drives. We are less
concerned about a drive failing as that would wipe half our storage anyways.
List all drives with :
```sh
sudo fdisk -l
```
You should end up seeing something like this
```sh
...
@ -44,7 +55,7 @@ Disk identifier: D2827F71-7F0A-EE4A-BB12-1B2172641DBE
...
```
Note down the Disk paths that you wish to use for your storage provider, in this case it is `/dev/sdb` and `/dev/sda`.
Note down the Disk paths that you wish to use for your storage provider, in this case it is `/dev/sdb` and `/dev/sda`.
We install ZFS and create a new pool as follows:
@ -56,4 +67,5 @@ sudo zpool create {pool-name} /dev/sda /dev/sdb ...
sudo zpool status
```
This folder will now have the drives mounted at `/{pool-name}`. For more in-depth guides to using zfs, check out [this page](https://zfsonlinux.org/).
This folder will now have the drives mounted at `/{pool-name}`. For more in-depth guides to using zfs, check
out [this page](https://zfsonlinux.org/).

48
docs/nodes/providers/2_setting_up.md
View File

@ -1,9 +1,11 @@
---
sidebar_position: 2
---
# Setting Up JProvd
## Pre-Requisites
## Pre-Requisites
See [Set-up](../1_install.md).
## Installing
@ -16,11 +18,13 @@ Check latest version [here](https://github.com/JackalLabs/canine-provider/releas
:::note
'Setting Up' instructions must be followed fully to add necessary golang path info to the current users ~/.profile. If these steps are skipped, 'make install' will not build jprovd--the provider daemon. Please ensure to perform the below steps as the 'jackal' user you previously made.
'Setting Up' instructions must be followed fully to add necessary golang path info to the current users ~/.profile. If
these steps are skipped, 'make install' will not build jprovd--the provider daemon. Please ensure to perform the below
steps as the 'jackal' user you previously made.
:::
Install make and confirm installation.
Install make and confirm installation.
```sh
sudo apt update
@ -31,7 +35,7 @@ make --version
```
Build jprovd and source the .profile to ensure your shell can find jprovd. Confirm installation.
Build jprovd and source the .profile to ensure your shell can find jprovd. Confirm installation.
```sh
git clone https://github.com/JackalLabs/canine-provider.git
@ -50,7 +54,7 @@ jprovd version
```
If you used ZFS to make a zpool. Give ownership of the zpool to the jackal user.
If you used ZFS to make a zpool. Give ownership of the zpool to the jackal user.
```sh
@ -66,32 +70,32 @@ Your keybase identity can be left as `""` if you don't want to link your provide
:::
1. Export the path to your storage pool
1. Export the path to your storage pool
```sh
export PHOME={path-to-pool-from-before}
```
2. Generate your provider's private key
2. Generate your provider's private key
```sh
jprovd client gen-key --home=$PHOME
```
3. Configure the chain-id
3. Configure the chain-id
```sh
jprovd client config chain-id {chain-id} --home=$PHOME
```
4. Configure the rpc node your provider will use to connect to the chain
4. Configure the rpc node your provider will use to connect to the chain
```sh
jprovd client config node {your node} --home=$PHOME
```
Some users may find it easier to complete steps 3 and 4 manually. Instructions for Ubuntu are below:
In your terminal, while inside of the PHOME directory, type 'nautilus'. This will open the nautilus file explorer.
At the top right corner, make sure 'Show Hidden Files' is checked.
Navigate to your '.jackal-storage' folder to access the config folder.
@ -99,17 +103,19 @@ Open the client.toml file to manually type in the 'chain-id' and 'node'.
Save and close the client.toml file.
Testnet and Mainnet chain-ids can be found here: https://github.com/JackalLabs/jackal-chain-assets.
If you are not running your own tendermint RPC node, Jackal Labs is currently hosting a testnet tendermint RPC node. Endpoint below:
If you are not running your own tendermint RPC node, Jackal Labs is currently hosting a testnet tendermint RPC node.
Endpoint below:
https://testnet-rpc.jackalprotocol.com:443
We will also be hosting a tendermint rpc node for mainnet, which will be made accessible to the public at launch of Jackal Storage.
Before completing step 5 below, your account will need tokens.
Testnet tokens can be obtained at https://testnet-faucet.jackalprotocol.com/
Mainnet tokens can be purchased on https://frontier.osmosis.zone/
We will also be hosting a tendermint rpc node for mainnet, which will be made accessible to the public at launch of
Jackal Storage.
5. Initialize the provider
Before completing step 5 below, your account will need tokens.
Testnet tokens can be obtained at https://testnet-faucet.jackalprotocol.com/
Mainnet tokens can be purchased on https://frontier.osmosis.zone/
5. Initialize the provider
```sh
jprovd init {FQDN} {STORAGE_IN_BYTES} {KEYBASE_IDENTITY} --home=$PHOME
@ -121,10 +127,10 @@ example:
jprovd init "https://storagep1.chainstrategies.cloud" "9000" "" --home=$PHOME
```
Please note that 'https://' is required to be included in the FQDN or init will throw an error.
Link for TB to Bytes converter: https://www.convertunits.com/from/TB/to/byte
Please note that 'https://' is required to be included in the FQDN or init will throw an error.
Link for TB to Bytes converter: https://www.convertunits.com/from/TB/to/byte
6. Start the provider
6. Start the provider
```sh
jprovd start --home=$PHOME

2
docs/nodes/providers/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Storage Providers",
"position":2
"position": 2
}

2
docs/nodes/providers/hardware/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Hardware",
"position":0
"position": 0
}

27
docs/nodes/providers/hardware/diy-serious copy.md
View File

@ -1,19 +1,22 @@
---
sidebar_position: 1
---
# DIY Build
For DIY individuals looking to power web3 infrastructure and increase your ROI- here is the recommended system for serious individual storage providers.
| Component|Recommendation| Units |
| ------------- |:-------------| :-----|
| CPU | AMD Ryzen 7 5700G 3.8 GHz 8-Core Processor | 1
| Motherboard | MSI B450 TOMAHAWK MAX II ATX AM4 Motherboard | 1
| Memory | 128 GB (2 x 64 GB) Memory | 1
| Storage | Kingston A400 960 GB 2.5" Solid State Drive | 1
| Storage | Seagate EXOS Enterprise 14 TB 3.5" 7200RPM Internal Hard Drive | 5 |
| Case | Cooler Master N400 ATX Mid Tower Case | 1
| Power Supply | Corsair HX750 Platinum 750 W 80+ Platinum Certified Fully Modular ATX Power Supply | 1
| Case Fan | Noctua S12B redux-700 33.49 CFM 120 mm Fan | 2
| Total Cost Estimate | $2014.08 USD
For DIY individuals looking to power web3 infrastructure and increase your ROI- here is the recommended system for
serious individual storage providers.
| Component | Recommendation | Units |
|---------------------|:------------------------------------------------------------------------------------|:------|
| CPU | AMD Ryzen 7 5700G 3.8 GHz 8-Core Processor | 1
| Motherboard | MSI B450 TOMAHAWK MAX II ATX AM4 Motherboard | 1
| Memory | 128 GB (2 x 64 GB) Memory | 1
| Storage | Kingston A400 960 GB 2.5" Solid State Drive | 1
| Storage | Seagate EXOS Enterprise 14 TB 3.5" 7200RPM Internal Hard Drive | 5 |
| Case | Cooler Master N400 ATX Mid Tower Case | 1
| Power Supply | Corsair HX750 Platinum 750 W 80+ Platinum Certified Fully Modular ATX Power Supply | 1
| Case Fan | Noctua S12B redux-700 33.49 CFM 120 mm Fan | 2
| Total Cost Estimate | $2014.08 USD

8
docs/nodes/providers/hardware/enterprise.md
View File

@ -1,12 +1,16 @@
---
sidebar_position: 2
---
# Enterprise Build
For teams looking to build a large storage system of ~2.1 Petabytes of storage, the estimated base price of the box with drives is ~$70,000 USD. This does not account for variable expenses including the regional costs of:
For teams looking to build a large storage system of ~2.1 Petabytes of storage, the estimated base price of the box with
drives is ~$70,000 USD. This does not account for variable expenses including the regional costs of:
- Power
- Internet
- HVAC
- Professionals
- Professionals
Those looking to build an enterprise storage provider, reach out to the team for recommendations and support.

17
docs/nodes/validators/1_joining.md
View File

@ -1,8 +1,8 @@
---
sidebar_position: 1
---
# Creating Validator
# Creating Validator
:::tip
@ -38,11 +38,14 @@ It is the only way to recover your account if you ever forget your password.
some words forming mnemonic seed will be placed here you have to write them down and keep them safe
```
Besure to back up the seed phrase of your validator wallet. It's also recommened to keep an offline copy along with your key files. Remember, your key files cannot be restored and ***must*** be backed up. See the installation page for instructions.
Besure to back up the seed phrase of your validator wallet. It's also recommened to keep an offline copy along with your
key files. Remember, your key files cannot be restored and ***must*** be backed up. See the installation page for
instructions.
You should also backup your keyring files.
Change `WALLET_NAME` to the name of your wallet.
```sh
mkdir ~/keyring_backup
cp ~/.canine/WALLET_NAME.info ~/keyring_backup
@ -54,6 +57,7 @@ cp ~/.canine/keyhash ~/keyring_backup
### Configure Gas Prices
As a validator, you'll need to set a minimum gas price like so:
```sh
GAS="0.02ujkl"
sed -i.bak -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"$GAS\"/" $HOME/.canine/config/app.toml
@ -61,9 +65,14 @@ sed -i.bak -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"$GAS\"/" $HOME/
### Create Your Validator
Before continuing, please note that `commission-max-change` and `commission-max-rate` cannot be changed once you set them. Your `commission-rate` may be changed once per day.
Before continuing, please note that `commission-max-change` and `commission-max-rate` cannot be changed once you set
them. Your `commission-rate` may be changed once per day.
There are a few things you will need to alter in this command. `amount` needs to be changed to what you are starting
your self bond as. `from` needs to be the name of your wallet you created earlier.
The `moniker`, `details`, `identity`, `website`, and `security-contact` should all be filled with the appropiate
information.
There are a few things you will need to alter in this command. `amount` needs to be changed to what you are starting your self bond as. `from` needs to be the name of your wallet you created earlier. The `moniker`, `details`, `identity`, `website`, and `security-contact` should all be filled with the appropiate information.
```sh
canined tx staking create-validator \
--amount 1000000ujkl \

2
docs/nodes/validators/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Validators",
"position":1
"position": 1
}

2
docs/official-links/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Official Links",
"position":9
"position": 9
}

4
docs/official-links/jackal-foundation.md
View File

@ -3,7 +3,9 @@ sidebar_position: 2
---
# Jackal Foundation Links
Here are the official website links for Jackal Foundation. Please use and bookmark these links to reduce the likelihood of cyber phishing threats.
Here are the official website links for Jackal Foundation. Please use and bookmark these links to reduce the likelihood
of cyber phishing threats.
## Jackal Foundation

4
docs/official-links/jackal-labs.md
View File

@ -3,7 +3,9 @@ sidebar_position: 2
---
# Jackal Labs Links
Here are the official website links for Jackal Labs. Please use and bookmark these links to reduce the likelihood of cyber phishing threats.
Here are the official website links for Jackal Labs. Please use and bookmark these links to reduce the likelihood of
cyber phishing threats.
## Jackal Labs

5
docs/official-links/jackal-protocol.md
View File

@ -3,7 +3,9 @@ sidebar_position: 1
---
# Jackal Protocol Links
Here are the official website links of the Jackal Protocol. Please use and bookmark these links to reduce the likelihood of cyber phishing threats.
Here are the official website links of the Jackal Protocol. Please use and bookmark these links to reduce the likelihood
of cyber phishing threats.
## Protocol
@ -13,7 +15,6 @@ Here are the official website links of the Jackal Protocol. Please use and bookm
[Jackal Dashboard](https://app.jackalprotocol.com/)
## Social
[Discord](https://discord.com/invite/5GKym3p6rj)

26
docs/overview/jackal-tldr.md
View File

@ -4,13 +4,29 @@ sidebar_position: 1
# Discover the Jackal Protocol
The Jackal Protocol provides a decentralized infrastructure for secure and scalable data storage, enabling individuals, developers, and enterprises to protect their data privacy and improve their cybersecurity posture. It offers a platform for building decentralized applications, managing access control and ownership, transferring encrypted data, and maintaining self-custodial control over data, all without relying on centralized storage providers or intermediaries.
The Jackal Protocol provides a decentralized infrastructure for secure and scalable data storage, enabling individuals,
developers, and enterprises to protect their data privacy and improve their cybersecurity posture. It offers a platform
for building decentralized applications, managing access control and ownership, transferring encrypted data, and
maintaining self-custodial control over data, all without relying on centralized storage providers or intermediaries.
Jackal Protocol stands apart, utilizing both validators and storage providers, enabling developers to create decentralized applications with seamless access to all [Jackal Protocol Modules](/docs/protocol/modules/module-overview.md), including storage contracts and file structures. Customize data ownership, share data with other Jackal users or smart contracts, and transfer encrypted data of any size, all without centralized storage providers or middleware. Your data remains self-custodial, ensuring that no one—not even the Jackal team—can access or view it.
Jackal Protocol stands apart, utilizing both validators and storage providers, enabling developers to create
decentralized applications with seamless access to
all [Jackal Protocol Modules](/docs/protocol/modules/module-overview.md), including storage contracts and file
structures. Customize data ownership, share data with other Jackal users or smart contracts, and transfer encrypted data
of any size, all without centralized storage providers or middleware. Your data remains self-custodial, ensuring that no
one—not even the Jackal team—can access or view it.
Comprising seven interoperable [modules](https://github.com/JackalLabs/canine-chain/blob/master/x/README.md) — [jklMint](https://github.com/JackalLabs/canine-chain/blob/master/x/jklmint/README.md), [lp](https://github.com/JackalLabs/canine-chain/blob/master/x/lp/README.md), [rns](https://github.com/JackalLabs/canine-chain/blob/master/x/rns/README.md), [wasm](https://github.com/JackalLabs/canine-chain/blob/master/x/wasm/README.md), [storage](https://github.com/JackalLabs/canine-chain/blob/master/x/storage/README.md), [filetree](https://github.com/JackalLabs/canine-chain/blob/master/x/filetree/README.md), and [dsig](https://github.com/JackalLabs/canine-chain/blob/master/x/dsig/README.md) — the Jackal Protocol allows for the development of secure, scalable, and truly decentralized applications .
Comprising seven
interoperable [modules](https://github.com/JackalLabs/canine-chain/blob/master/x/README.md) — [jklMint](https://github.com/JackalLabs/canine-chain/blob/master/x/jklmint/README.md), [lp](https://github.com/JackalLabs/canine-chain/blob/master/x/lp/README.md), [rns](https://github.com/JackalLabs/canine-chain/blob/master/x/rns/README.md), [wasm](https://github.com/JackalLabs/canine-chain/blob/master/x/wasm/README.md), [storage](https://github.com/JackalLabs/canine-chain/blob/master/x/storage/README.md), [filetree](https://github.com/JackalLabs/canine-chain/blob/master/x/filetree/README.md),
and [dsig](https://github.com/JackalLabs/canine-chain/blob/master/x/dsig/README.md) — the Jackal Protocol allows for the
development of secure, scalable, and truly decentralized applications .
The Jackal Protocol is [open source](https://github.com/JackalLabs/canine-chain) and community-driven, fostering a transparent and trustless ecosystem. Dive into this wiki to access comprehensive information on the protocol, usage, infrastructure, and opportunities.
The Jackal Protocol is [open source](https://github.com/JackalLabs/canine-chain) and community-driven, fostering a
transparent and trustless ecosystem. Dive into this wiki to access comprehensive information on the protocol, usage,
infrastructure, and opportunities.
Maintained by the dedicated [Jackal Labs](/docs/official-links/jackal-labs) and [Jackal Foundation](/docs/contributors/foundation.md) teams, the Jackal Wiki is constantly updated to ensure accuracy. Should you discover anything out-of-date, don't hesitate to reach out, as we strive to keep our documentation impeccable for the community.
Maintained by the dedicated [Jackal Labs](/docs/official-links/jackal-labs)
and [Jackal Foundation](/docs/contributors/foundation.md) teams, the Jackal Wiki is constantly updated to ensure
accuracy. Should you discover anything out-of-date, don't hesitate to reach out, as we strive to keep our documentation
impeccable for the community.

27
docs/overview/jkl.md
View File

@ -4,37 +4,46 @@ sidebar_position: 2
# What Is The JKL Token?
The JKL Token is the driving force behind the revolutionary Jackal Protocol. This versatile native token seamlessly integrates with the ecosystem, unlocking endless possibilities for users, developers, and enterprises alike.
The JKL Token is the driving force behind the revolutionary Jackal Protocol. This versatile native token seamlessly
integrates with the ecosystem, unlocking endless possibilities for users, developers, and enterprises alike.
## What Does The JKL Token Do?
## What Does The JKL Token Do?
### Fueling dApps
JKL Token plays a pivotal role in applications built on the Jackal Protocol, such as Jackal Storage and the RNS Marketplace. By harnessing the power of JKL, these applications can unlock new potentials and further enhance their utility.
JKL Token plays a pivotal role in applications built on the Jackal Protocol, such as Jackal Storage and the RNS
Marketplace. By harnessing the power of JKL, these applications can unlock new potentials and further enhance their
utility.
### Network Security
At its core, the Jackal Protocol is a Proof-of-Stake (PoS) Cosmos L1 blockchain, relying on JKL delegation to validators for network security. Stake your JKL tokens and contribute to securing the network while earning rewards.
At its core, the Jackal Protocol is a Proof-of-Stake (PoS) Cosmos L1 blockchain, relying on JKL delegation to validators
for network security. Stake your JKL tokens and contribute to securing the network while earning rewards.
### Affordable Transactions
With JKL, transaction fees on the Jackal Protocol are incredibly cost-effective, ensuring that users have an affordable and seamless experience.
With JKL, transaction fees on the Jackal Protocol are incredibly cost-effective, ensuring that users have an affordable
and seamless experience.
### Governance
Staked JKL tokens grant you the power to participate in on-chain governance within the Jackal Protocol. Make your voice heard by voting on text, software, spending, and other critical governance proposals.
Staked JKL tokens grant you the power to participate in on-chain governance within the Jackal Protocol. Make your voice
heard by voting on text, software, spending, and other critical governance proposals.
### Collateral
The JKL token serves as versatile collateral for validators, storage providers, and various smart contract use cases, unlocking new possibilities for users and developers.
The JKL token serves as versatile collateral for validators, storage providers, and various smart contract use cases,
unlocking new possibilities for users and developers.
### Liquidity
Put your JKL tokens to work by allocating them into a liquidity pool and earn JKL rewards in return. Contribute to the ecosystem while reaping the benefits of your investment.
Put your JKL tokens to work by allocating them into a liquidity pool and earn JKL rewards in return. Contribute to the
ecosystem while reaping the benefits of your investment.
### Data Storage
The JKL token serves as the primary medium of exchange for accessing data storage within the Jackal Protocol, ensuring a smooth and efficient market for users and storage providers alike.
The JKL token serves as the primary medium of exchange for accessing data storage within the Jackal Protocol, ensuring a
smooth and efficient market for users and storage providers alike.

31
docs/overview/why-jackal.md
View File

@ -4,7 +4,8 @@ sidebar_position: 3
# Why Choose Jackal Protocol
The Jackal Protocol offers various advantages for individuals, small businesses, and large enterprises seeking secure, decentralized data storage and management solutions.
The Jackal Protocol offers various advantages for individuals, small businesses, and large enterprises seeking secure,
decentralized data storage and management solutions.
## Individuals
@ -12,15 +13,18 @@ Individuals choose the Jackal Protocol for several reasons:
### Enhanced data privacy and security
The decentralized nature of the Jackal Protocol ensures that your data is stored across multiple nodes, reducing the risk of data breaches and unauthorized access.
The decentralized nature of the Jackal Protocol ensures that your data is stored across multiple nodes, reducing the
risk of data breaches and unauthorized access.
### Self-custodial storage
The Jackal Protocol allows individuals to retain full control over their data, ensuring that no third party, not even the Jackal team, can access or view it without the user's consent.
The Jackal Protocol allows individuals to retain full control over their data, ensuring that no third party, not even
the Jackal team, can access or view it without the user's consent.
### On-chain permissions
The transparent and secure permissions system enables users to manage access to their data, granting, revoking, or modifying permissions as needed.
The transparent and secure permissions system enables users to manage access to their data, granting, revoking, or
modifying permissions as needed.
## Small Businesses
@ -28,15 +32,18 @@ Small businesses benefit from the Jackal Protocol in various ways:
### Cost-effective storage
With the Jackal Protocol's decentralized storage model, businesses can benefit from competitive pricing, making it more affordable than traditional centralized storage solutions.
With the Jackal Protocol's decentralized storage model, businesses can benefit from competitive pricing, making it more
affordable than traditional centralized storage solutions.
### Scalability
The Jackal Protocol is built to scale with your business, ensuring that your data storage capacity can grow as your organization expands.
The Jackal Protocol is built to scale with your business, ensuring that your data storage capacity can grow as your
organization expands.
### Simplified compliance
Jackal Protocol's immutable records of data access and modification make it easier to meet industry-specific regulatory requirements and simplify auditing processes.
Jackal Protocol's immutable records of data access and modification make it easier to meet industry-specific regulatory
requirements and simplify auditing processes.
## Large Enterprises
@ -44,12 +51,16 @@ Large enterprises can leverage the Jackal Protocol for:
### Improved data governance
The on-chain permissions system allows for transparent and secure management of data access, ensuring that sensitive information remains protected and accessible only to authorized personnel.
The on-chain permissions system allows for transparent and secure management of data access, ensuring that sensitive
information remains protected and accessible only to authorized personnel.
### Enhanced security
By leveraging the decentralized infrastructure, Jackal Protocol offers an additional layer of security for enterprise data storage, reducing the risk of cyber-attacks and data breaches.
By leveraging the decentralized infrastructure, Jackal Protocol offers an additional layer of security for enterprise
data storage, reducing the risk of cyber-attacks and data breaches.
### Customizable solutions
The Jackal Protocol enables developers to build and deploy a wide range of decentralized applications (dApps) that can interact with user data, opening up new possibilities for services and products that prioritize user privacy and control.
The Jackal Protocol enables developers to build and deploy a wide range of decentralized applications (dApps) that can
interact with user data, opening up new possibilities for services and products that prioritize user privacy and
control.

2
docs/protocol/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "The Protocol",
"position":6
"position": 6
}

29
docs/protocol/encryption.md
View File

@ -1,32 +1,45 @@
---
sidebar_position: 2
---
# Encryption in Jackal Protocol
The Jackal Protocol utilizes encryption techniques to ensure the privacy and security of user data. The two primary encryption models within the protocol are file encryption and file-entry encryption. File encryption secures the files themselves, while file-entry encryption focuses on securing the file entries on the blockchain.
The Jackal Protocol utilizes encryption techniques to ensure the privacy and security of user data. The two primary
encryption models within the protocol are file encryption and file-entry encryption. File encryption secures the files
themselves, while file-entry encryption focuses on securing the file entries on the blockchain.
## File Encryption
File encryption is essential for protecting the data stored on storage providers within the Jackal Protocol. Before transferring files to storage providers, the user's client encrypts the files using a randomly generated symmetric key. The Advanced Encryption Standard (AES-256) is used for this encryption process, resulting in a securely encrypted file.
File encryption is essential for protecting the data stored on storage providers within the Jackal Protocol. Before
transferring files to storage providers, the user's client encrypts the files using a randomly generated symmetric key.
The Advanced Encryption Standard (AES-256) is used for this encryption process, resulting in a securely encrypted file.
![File Encryption Process](/img/jkl_paper/enc1.png)
The symmetric key's secure storage is equally crucial, as exposing it would compromise the file's encryption. The Jackal Chain's File Tree Module serves as a safe and immutable location for storing the encrypted symmetric key alongside the file's location.
The symmetric key's secure storage is equally crucial, as exposing it would compromise the file's encryption. The Jackal
Chain's File Tree Module serves as a safe and immutable location for storing the encrypted symmetric key alongside the
file's location.
## Integrated Encryption Scheme
The protocol uses an Integrated Encryption Scheme based on AES and the Elliptic Curve cryptography, which generates Bech32 addresses for secure key storage.
The protocol uses an Integrated Encryption Scheme based on AES and the Elliptic Curve cryptography, which generates
Bech32 addresses for secure key storage.
![Integrated Encryption Scheme](/img/jkl_paper/enc2.png)
To securely store the symmetric key, the protocol encrypts it with the user's public key. This process ensures that only the user with the corresponding private key can decrypt the symmetric key.
To securely store the symmetric key, the protocol encrypts it with the user's public key. This process ensures that only
the user with the corresponding private key can decrypt the symmetric key.
![Symmetric Key Decryption](/img/jkl_paper/enc3.png)
When decrypting a file, the user's private key is used to decrypt the symmetric key. Once the symmetric key is retrieved, it can be used to decrypt the file stored on the storage provider, resulting in the original uploaded file.
When decrypting a file, the user's private key is used to decrypt the symmetric key. Once the symmetric key is
retrieved, it can be used to decrypt the file stored on the storage provider, resulting in the original uploaded file.
## File Sharing and Access
To share files with other users, the protocol first decrypts the symmetric key from the chain, then retrieves the external user's public key from the chain, and encrypts the symmetric key with the external user's public key. By appending the newly encrypted symmetric key to the file entry, the external user gains access to the file.
To share files with other users, the protocol first decrypts the symmetric key from the chain, then retrieves the
external user's public key from the chain, and encrypts the symmetric key with the external user's public key. By
appending the newly encrypted symmetric key to the file entry, the external user gains access to the file.
By leveraging encryption techniques for both files and file entries, the Jackal Protocol ensures the privacy, security, and integrity of user data throughout the storage and sharing processes.
By leveraging encryption techniques for both files and file entries, the Jackal Protocol ensures the privacy, security,
and integrity of user data throughout the storage and sharing processes.

2
docs/protocol/modules/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Blockchain Modules",
"position":1
"position": 1
}

1
docs/protocol/modules/dsig.md
View File

@ -1,6 +1,7 @@
---
sidebar_position: 7
---
# dsig Module
## Coming Soon

40
docs/protocol/modules/filetree.md
View File

@ -1,24 +1,52 @@
---
sidebar_position: 8
---
# Filetree Module
## Overview
The Jackal Filetree module is responsible for organizing and managing user files in a secure and user-friendly way. When a user uploads a file using the Storage module, the file is only accessible from the File ID (FID), which can be challenging to remember for every file uploaded to Jackal. Additionally, every single upload would be required to be public, or the user would need to keep track of every symmetric key used to encrypt the files and manually map them to the FIDs. To address this issue, the File Tree module implements a tree structure to store each file as an entry in the tree. Organizing this structure is also trivial as we can assign children to pseudo files that we call folders. Finally, to keep track of encryption keys, the protocol maps every file to its respective key, emphasizing the security and privacy posture that the File Tree module enables.
The Jackal Filetree module is responsible for organizing and managing user files in a secure and user-friendly way. When
a user uploads a file using the Storage module, the file is only accessible from the File ID (FID), which can be
challenging to remember for every file uploaded to Jackal. Additionally, every single upload would be required to be
public, or the user would need to keep track of every symmetric key used to encrypt the files and manually map them to
the FIDs. To address this issue, the File Tree module implements a tree structure to store each file as an entry in the
tree. Organizing this structure is also trivial as we can assign children to pseudo files that we call folders. Finally,
to keep track of encryption keys, the protocol maps every file to its respective key, emphasizing the security and
privacy posture that the File Tree module enables.
![Protocol Overview](/img/jkl_paper/filetree1.png)
## Folder Abstraction
These, of course, are all abstractions of what's actually under the hood. The File Tree module doesn't actually handle any of the folder logic; the system believes it is storing files that act as metadata stores, which then update to reflect changes in folders. This gives the user experience the feeling that folders and files are separate entities in the tree, but in reality, they are identical.
These, of course, are all abstractions of what's actually under the hood. The File Tree module doesn't actually handle
any of the folder logic; the system believes it is storing files that act as metadata stores, which then update to
reflect changes in folders. This gives the user experience the feeling that folders and files are separate entities in
the tree, but in reality, they are identical.
## File Entry Structure
Storing file entries on-chain is a challenge since the chain itself is public. This requires the use of client-side encryption before uploading data to the chain itself. The main component of a file is location (Address), allowing users to query the rest of the data from the file. You can think of the location as a key in a traditional key-value store or a path in bucket-based storage. The address is hashed using SHA256 to ensure it is impossible to retrieve the plain-text representation of the file name while still being able to query the file using its given name.
Storing file entries on-chain is a challenge since the chain itself is public. This requires the use of client-side
encryption before uploading data to the chain itself. The main component of a file is location (Address), allowing users
to query the rest of the data from the file. You can think of the location as a key in a traditional key-value store or
a path in bucket-based storage. The address is hashed using SHA256 to ensure it is impossible to retrieve the plain-text
representation of the file name while still being able to query the file using its given name.
![Protocol Overview](/img/jkl_paper/filetree2.png)
The second most important data point in a file is the content of the file. This field is extremely versatile as it can store any string. Traditionally this is used to store a JSON list of FIDs to point to a file on the Storage Module; however, the protocol can also theoretically use it to store short bits of text like encrypted passwords for a private password manager. The owner tag is a hashed version of the owner, hiding what address owns each file. This field can be changed to reflect the transferral of ownership. When making changes to the file such as deletion, movement, or adding/removing viewers/editors, the owner field is consulted to determine permissions. The same applies to edit access; editors can update the contents but nothing else.
The second most important data point in a file is the content of the file. This field is extremely versatile as it can
store any string. Traditionally this is used to store a JSON list of FIDs to point to a file on the Storage Module;
however, the protocol can also theoretically use it to store short bits of text like encrypted passwords for a private
password manager. The owner tag is a hashed version of the owner, hiding what address owns each file. This field can be
changed to reflect the transferral of ownership. When making changes to the file such as deletion, movement, or
adding/removing viewers/editors, the owner field is consulted to determine permissions. The same applies to edit access;
editors can update the contents but nothing else.
## Encrypted Viewing Access
For users to view files, they need access to the symmetric keys used to encrypt the files. To do this, the protocol has a map of hashed addresses with each user's respective version of the symmetric key encrypted with that address's corresponding public key. The protocol can then store that map in the file entry to act as an encryption key discovery layer. The addresses in this viewing list are only able to access files and decrypt the data in their client; they have no privileges over the modification of the file entry in any way. This approach ensures that the File Tree module maintains a strong security and privacy posture for user data.
For users to view files, they need access to the symmetric keys used to encrypt the files. To do this, the protocol has
a map of hashed addresses with each user's respective version of the symmetric key encrypted with that address's
corresponding public key. The protocol can then store that map in the file entry to act as an encryption key discovery
layer. The addresses in this viewing list are only able to access files and decrypt the data in their client; they have
no privileges over the modification of the file entry in any way. This approach ensures that the File Tree module
maintains a strong security and privacy posture for user data.

3
docs/protocol/modules/jklmint.md
View File

@ -4,7 +4,8 @@ sidebar_position: 2
# JKLmint Module
The `jklmint` module is responsible for the management of the native JKL token within the Jackal Protocol. This module handles the issuance, distribution, and inflation of JKL tokens, ensuring a stable and secure token economy.
The `jklmint` module is responsible for the management of the native JKL token within the Jackal Protocol. This module
handles the issuance, distribution, and inflation of JKL tokens, ensuring a stable and secure token economy.
## Overview

8
docs/protocol/modules/lp.md
View File

@ -1,9 +1,12 @@
---
sidebar_position: 3
---
# LP Module (Coming Soon)
The `lp` (Liquidity Provision) module is a vital part of the Jackal Protocol, enabling the creation and management of liquidity pools for trading and swapping tokens. This module provides a decentralized solution for users to contribute liquidity to the ecosystem and earn rewards in return.
The `lp` (Liquidity Provision) module is a vital part of the Jackal Protocol, enabling the creation and management of
liquidity pools for trading and swapping tokens. This module provides a decentralized solution for users to contribute
liquidity to the ecosystem and earn rewards in return.
## Overview
@ -14,4 +17,5 @@ The `lp` module manages the following aspects of liquidity pools:
3. **Token Swaps**: Enables decentralized trading and swapping of tokens within the liquidity pools.
4. **Rewards**: Distributes rewards to liquidity providers proportionate to their contribution.
For a more detailed guide on the 'lp' module, please refer to the [module documentation](https://github.com/JackalLabs/canine-chain/blob/master/x/lp/README.md) on GitHub.
For a more detailed guide on the 'lp' module, please refer to
the [module documentation](https://github.com/JackalLabs/canine-chain/blob/master/x/lp/README.md) on GitHub.

2
docs/protocol/modules/module-overview.md
View File

@ -1,8 +1,8 @@
---
sidebar_position: 1
---
# Module Overview
# Module Overview
![Protocol Overview](/img/jkl_paper/protocol.png)

9
docs/protocol/modules/rns.md
View File

@ -1,9 +1,13 @@
---
sidebar_position: 4
---
# Name Service Module
The `rns` (Reverse Name Service) module is an essential component of the Jackal Protocol, providing a user-friendly naming system for blockchain addresses. The RNS module simplifies the process of interacting with complex addresses by mapping them to human-readable names. This module allows users to transfer tokens and permissions to files/folders stored on the Jackal Protocol using human readable names.
The `rns` (Reverse Name Service) module is an essential component of the Jackal Protocol, providing a user-friendly
naming system for blockchain addresses. The RNS module simplifies the process of interacting with complex addresses by
mapping them to human-readable names. This module allows users to transfer tokens and permissions to files/folders
stored on the Jackal Protocol using human readable names.
## Overview
@ -15,4 +19,5 @@ The `rns` module manages the following aspects of the Reverse Name Service:
4. **Name Sales**: Enables users to buy and sell RNS names through the RNS Marketplace.
5. **Name Transfers**: Enables users to transfer RNS names.
For a more detailed guide on integrating the rns module into your application, please refer to the [module documentation](https://github.com/JackalLabs/canine-chain/blob/master/x/README.md) on GitHub.
For a more detailed guide on integrating the rns module into your application, please refer to
the [module documentation](https://github.com/JackalLabs/canine-chain/blob/master/x/README.md) on GitHub.

45
docs/protocol/modules/storage.md
View File

@ -4,28 +4,46 @@ sidebar_position: 6
# Storage Module
The Jackal Protocol incorporates two crucial algorithms for decentralized storage: Jackal Proof-of-Persistence (JPOP) and Internal Detection Of Loss (IDOL) protocols. This document provides an overview of these algorithms, their functionalities, and their interaction with users and Storage Providers.
The Jackal Protocol incorporates two crucial algorithms for decentralized storage: Jackal Proof-of-Persistence (JPOP)
and Internal Detection Of Loss (IDOL) protocols. This document provides an overview of these algorithms, their
functionalities, and their interaction with users and Storage Providers.
## Jackal Proof-of-Persistence (JPOP)
JPOP is a Proof-of-Storage algorithm that governs the relationship between the storage provider and the user. It operates through a series of contracts containing the Merkle Tree root hash of the file and information required to prove ownership. Storage Providers are responsible for posting Merkle Proofs within a challenge window determined by the blockchain.
JPOP is a Proof-of-Storage algorithm that governs the relationship between the storage provider and the user. It
operates through a series of contracts containing the Merkle Tree root hash of the file and information required to
prove ownership. Storage Providers are responsible for posting Merkle Proofs within a challenge window determined by the
blockchain.
The challenge windows require miners to post the raw data chunk and the required Merkle Hashes to prove the data belongs to the Merkle Root stored on the contract. The challenge indexes are chosen at random by the blockchain using a block-hash-based random number generator paired with a random data oracle.
The challenge windows require miners to post the raw data chunk and the required Merkle Hashes to prove the data belongs
to the Merkle Root stored on the contract. The challenge indexes are chosen at random by the blockchain using a
block-hash-based random number generator paired with a random data oracle.
## Internal Detection Of Loss (IDOL) Protocol
The IDOL protocol ensures that data remains available and accessible. When a Storage Provider successfully posts a Merkle Proof within the challenge window, and Validators verify the data, the Storage Provider is rewarded. The rewards are proportional to the file size associated with the contract relative to other active contracts on the network.
The IDOL protocol ensures that data remains available and accessible. When a Storage Provider successfully posts a
Merkle Proof within the challenge window, and Validators verify the data, the Storage Provider is rewarded. The rewards
are proportional to the file size associated with the contract relative to other active contracts on the network.
If a Storage Provider fails to provide a valid proof within the allotted timeframe, the contract is marked with a missed proof. After a certain number of missed proofs, the contract is burned, and the user is alerted the next time they query the contract. Storage Providers receive penalties for every contract burned due to missed proofs, which remain on their record for an adjustable period.
If a Storage Provider fails to provide a valid proof within the allotted timeframe, the contract is marked with a missed
proof. After a certain number of missed proofs, the contract is burned, and the user is alerted the next time they query
the contract. Storage Providers receive penalties for every contract burned due to missed proofs, which remain on their
record for an adjustable period.
The IDOL protocol comes into play when contracts with missed proofs are moved to a new list where they can be claimed by other providers. The new provider downloads the file from one of the two online providers storing the same file, resumes the contract's proof action, and restores redundancy to 3x.
The IDOL protocol comes into play when contracts with missed proofs are moved to a new list where they can be claimed by
other providers. The new provider downloads the file from one of the two online providers storing the same file, resumes
the contract's proof action, and restores redundancy to 3x.
## Interaction Outline
1. A user sends a file to an available Storage Provider. A list of Storage Providers can be found on the blockchain, and miners can deny any incoming request if they do not want to store new files.
2. After receiving the entire file, the Storage Provider keeps the file in memory and posts a contract to the blockchain.
3. If the contract is not signed by the sender within a certain number of blocks (configurable by the Storage Provider), the file is removed from memory, and the contract is burned.
4. If the contract is signed by the user within the given number of blocks, the file is committed to the Storage Provider's hard storage, and the challenge windows start being created for the now active contract.
1. A user sends a file to an available Storage Provider. A list of Storage Providers can be found on the blockchain, and
miners can deny any incoming request if they do not want to store new files.
2. After receiving the entire file, the Storage Provider keeps the file in memory and posts a contract to the
blockchain.
3. If the contract is not signed by the sender within a certain number of blocks (configurable by the Storage Provider),
the file is removed from memory, and the contract is burned.
4. If the contract is signed by the user within the given number of blocks, the file is committed to the Storage
Provider's hard storage, and the challenge windows start being created for the now active contract.
## Client Query Commands
@ -61,6 +79,9 @@ The transaction commands allow users to interact with the storage module. Exampl
- `cancel-contract`
- `upgrade-storage`
By implementing the JPOP and IDOL protocols, the Jackal Protocol ensures secure, efficient, and reliable decentralized storage management. These protocols, along with the provided client query commands and transactions, enable users and Storage Providers to interact with the Jackal storage ecosystem seamlessly.
By implementing the JPOP and IDOL protocols, the Jackal Protocol ensures secure, efficient, and reliable decentralized
storage management. These protocols, along with the provided client query commands and transactions, enable users and
Storage Providers to interact with the Jackal storage ecosystem seamlessly.
Please refer to the respective command documentation for detailed usage and parameters. The Jackal Protocol continues to evolve, and as new features are added, updates to this documentation will be provided accordingly.
Please refer to the respective command documentation for detailed usage and parameters. The Jackal Protocol continues to
evolve, and as new features are added, updates to this documentation will be provided accordingly.

10
docs/protocol/modules/wasm.md
View File

@ -4,15 +4,19 @@ sidebar_position: 5
# WASM Module
The `wasm` module in the Jackal Protocol incorporates the CosmWasm smart contracting platform, which is designed specifically for the Cosmos Ecosystem. This module provides a secure and efficient environment for executing WebAssembly (WASM) smart contracts on the Jackal Protocol.
The `wasm` module in the Jackal Protocol incorporates the CosmWasm smart contracting platform, which is designed
specifically for the Cosmos Ecosystem. This module provides a secure and efficient environment for executing
WebAssembly (WASM) smart contracts on the Jackal Protocol.
## Overview
The `wasm` module manages the following aspects of the CosmWasm platform:
1. **Smart Contract Deployment**: Allows developers to deploy smart contracts written in Rust or other languages that compile to WASM.
1. **Smart Contract Deployment**: Allows developers to deploy smart contracts written in Rust or other languages that
compile to WASM.
2. **Smart Contract Execution**: Facilitates the execution of smart contract functions on the blockchain.
3. **Smart Contract Interaction**: Enables users and other smart contracts to interact with deployed smart contracts.
For a more detailed guide on integrating the wasm module into your application, please refer to the [Jackal Protocol GitHub](https://github.com/JackalLabs/canine-chain/blob/master/x/README.md).
For a more detailed guide on integrating the wasm module into your application, please refer to
the [Jackal Protocol GitHub](https://github.com/JackalLabs/canine-chain/blob/master/x/README.md).

24
docs/protocol/p-o-p.md
View File

@ -5,15 +5,26 @@ sidebar_position: 1
# Jackal Proof-of-Persistence Documentation
## Overview
Jackal Storage is powered by a Proof-of-Storage algorithm called Proof-of-Persistence (JPOP). JPOP is designed to ensure the secure and persistent storage of user data through a series of contracts formed between the storage provider and the user. These contracts contain the Merkle Tree root hash of the file and the information required to prove ownership of the file. In this documentation, we'll explain the core components and processes involved in the Jackal Proof-of-Persistence.
Jackal Storage is powered by a Proof-of-Storage algorithm called Proof-of-Persistence (JPOP). JPOP is designed to ensure
the secure and persistent storage of user data through a series of contracts formed between the storage provider and the
user. These contracts contain the Merkle Tree root hash of the file and the information required to prove ownership of
the file. In this documentation, we'll explain the core components and processes involved in the Jackal
Proof-of-Persistence.
## Building the Trees
Merkle Trees are a core component of the JPOP mechanism, thus, it is important to outline how these trees are used to create efficient and trustworthy proofs. When saving a file for the first time, providers split each file into many 1kb chunks. Providers must also hash the entire file to create a folder to house every chunk, this is displayed by the following diagram.
Merkle Trees are a core component of the JPOP mechanism, thus, it is important to outline how these trees are used to
create efficient and trustworthy proofs. When saving a file for the first time, providers split each file into many 1kb
chunks. Providers must also hash the entire file to create a folder to house every chunk, this is displayed by the
following diagram.
![File Tree](/img/jkl_paper/tree1.png)
These chunks are used as leaves on the Merkle Tree defining each storage contract. Immediately after saving a file to disk, the storage provider builds a tree using each chunk. To create this tree, each chunk is hashed into a respective Hashed Chunk. These chunks are then recursively paired together and hashed until a single root node is created. This is called the Merkle Root, the only piece of data relative to a file that is saved directly on the blockchain itself.
These chunks are used as leaves on the Merkle Tree defining each storage contract. Immediately after saving a file to
disk, the storage provider builds a tree using each chunk. To create this tree, each chunk is hashed into a respective
Hashed Chunk. These chunks are then recursively paired together and hashed until a single root node is created. This is
called the Merkle Root, the only piece of data relative to a file that is saved directly on the blockchain itself.
![Merkle Roots](/img/jkl_paper/tree2.png)
@ -21,6 +32,11 @@ In the diagram above, displays how each file is hashed together to create a sing
## Proving Data Availability
These nodes are essential as they only require the nodes below them to prove they are part of the tree. This means that we can create a proof claiming a single chunk belongs to the file using the Merkle Root saved on the chain. In the following diagram, we can see that only the blue nodes are required to build a successful proof. The green nodes represent information that we can generate given the blue nodes. Finally, we can compare the root generated from the proof to the root saved on the chain and determine if the chunk does belong to the contract we are proving. This results in small message sizes due to not needing to send the entire file every proof.
These nodes are essential as they only require the nodes below them to prove they are part of the tree. This means that
we can create a proof claiming a single chunk belongs to the file using the Merkle Root saved on the chain. In the
following diagram, we can see that only the blue nodes are required to build a successful proof. The green nodes
represent information that we can generate given the blue nodes. Finally, we can compare the root generated from the
proof to the root saved on the chain and determine if the chunk does belong to the contract we are proving. This results
in small message sizes due to not needing to send the entire file every proof.
![Merkle Roots Graphed](/img/jkl_paper/tree3.png)

32
docs/protocol/tokens.md
View File

@ -1,40 +1,58 @@
---
sidebar_position: 1
---
# JKL Token
## Overview
The JKL token is an inflationary token that powers the Jackal Protocol. It has numerous use cases within the ecosystem, ensuring its utility and importance. In this documentation, we will outline the main use cases of the JKL token and explain its role in the Jackal Protocol ecosystem.
The JKL token is an inflationary token that powers the Jackal Protocol. It has numerous use cases within the ecosystem,
ensuring its utility and importance. In this documentation, we will outline the main use cases of the JKL token and
explain its role in the Jackal Protocol ecosystem.
## Use Cases
### dApps
Applications built leveraging the Jackal Protocol, such as Jackal Storage and the RNS Marketplace, may choose to include the JKL token to expand its utility.
Applications built leveraging the Jackal Protocol, such as Jackal Storage and the RNS Marketplace, may choose to include
the JKL token to expand its utility.
### Securing the Network
As the Jackal Protocol is a Proof-of-Stake (PoS) Cosmos L1 blockchain, JKL can be delegated to validators to secure the network and earn JKL rewards. Otherwise known as staking or bonded tokens.
As the Jackal Protocol is a Proof-of-Stake (PoS) Cosmos L1 blockchain, JKL can be delegated to validators to secure the
network and earn JKL rewards. Otherwise known as staking or bonded tokens.
### Transaction Fees
Transactions on the Jackal Protocol must be paid for using JKL. As the protocol is PoS, the cost of transactions is inexpensive.
Transactions on the Jackal Protocol must be paid for using JKL. As the protocol is PoS, the cost of transactions is
inexpensive.
### Governance
Staked tokens grant on-chain governance participation within the Jackal Protocol to vote on text, software, spend, and other governance proposals.
Staked tokens grant on-chain governance participation within the Jackal Protocol to vote on text, software, spend, and
other governance proposals.
### Collateral
The JKL token can act as collateral for validators, storage providers, and other smart contract use cases.
### Liquidity Provision
JKL can be allocated into a liquidity pool to earn rewards.
## Unique JKL Token Utility for Users and Storage Providers
### Users
Users seeking storage solutions can leverage JKL tokens to pay for the storage services provided by storage providers within the Jackal Protocol. By utilizing JKL tokens as a medium of exchange, users can access a decentralized, secure, and censorship-resistant storage infrastructure.
Users seeking storage solutions can leverage JKL tokens to pay for the storage services provided by storage providers
within the Jackal Protocol. By utilizing JKL tokens as a medium of exchange, users can access a decentralized, secure,
and censorship-resistant storage infrastructure.
### Storage Providers
Storage providers are incentivized to offer storage space and maintain a high level of service by earning JKL tokens. By receiving JKL tokens as payment for their services, storage providers can cover the costs of infrastructure, hardware, and bandwidth while potentially profiting from their participation in the ecosystem.
Storage providers are incentivized to offer storage space and maintain a high level of service by earning JKL tokens. By
receiving JKL tokens as payment for their services, storage providers can cover the costs of infrastructure, hardware,
and bandwidth while potentially profiting from their participation in the ecosystem.

10
docs/protocol/validators.md
View File

@ -1,9 +1,15 @@
---
sidebar_position: 5
---
# Validators
The Jackal Validators are secure web servers, dedicated machines that participate in the consensus protocol by broadcasting cryptographic signatures, or votes, to agree upon the next block. Voting power is determined by the amount of staking tokens delegated by non-validators and bonded as collateral to earn a reward. These non-validators, or delegators, incur the risk of getting punished (slashed) if the delegate validator gets hacked or violates the protocol.
To set up a validator and become a contributing part of the network, read the installation instructions [here](/docs/nodes/nodes/installation)
The Jackal Validators are secure web servers, dedicated machines that participate in the consensus protocol by
broadcasting cryptographic signatures, or votes, to agree upon the next block. Voting power is determined by the amount
of staking tokens delegated by non-validators and bonded as collateral to earn a reward. These non-validators, or
delegators, incur the risk of getting punished (slashed) if the delegate validator gets hacked or violates the protocol.
To set up a validator and become a contributing part of the network, read the installation
instructions [here](/docs/nodes/nodes/installation)

2
docs/using-jackal/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Using Jackal",
"position":4
"position": 4
}

23
docs/using-jackal/dashboard.md
View File

@ -4,7 +4,8 @@ sidebar_position: 4
# Jackal Dashboard Guide
The Jackal Dashboard is your one-stop destination for interacting with the Jackal Protocol and Cosmos ecosystem. This guide will walk you through the various features and capabilities available on the Jackal Dashboard.
The Jackal Dashboard is your one-stop destination for interacting with the Jackal Protocol and Cosmos ecosystem. This
guide will walk you through the various features and capabilities available on the Jackal Dashboard.
## 1. File Management
@ -13,15 +14,16 @@ The Jackal Dashboard allows users to upload, download, delete, and share files s
### Uploading Files
1. Navigate to the "Storage" tab on navigation bar of the Jackal Dashboard.
2. Click "Browse Files" and select the file(s) you want to upload. Users can also drag and drop files into the dashboard directly.
3. Click "Encrypt & Upload" on the right side of the screen.
4. Sign the transaction prompt for your Keplr wallet.
2. Click "Browse Files" and select the file(s) you want to upload. Users can also drag and drop files into the dashboard
directly.
3. Click "Encrypt & Upload" on the right side of the screen.
4. Sign the transaction prompt for your Keplr wallet.
### Downloading Files
1. In the "Storage" tab, locate the file you want to download.
2. Click the "..." button relative to the file you wish to download.
3. Click "Download".
3. Click "Download".
4. The file will be downloaded to your local device.
### Sharing Files (Coming Soon)
@ -29,8 +31,7 @@ The Jackal Dashboard allows users to upload, download, delete, and share files s
## 2. Buy Tokens
1. Navigate to the "Buy Tokens" tab on the Jackal Dashboard.
2. You will be re-directed to the Osmosis Decentralized Exchange in another tab.
2. You will be re-directed to the Osmosis Decentralized Exchange in another tab.
## 3. Name Service
@ -39,14 +40,14 @@ The Jackal Dashboard enables users to register and manage RNS names.
### Registering RNS Names
1. Navigate to the "Name Service" tab on the Jackal Dashboard.
2. Click "Register"
3. Enter your desired name and how many years you wish to keep it for.
2. Click "Register"
3. Enter your desired name and how many years you wish to keep it for.
4. Confirm the transaction in your connected wallet.
### Managing RNS Names
1. In the "Name Service" tab, view your owned RNS addresses.
2. Click on a "..." next to the name you wish to manage.
2. Click on a "..." next to the name you wish to manage.
## 4. Name Service Marketplace
@ -56,7 +57,7 @@ The RNS Marketplace allows users to buy and sell RNS names.
2. Browse available RNS names or search for a specific name.
3. Click "Buy" to purchase an RNS name or "Sell" to list one of your RNS names for sale.
## 5. Hosting Static Websites (Coming Soon)
## 5. Hosting Static Websites (Coming Soon)
## 6. Governance Participation

29
docs/using-jackal/delegate.md
View File

@ -4,7 +4,8 @@ sidebar_position: 3
# How to Delegate JKL Tokens to a Validator
This guide will help you delegate your JKL tokens to a validator on the Jackal Protocol, which helps secure the network and earns you staking rewards.
This guide will help you delegate your JKL tokens to a validator on the Jackal Protocol, which helps secure the network
and earns you staking rewards.
## Step 1: Set up a Keplr Wallet
@ -26,24 +27,34 @@ This guide will help you delegate your JKL tokens to a validator on the Jackal P
1. Enter the amount of JKL tokens you want to delegate.
2. Click "Delegate" and confirm the transaction in your Keplr Wallet.
3. Once the transaction is complete, you will see your delegated JKL tokens and earned rewards in the "Staking" or "Delegations" tab on the dashboards.
3. Once the transaction is complete, you will see your delegated JKL tokens and earned rewards in the "Staking" or "
Delegations" tab on the dashboards.
## Step 5: Monitor and Manage Your Delegation
1. You can redelegate your JKL tokens to another validator or undelegate (unbond) them if you want to withdraw your tokens. Note that there is a 14-day unbonding period during which your tokens are locked and not earning rewards.
1. You can redelegate your JKL tokens to another validator or undelegate (unbond) them if you want to withdraw your
tokens. Note that there is a 14-day unbonding period during which your tokens are locked and not earning rewards.
Now you have successfully delegated your JKL tokens to a validator on the Jackal Protocol, contributing to the network's security and earning staking rewards.
Now you have successfully delegated your JKL tokens to a validator on the Jackal Protocol, contributing to the network's
security and earning staking rewards.
### Reminder
If you possess JKL tokens, you can temporarily lock them away to secure the protocol, this is called staking or delegating. In exchange for securing the network with your tokens, you receive rewards and the ability to vote on the Protocol’s future. These rewards come from newly generated JKL tokens and transaction fees.
### Reminder
It should be noted that staking or delegating is not risk free, this is why it is important to learn about the risks and participate in sustainable staking practices.
If you possess JKL tokens, you can temporarily lock them away to secure the protocol, this is called staking or
delegating. In exchange for securing the network with your tokens, you receive rewards and the ability to vote on the
Protocol’s future. These rewards come from newly generated JKL tokens and transaction fees.
To decrease risk, it’s recommended that you do research on validators and select one you trust as well as delegate to multiple validators.
It should be noted that staking or delegating is not risk free, this is why it is important to learn about the risks and
participate in sustainable staking practices.
To decrease risk, it’s recommended that you do research on validators and select one you trust as well as delegate to
multiple validators.
#### Slashing by 0.01%
Occurs if the validator you delegate to is offline for too long.
#### Slashing by 5%
Occurs if the validator signs two different blocks at the same block height. This is often caused by bad validator operation practices or malicious intent by the validator.
Occurs if the validator signs two different blocks at the same block height. This is often caused by bad validator
operation practices or malicious intent by the validator.

6
docs/using-jackal/fund.md
View File

@ -4,7 +4,8 @@ sidebar_position: 2
# Accessing JKL Tokens on Osmosis and Withdrawing to Jackal Protocol
This guide will help you access JKL tokens on the Osmosis Decentralized Exchange (DEX) and withdraw them to the Jackal Protocol using Inter-Blockchain Communication (IBC).
This guide will help you access JKL tokens on the Osmosis Decentralized Exchange (DEX) and withdraw them to the Jackal
Protocol using Inter-Blockchain Communication (IBC).
## Step 1: Set up a Keplr Wallet
@ -28,7 +29,8 @@ This guide will help you access JKL tokens on the Osmosis Decentralized Exchange
1. Visit the [Assets Page](https://app.osmosis.zone/assets).
2. Find the JKL asset and click "withdraw".
3. Once you sign the transaction with your Keplr wallet, an IBC transfer has begun and your JKL tokens will be available on the Jackal Protocol shortly.
3. Once you sign the transaction with your Keplr wallet, an IBC transfer has begun and your JKL tokens will be available
on the Jackal Protocol shortly.
Now you have successfully accessed JKL tokens on the Osmosis DEX and withdrawn them to the Jackal Protocol using IBC.

2
docs/using-jackal/wallet/_category_.json
View File

@ -1,4 +1,4 @@
{
"label": "Wallets",
"position":1
"position": 1
}

54
docs/using-jackal/wallet/keplr.md
View File

@ -1,45 +1,55 @@
---
sidebar_position: 2
---
# Keplr Wallet
The Keplr browser extension is a wallet for accessing some Jackal applications in the [Cosmos ecosystem](https://cosmos.network/). Keplr can be used to exchange/manage JKL and other Cosmos-based tokens, participate in governance from the [Jackal Dashboard](/docs/using-jackal/dashboard.md), and use Jackal Storage.
The Keplr browser extension is a wallet for accessing some Jackal applications in
the [Cosmos ecosystem](https://cosmos.network/). Keplr can be used to exchange/manage JKL and other Cosmos-based tokens,
participate in governance from the [Jackal Dashboard](/docs/using-jackal/dashboard.md), and use Jackal Storage.
## Set up Keplr
More information about setting up a Keplr wallet can be found in the official [Keplr Documentation](https://docs.keplr.app/).
Open the Keplr extension on your browser. If you are setting up Keplr for the first time, you can either __create a new account__ or __import an existing account__.
More information about setting up a Keplr wallet can be found in the
official [Keplr Documentation](https://docs.keplr.app/).
Open the Keplr extension on your browser. If you are setting up Keplr for the first time, you can either __create a new
account__ or __import an existing account__.
## Create a new account
There are two ways to create a new Keplr account:
__Most Secure__
- Mnemonic/seed phrase.
__Easiest__
- One-click login.
__Easiest__
- One-click login.
### Create an account with a Seed Phrase
1. In the initial pop-up window, choose Create New Account
- If you have used Keplr before, click on the silhouette in the upper-right corner, then the blue box labeled __Add Account__, and select __Create New Account__.
- If you have used Keplr before, click on the silhouette in the upper-right corner, then the blue box labeled __Add
Account__, and select __Create New Account__.
2. Choose to have a seed/mnemonic phrase of 24 words, and save the phrase.
- You can change the derivation path by clicking on Advanced, but this is optional [learn more in the Keplr FAQ](https://faq.keplr.app/)
- You can change the derivation path by clicking on Advanced, but this is
optional [learn more in the Keplr FAQ](https://faq.keplr.app/)
3. Enter a name for your account. This can be changed later.
4. Once you have transcribed your 24 word seed/mnemonic phrase, click on __Next__
5. To confirm the creation of the new account, click on the words on the right order in which they appear in your seed/mnemonic phrase, and press __Register__.
5. To confirm the creation of the new account, click on the words on the right order in which they appear in your
seed/mnemonic phrase, and press __Register__.
5. If you have not used Keplr before, set a password for the Keplr extension, and click __Confirm__.
### Import an existing account
There are several ways to import an existing account:
There are several ways to import an existing account:
- via a __mnemonic/seed phrase/private key__.
- via __ledger__.
@ -47,13 +57,17 @@ __Easiest__
__Import with a Seed Phrase__
1. In the initial pop-up window, choose Import Existing Account
If you have used Keplr before, click on the silhouette in the upper-right corner, then the blue box labeled __Add Account__, and select __Import Existing Account__.
If you have used Keplr before, click on the silhouette in the upper-right corner, then the blue box labeled __Add
Account__, and select __Import Existing Account__.
2. Enter your mnemonic/seed phrase/private key in the appropriate slot, seperating the words with spaces and make sure to check they are spelled correctly.
2. Enter your mnemonic/seed phrase/private key in the appropriate slot, seperating the words with spaces and make sure
to check they are spelled correctly.
3. Make sure you have imported the account with the correct derivation path, viewable by clicking on __Advanced__.
- Normally, the derivation path should be m/44'/…’/0/0/0, but if you see that importing the account via mnemonic on Keplr, the Cosmos Mainnet address displayed is different than yours, it is possible the derivation path ends with 1 (or another number) instead of 0.
- Normally, the derivation path should be m/44'/…’/0/0/0, but if you see that importing the account via mnemonic on
Keplr, the Cosmos Mainnet address displayed is different than yours, it is possible the derivation path ends with
1 (or another number) instead of 0.
- If this is the case, you just have to start the process over, and replace the last 0 with 1
@ -62,12 +76,18 @@ If you have used Keplr before, click on the silhouette in the upper-right corner
4. If you have not used Keplr before, set a password for the Keplr extension, and click __Confirm__.
__Import with Ledger__
1. In the initial pop-up window, choose Import Ledger.
- If you have used Keplr before, click on the silhouette in the upper-right corner, then the blue box labeled __Add Account__, and select __Import Ledger__.
2. To complete the connection with your Ledger Nano Hard Wallet, follow the steps described in the pop-up that appears. A detailed tutorial can be found [here](https://medium.com/chainapsis/how-to-use-ledger-nano-hardware-wallet-with-keplr-9ea7f07826c2).
1. In the initial pop-up window, choose Import Ledger.
- If you have used Keplr before, click on the silhouette in the upper-right corner, then the blue box labeled __Add
Account__, and select __Import Ledger__.
2. To complete the connection with your Ledger Nano Hard Wallet, follow the steps described in the pop-up that appears.
A detailed tutorial can be
found [here](https://medium.com/chainapsis/how-to-use-ledger-nano-hardware-wallet-with-keplr-9ea7f07826c2).
3. If you have not used Keplr before, set a password for the Keplr extension, and click __Confirm__.
## Connecting Keplr to the Jackal Protocol
Once you are signed in to the Keplr extension, you can connect the wallet with the Jackal Protocol. Once on the __Jackal Dashboard__ you will be prompted to connect your Keplr wallet.
Once you are signed in to the Keplr extension, you can connect the wallet with the Jackal Protocol. Once on the __Jackal
Dashboard__ you will be prompted to connect your Keplr wallet.