bump: version 0.5.27 → 0.6.0

test: Add commitizen dry run step to checks workflow (#1217 )
refactor/internal (#1216 )
2026-08-03 18:01:39 +00:00 · 2024-12-24 16:25:16 +00:00 · 2024-12-24 16:24:04 +00:00 · 2024-12-24 16:10:20 +00:00 · 2024-12-24 15:38:17 +00:00 · 2024-12-24 03:37:27 -05:00
650 changed files with 20732 additions and 28369 deletions
@@ -2,6 +2,7 @@
 name = "cz_conventional_commits"
 tag_format = "v$version"
 version_scheme = "semver"
-version = "0.5.19"
+version = "0.6.0"
-update_changelog_on_bump = true
+update_changelog_on_bump = false
 major_version_zero = true
 changelog_file = "CHANGELOG.md"
@@ -1,569 +0,0 @@
 # Protocol Buffers in Cosmos SDK
 ## Overview
 The Cosmos SDK uses Protocol Buffers for serialization and API definitions. Generation is handled via a Docker image: `ghcr.io/cosmos/proto-builder:0.15.x`.
 ## Generation Tools
 - **Buf**: Primary tool for protobuf management
 - **protocgen.sh**: Core generation script in `scripts/` 
 - **Makefile Commands**: Standard commands for generate, lint, format
 ## Key Components
 ### Buf Configuration
 1. **Workspace Setup**
   - Root level buf workspace configuration
   - Manages multiple protobuf directories
 2. **Directory Structure**
   ```
   proto/
   ├── buf.gen.gogo.yaml    # GoGo Protobuf generation
   ├── buf.gen.pulsar.yaml  # Pulsar API generation  
   ├── buf.gen.swagger.yaml # OpenAPI/Swagger docs
   ├── buf.lock            # Dependencies
   ├── buf.yaml            # Core configuration
   ├── cosmos/            # Core protos
   └── tendermint/        # Consensus protos
   ```
 3. **Module Protos**
   - Located in `x/{moduleName}/proto`
   - Module-specific message definitions
 #### `buf.gen.gogo.yaml`
 `buf.gen.gogo.yaml` defines how the protobuf files should be generated for use with in the module. This file uses [gogoproto](https://github.com/gogo/protobuf), a separate generator from the google go-proto generator that makes working with various objects more ergonomic, and it has more performant encode and decode steps
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/main/proto/buf.gen.gogo.yaml#L1-L9
 ```
 #### `buf.gen.pulsar.yaml`
 `buf.gen.pulsar.yaml` defines how protobuf files should be generated using the [new golang apiv2 of protobuf](https://go.dev/blog/protobuf-apiv2). This generator is used instead of the google go-proto generator because it has some extra helpers for Cosmos SDK applications and will have more performant encode and decode than the google go-proto generator. You can follow the development of this generator [here](https://github.com/cosmos/cosmos-proto).
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/main/proto/buf.gen.pulsar.yaml#L1-L18
 ```
 #### `buf.gen.swagger.yaml`
 `buf.gen.swagger.yaml` generates the swagger documentation for the query and messages of the chain. This will only define the REST API end points that were defined in the query and msg servers. You can find examples of this [here](https://github.com/cosmos/cosmos-sdk/blob/main/x/bank/proto/cosmos/bank/v1beta1/query.proto)
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/main/proto/buf.gen.swagger.yaml#L1-L6
 ```
 #### `buf.lock`
 This is an autogenerated file based off the dependencies required by the `.gen` files. There is no need to copy the current one. If you depend on cosmos-sdk proto definitions a new entry for the Cosmos SDK will need to be provided. The dependency you will need to use is `buf.build/cosmos/cosmos-sdk`.
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/main/proto/buf.lock#L1-L16
 ```
 #### `buf.yaml`
 `buf.yaml` defines the [name of your package](https://github.com/cosmos/cosmos-sdk/blob/main/proto/buf.yaml#L3), which [breakage checker](https://buf.build/docs/tutorials/getting-started-with-buf-cli#detect-breaking-changes) to use and how to [lint your protobuf files](https://buf.build/docs/tutorials/getting-started-with-buf-cli#lint-your-api).
 It is advised to use a tagged version of the buf modules corresponding to the version of the Cosmos SDK being are used.
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/main/proto/buf.yaml#L1-L24
 ```
 We use a variety of linters for the Cosmos SDK protobuf files. The repo also checks this in ci.
 A reference to the github actions can be found [here](https://github.com/cosmos/cosmos-sdk/blob/main/.github/workflows/proto.yml#L1-L32)
 # ORM
 The Cosmos SDK ORM is a state management library that provides a rich, but opinionated set of tools for managing a
 module's state. It provides support for:
 - type safe management of state
 - multipart keys
 - secondary indexes
 - unique indexes
 - easy prefix and range queries
 - automatic genesis import/export
 - automatic query services for clients, including support for light client proofs (still in development)
 - indexing state data in external databases (still in development)
 ## Design and Philosophy
 The ORM's data model is inspired by the relational data model found in SQL databases. The core abstraction is a table
 with a primary key and optional secondary indexes.
 Because the Cosmos SDK uses protobuf as its encoding layer, ORM tables are defined directly in .proto files using
 protobuf options. Each table is defined by a single protobuf `message` type and a schema of multiple tables is
 represented by a single .proto file.
 Table structure is specified in the same file where messages are defined in order to make it easy to focus on better
 design of the state layer. Because blockchain state layout is part of the public API for clients (TODO: link to docs on
 light client proofs), it is important to think about the state layout as being part of the public API of a module.
 Changing the state layout actually breaks clients, so it is ideal to think through it carefully up front and to aim for
 a design that will eliminate or minimize breaking changes down the road. Also, good design of state enables building
 more performant and sophisticated applications. Providing users with a set of tools inspired by relational databases
 which have a long history of database design best practices and allowing schema to be specified declaratively in a
 single place are design choices the ORM makes to enable better design and more durable APIs.
 Also, by only supporting the table abstraction as opposed to key-value pair maps, it is easy to add to new
 columns/fields to any data structure without causing a breaking change and the data structures can easily be indexed in
 any off-the-shelf SQL database for more sophisticated queries.
 The encoding of fields in keys is designed to support ordered iteration for all protobuf primitive field types
 except for `bytes` as well as the well-known types `google.protobuf.Timestamp` and `google.protobuf.Duration`. Encodings
 are optimized for storage space when it makes sense (see the documentation in `cosmos/orm/v1/orm.proto` for more details)
 and table rows do not use extra storage space to store key fields in the value.
 We recommend that users of the ORM attempt to follow database design best practices such as
 [normalization](https://en.wikipedia.org/wiki/Database_normalization) (at least 1NF).
 For instance, defining `repeated` fields in a table is considered an anti-pattern because breaks first normal form (1NF).
 Although we support `repeated` fields in tables, they cannot be used as key fields for this reason. This may seem
 restrictive but years of best practice (and also experience in the SDK) have shown that following this pattern
 leads to easier to maintain schemas.
 To illustrate the motivation for these principles with an example from the SDK, historically balances were stored
 as a mapping from account -> map of denom to amount. This did not scale well because an account with 100 token balances
 needed to be encoded/decoded every time a single coin balance changed. Now balances are stored as account,denom -> amount
 as in the example above. With the ORM's data model, if we wanted to add a new field to `Balance` such as
 `unlocked_balance` (if vesting accounts were redesigned in this way), it would be easy to add it to this table without
 requiring a data migration. Because of the ORM's optimizations, the account and denom are only stored in the key part
 of storage and not in the value leading to both a flexible data model and efficient usage of storage.
 ## Defining Tables
 To define a table:
 1. create a .proto file to describe the module's state (naming it `state.proto` is recommended for consistency),
   and import "cosmos/orm/v1/orm.proto", ex:
 ```protobuf
 syntax = "proto3";
 package bank_example;
 import "cosmos/orm/v1/orm.proto";
 ```
 2. define a `message` for the table, ex:
 ```protobuf
 message Balance {
  bytes account = 1;
  string denom = 2;
  uint64 balance = 3;
 }
 ```
 3. add the `cosmos.orm.v1.table` option to the table and give the table an `id` unique within this .proto file:
 ```protobuf
 message Balance {
  option (cosmos.orm.v1.table) = {
    id: 1
  };
  bytes account = 1;
  string denom = 2;
  uint64 balance = 3;
 }
 ```
 4. define the primary key field or fields, as a comma-separated list of the fields from the message which should make
   up the primary key:
 ```protobuf
 message Balance {
  option (cosmos.orm.v1.table) = {
    id: 1
    primary_key: { fields: "account,denom" }
  };
  bytes account = 1;
  string denom = 2;
  uint64 balance = 3;
 }
 ```
 5. add any desired secondary indexes by specifying an `id` unique within the table and a comma-separate list of the
   index fields:
 ```protobuf
 message Balance {
  option (cosmos.orm.v1.table) = {
    id: 1;
    primary_key: { fields: "account,denom" }
    index: { id: 1 fields: "denom" } // this allows querying for the accounts which own a denom
  };
  bytes account = 1;
  string denom   = 2;
  uint64 amount  = 3;
 }
 ```
 ### Auto-incrementing Primary Keys
 A common pattern in SDK modules and in database design is to define tables with a single integer `id` field with an
 automatically generated primary key. In the ORM we can do this by setting the `auto_increment` option to `true` on the
 primary key, ex:
 ```protobuf
 message Account {
  option (cosmos.orm.v1.table) = {
    id: 2;
    primary_key: { fields: "id", auto_increment: true }
  };
  uint64 id = 1;
  bytes address = 2;
 }
 ```
 ### Unique Indexes
 A unique index can be added by setting the `unique` option to `true` on an index, ex:
 ```protobuf
 message Account {
  option (cosmos.orm.v1.table) = {
    id: 2;
    primary_key: { fields: "id", auto_increment: true }
    index: {id: 1, fields: "address", unique: true}
  };
  uint64 id = 1;
  bytes address = 2;
 }
 ```
 ### Singletons
 The ORM also supports a special type of table with only one row called a `singleton`. This can be used for storing
 module parameters. Singletons only need to define a unique `id` and that cannot conflict with the id of other
 tables or singletons in the same .proto file. Ex:
 ```protobuf
 message Params {
  option (cosmos.orm.v1.singleton) = {
    id: 3;
  };
  google.protobuf.Duration voting_period = 1;
  uint64 min_threshold = 2;
 }
 ```
 ## Running Codegen
 NOTE: the ORM will only work with protobuf code that implements the [google.golang.org/protobuf](https://pkg.go.dev/google.golang.org/protobuf)
 API. That means it will not work with code generated using gogo-proto.
 To install the ORM's code generator, run:
 ```shell
 go install cosmossdk.io/orm/cmd/protoc-gen-go-cosmos-orm@latest
 ```
 The recommended way to run the code generator is to use [buf build](https://docs.buf.build/build/usage).
 This is an example `buf.gen.yaml` that runs `protoc-gen-go`, `protoc-gen-go-grpc` and `protoc-gen-go-cosmos-orm`
 using buf managed mode:
 ```yaml
 version: v1
 managed:
  enabled: true
  go_package_prefix:
    default: foo.bar/api # the go package prefix of your package
    override:
      buf.build/cosmos/cosmos-sdk: cosmossdk.io/api # required to import the Cosmos SDK api module
 plugins:
  - name: go
    out: .
    opt: paths=source_relative
  - name: go-grpc
    out: .
    opt: paths=source_relative
  - name: go-cosmos-orm
    out: .
    opt: paths=source_relative
 ```
 ## Using the ORM in a module
 ### Initialization
 To use the ORM in a module, first create a `ModuleSchemaDescriptor`. This tells the ORM which .proto files have defined
 an ORM schema and assigns them all a unique non-zero id. Ex:
 ```go
 var MyModuleSchema = &ormv1alpha1.ModuleSchemaDescriptor{
    SchemaFile: []*ormv1alpha1.ModuleSchemaDescriptor_FileEntry{
        {
            Id:            1,
            ProtoFileName: mymodule.File_my_module_state_proto.Path(),
        },
    },
 }
 ```
 In the ORM generated code for a file named `state.proto`, there should be an interface `StateStore` that got generated
 with a constructor `NewStateStore` that takes a parameter of type `ormdb.ModuleDB`. Add a reference to `StateStore`
 to your module's keeper struct. Ex:
 ```go
 type Keeper struct {
    db StateStore
 }
 ```
 Then instantiate the `StateStore` instance via an `ormdb.ModuleDB` that is instantiated from the `SchemaDescriptor`
 above and one or more store services from `cosmossdk.io/core/store`. Ex:
 ```go
 func NewKeeper(storeService store.KVStoreService) (*Keeper, error) {
    modDb, err := ormdb.NewModuleDB(MyModuleSchema, ormdb.ModuleDBOptions{KVStoreService: storeService})
    if err != nil {
        return nil, err
    }
    db, err := NewStateStore(modDb)
    if err != nil {
        return nil, err
    }
    return Keeper{db: db}, nil
 }
 ```
 ### Using the generated code
 The generated code for the ORM contains methods for inserting, updating, deleting and querying table entries.
 For each table in a .proto file, there is a type-safe table interface implemented in generated code. For instance,
 for a table named `Balance` there should be a `BalanceTable` interface that looks like this:
 ```go
 type BalanceTable interface {
    Insert(ctx context.Context, balance *Balance) error
    Update(ctx context.Context, balance *Balance) error
    Save(ctx context.Context, balance *Balance) error
    Delete(ctx context.Context, balance *Balance) error
    Has(ctx context.Context, account []byte, denom string) (found bool, err error)
    // Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
    Get(ctx context.Context, account []byte, denom string) (*Balance, error)
    List(ctx context.Context, prefixKey BalanceIndexKey, opts ...ormlist.Option) (BalanceIterator, error)
    ListRange(ctx context.Context, from, to BalanceIndexKey, opts ...ormlist.Option) (BalanceIterator, error)
    DeleteBy(ctx context.Context, prefixKey BalanceIndexKey) error
    DeleteRange(ctx context.Context, from, to BalanceIndexKey) error
    doNotImplement()
 }
 ```
 This `BalanceTable` should be accessible from the `StateStore` interface (assuming our file is named `state.proto`)
 via a `BalanceTable()` accessor method. If all the above example tables/singletons were in the same `state.proto`,
 then `StateStore` would get generated like this:
 ```go
 type BankStore interface {
    BalanceTable() BalanceTable
    AccountTable() AccountTable
    ParamsTable() ParamsTable
    doNotImplement()
 }
 ```
 So to work with the `BalanceTable` in a keeper method we could use code like this:
 ```go
 func (k keeper) AddBalance(ctx context.Context, acct []byte, denom string, amount uint64) error {
    balance, err := k.db.BalanceTable().Get(ctx, acct, denom)
    if err != nil && !ormerrors.IsNotFound(err) {
        return err
    }
    if balance == nil {
        balance = &Balance{
            Account: acct,
            Denom:   denom,
            Amount:  amount,
        }
    } else {
        balance.Amount = balance.Amount + amount
    }
    return k.db.BalanceTable().Save(ctx, balance)
 }
 ```
 `List` methods take `IndexKey` parameters. For instance, `BalanceTable.List` takes `BalanceIndexKey`. `BalanceIndexKey`
 let's represent index keys for the different indexes (primary and secondary) on the `Balance` table. The primary key
 in the `Balance` table gets a struct `BalanceAccountDenomIndexKey` and the first index gets an index key `BalanceDenomIndexKey`.
 If we wanted to list all the denoms and amounts that an account holds, we would use `BalanceAccountDenomIndexKey`
 with a `List` query just on the account prefix. Ex:
 ```go
 it, err := keeper.db.BalanceTable().List(ctx, BalanceAccountDenomIndexKey{}.WithAccount(acct))
 ```
 ---
 ## sidebar_position: 1
 # ProtocolBuffer Annotations
 This document explains the various protobuf scalars that have been added to make working with protobuf easier for Cosmos SDK application developers
 ## Signer
 Signer specifies which field should be used to determine the signer of a message for the Cosmos SDK. This field can be used for clients as well to infer which field should be used to determine the signer of a message.
 Read more about the signer field [here](./02-messages-and-queries.md).
 ```protobuf reference
 https://github.com/cosmos/cosmos-sdk/blob/e6848d99b55a65d014375b295bdd7f9641aac95e/proto/cosmos/bank/v1beta1/tx.proto#L40
 ```
 ```proto
 option (cosmos.msg.v1.signer) = "from_address";
 ```
 ## Scalar
 The scalar type defines a way for clients to understand how to construct protobuf messages according to what is expected by the module and sdk.
 ```proto
 (cosmos_proto.scalar) = "cosmos.AddressString"
 ```
 Example of account address string scalar:
 ```proto reference
 https://github.com/cosmos/cosmos-sdk/blob/e6848d99b55a65d014375b295bdd7f9641aac95e/proto/cosmos/bank/v1beta1/tx.proto#L46
 ```
 Example of validator address string scalar:
 ```proto reference
 https://github.com/cosmos/cosmos-sdk/blob/e8f28bf5db18b8d6b7e0d94b542ce4cf48fed9d6/proto/cosmos/distribution/v1beta1/query.proto#L87
 ```
 Example of pubkey scalar:
 ```proto reference
 https://github.com/cosmos/cosmos-sdk/blob/11068bfbcd44a7db8af63b6a8aa079b1718f6040/proto/cosmos/staking/v1beta1/tx.proto#L94
 ```
 Example of Decimals scalar:
 ```proto reference
 https://github.com/cosmos/cosmos-sdk/blob/e8f28bf5db18b8d6b7e0d94b542ce4cf48fed9d6/proto/cosmos/distribution/v1beta1/distribution.proto#L26
 ```
 Example of Int scalar:
 ```proto reference
 https://github.com/cosmos/cosmos-sdk/blob/e8f28bf5db18b8d6b7e0d94b542ce4cf48fed9d6/proto/cosmos/gov/v1/gov.proto#L137
 ```
 There are a few options for what can be provided as a scalar: `cosmos.AddressString`, `cosmos.ValidatorAddressString`, `cosmos.ConsensusAddressString`, `cosmos.Int`, `cosmos.Dec`.
 ## Implements_Interface
 Implement interface is used to provide information to client tooling like [telescope](https://github.com/cosmology-tech/telescope) on how to encode and decode protobuf messages.
 ```proto
 option (cosmos_proto.implements_interface) = "cosmos.auth.v1beta1.AccountI";
 ```
 ## Method,Field,Message Added In
 `method_added_in`, `field_added_in` and `message_added_in` are annotations to denotate to clients that a field has been supported in a later version. This is useful when new methods or fields are added in later versions and that the client needs to be aware of what it can call.
 The annotation should be worded as follow:
 ```proto
 option (cosmos_proto.method_added_in) = "cosmos-sdk v0.50.1";
 option (cosmos_proto.method_added_in) = "x/epochs v1.0.0";
 option (cosmos_proto.method_added_in) = "simapp v24.0.0";
 ```
 ## Amino
 The amino codec was removed in `v0.50+`, this means there is not a need register `legacyAminoCodec`. To replace the amino codec, Amino protobuf annotations are used to provide information to the amino codec on how to encode and decode protobuf messages.
 :::note
 Amino annotations are only used for backwards compatibility with amino. New modules are not required use amino annotations.
 :::
 The below annotations are used to provide information to the amino codec on how to encode and decode protobuf messages in a backwards compatible manner.
 ### Name
 Name specifies the amino name that would show up for the user in order for them see which message they are signing.
 ```proto
 option (amino.name) = "cosmos-sdk/BaseAccount";
 ```
 ```proto reference
 https://github.com/cosmos/cosmos-sdk/blob/e8f28bf5db18b8d6b7e0d94b542ce4cf48fed9d6/proto/cosmos/bank/v1beta1/tx.proto#L41
 ```
 ### Field_Name
 Field name specifies the amino name that would show up for the user in order for them see which field they are signing.
 ```proto
 uint64 height = 1 [(amino.field_name) = "public_key"];
 ```
 ```proto reference
 https://github.com/cosmos/cosmos-sdk/blob/e8f28bf5db18b8d6b7e0d94b542ce4cf48fed9d6/proto/cosmos/distribution/v1beta1/distribution.proto#L166
 ```
 ### Dont_OmitEmpty
 Dont omitempty specifies that the field should not be omitted when encoding to amino.
 ```proto
 repeated cosmos.base.v1beta1.Coin amount = 3 [(amino.dont_omitempty)   = true];
 ```
 ```proto reference
 https://github.com/cosmos/cosmos-sdk/blob/e8f28bf5db18b8d6b7e0d94b542ce4cf48fed9d6/proto/cosmos/bank/v1beta1/bank.proto#L56
 ```
 ### Encoding
 Encoding instructs the amino json marshaler how to encode certain fields that may differ from the standard encoding behaviour. The most common example of this is how `repeated cosmos.base.v1beta1.Coin` is encoded when using the amino json encoding format. The `legacy_coins` option tells the json marshaler [how to encode a null slice](https://github.com/cosmos/cosmos-sdk/blob/e8f28bf5db18b8d6b7e0d94b542ce4cf48fed9d6/x/tx/signing/aminojson/json_marshal.go#L65) of `cosmos.base.v1beta1.Coin`.
 ```proto
 (amino.encoding)         = "legacy_coins",
 ```
 ```proto reference
 https://github.com/cosmos/cosmos-sdk/blob/e8f28bf5db18b8d6b7e0d94b542ce4cf48fed9d6/proto/cosmos/bank/v1beta1/genesis.proto#L23
 ```
 Another example is a protobuf `bytes` that contains a valid JSON document.
 The `inline_json` option tells the json marshaler to embed the JSON bytes into the wrapping document without escaping.
 ```proto
 (amino.encoding)         = "inline_json",
 ```
 E.g. the bytes containing `{"foo":123}` in the `envelope` field would lead to the following JSON:
 ```json
 {
  "envelope": {
    "foo": 123
  }
 }
 ```
 If the bytes are not valid JSON, this leads to JSON broken documents. Thus a JSON validity check needs to be in place at some point of the process.
@@ -1,627 +0,0 @@
 # RFC 004: Account System Refactor
 ## Status
 - Draft v2 (May 2023)
 ## Current Limitations
 1. **Account Representation**: Limited by `google.Protobuf.Any` encapsulation and basic authentication methods
 2. **Interface Constraints**: Lacks support for advanced functionalities like vesting and complex auth systems
 3. **Implementation Rigidity**: Poor differentiation between account types (e.g., `ModuleAccount`)
 4. **Authorization System**: Basic `x/auth` module with limited scope beyond `x/bank` functionality
 5. **Dependency Issues**: Cyclic dependencies between modules (e.g., `x/auth` ↔ `x/bank` for vesting)
 ## Proposal
 This proposal aims to transform the way accounts are managed within the Cosmos SDK by introducing significant changes to
 their structure and functionality.
 ### Rethinking Account Representation and Business Logic
 Instead of representing accounts as simple `google.Protobuf.Any` structures stored in state with no business logic
 attached, this proposal suggests a more sophisticated account representation that is closer to module entities.
 In fact, accounts should be able to receive messages and process them in the same way modules do, and be capable of storing
 state in a isolated (prefixed) portion of state belonging only to them, in the same way as modules do.
 ### Account Message Reception
 We propose that accounts should be able to receive messages in the same way modules can, allowing them to manage their
 own state modifications without relying on other modules. This change would enable more advanced account functionality, such as the
 `VestingAccount` example, where the x/bank module previously needed to change the vestingState by casting the abstracted
 account to `VestingAccount` and triggering the `TrackDelegation` call. Accounts are already capable of sending messages when
 a state transition, originating from a transaction, is executed.
 When accounts receive messages, they will be able to identify the sender of the message and decide how to process the
 state transition, if at all.
 ### Consequences
 These changes would have significant implications for the Cosmos SDK, resulting in a system of actors that are equal from
 the runtime perspective. The runtime would only be responsible for propagating messages between actors and would not
 manage the authorization system. Instead, actors would manage their own authorizations. For instance, there would be no
 need for the `x/auth` module to manage minting or burning of coins permissions, as it would fall within the scope of the
 `x/bank` module.
 The key difference between accounts and modules would lie in the origin of the message (state transition). Accounts
 (ExternallyOwnedAccount), which have credentials (e.g., a public/private key pairing), originate state transitions from
 transactions. In contrast, module state transitions do not have authentication credentials backing them and can be
 caused by two factors: either as a consequence of a state transition coming from a transaction or triggered by a scheduler
 (e.g., the runtime's Begin/EndBlock).
 By implementing these proposed changes, the Cosmos SDK will benefit from a more extensible, versatile, and efficient account
 management system that is better suited to address the requirements of the Cosmos ecosystem.
 #### Standardization
 With `x/accounts` allowing a modular api there becomes a need for standardization of accounts or the interfaces wallets and other clients should expect to use. For this reason we will be using the [`CIP` repo](https://github.com/cosmos/cips) in order to standardize interfaces in order for wallets to know what to expect when interacting with accounts.
 ## Implementation
 ### Account Definition
 We define the new `Account` type, which is what an account needs to implement to be treated as such.
 An `Account` type is defined at APP level, so it cannot be dynamically loaded as the chain is running without upgrading the
 node code, unless we create something like a `CosmWasmAccount` which is an account backed by an `x/wasm` contract.
 ```go
 // Account is what the developer implements to define an account.
 type Account[InitMsg proto.Message] interface {
 	// Init is the function that initialises an account instance of a given kind.
 	// InitMsg is used to initialise the initial state of an account.
 	Init(ctx *Context, msg InitMsg) error
 	// RegisterExecuteHandlers registers an account's execution messages.
 	RegisterExecuteHandlers(executeRouter *ExecuteRouter)
 	// RegisterQueryHandlers registers an account's query messages.
 	RegisterQueryHandlers(queryRouter *QueryRouter)
 	// RegisterMigrationHandlers registers an account's migration messages.
 	RegisterMigrationHandlers(migrationRouter *MigrationRouter)
 }
 ```
 ### The InternalAccount definition
 The public `Account` interface implementation is then converted by the runtime into an `InternalAccount` implementation,
 which contains all the information and business logic needed to operate the account.
 ```go
 type Schema struct {
 	state StateSchema // represents the state of an account
 	init InitSchema // represents the init msg schema
 	exec ExecSchema // represents the multiple execution msg schemas, containing also responses
 	query QuerySchema // represents the multiple query msg schemas, containing also responses
 	migrate *MigrateSchema // represents the multiple migrate msg schemas, containing also responses, it's optional
 }
 type InternalAccount struct {
 	init    func(ctx *Context, msg proto.Message) (*InitResponse, error)
 	execute func(ctx *Context, msg proto.Message) (*ExecuteResponse, error)
 	query   func(ctx *Context, msg proto.Message) (proto.Message, error)
    schema  func() *Schema
    migrate func(ctx *Context, msg proto.Message) (*MigrateResponse, error)
 }
 ```
 This is an internal view of the account as intended by the system. It is not meant to be what developers implement. An
 example implementation of the `InternalAccount` type can be found in [this](https://github.com/testinginprod/accounts-poc/blob/main/examples/recover/recover.go)
 example of account whose credentials can be recovered. In fact, even if the `Internal` implementation is untyped (with
 respect to `proto.Message`), the concrete implementation is fully typed.
 During any of the execution methods of `InternalAccount`, `schema` excluded, the account is given a `Context` which provides:
 - A namespaced `KVStore` for the account, which isolates the account state from others (NOTE: no `store keys` needed,
  the account address serves as `store key`).
 - Information regarding itself (its address)
 - Information regarding the sender.
 - ...
 #### Init
 Init defines the entrypoint that allows for a new account instance of a given kind to be initialised.
 The account is passed some opaque protobuf message which is then interpreted and contains the instructions that
 constitute the initial state of an account once it is deployed.
 An `Account` code can be deployed multiple times through the `Init` function, similar to how a `CosmWasm` contract code
 can be deployed (Instantiated) multiple times.
 #### Execute
 Execute defines the entrypoint that allows an `Account` to process a state transition, the account can decide then how to
 process the state transition based on the message provided and the sender of the transition.
 #### Query
 Query defines a read-only entrypoint that provides a stable interface that links an account with its state. The reason for
 which `Query` is still being preferred as an addition to raw state reflection is to:
 - Provide a stable interface for querying (state can be optimised and change more frequently than a query)
 - Provide a way to define an account `Interface` with respect to its `Read/Write` paths.
 - Provide a way to query information that cannot be processed from raw state reflection, ex: compute information from lazy
  state that has not been yet concretely processed (eg: balances with respect to lazy inputs/outputs)
 #### Schema
 Schema provides the definition of an account from `API` perspective, and it's the only thing that should be taken into account
 when interacting with an account from another account or module, for example: an account is an `authz-interface` account if
 it has the following message in its execution messages `MsgProxyStateTransition{ state_transition: google.Protobuf.Any }`.
 ### Migrate
 Migrate defines the entrypoint that allows an `Account` to migrate its state from a previous version to a new one. Migrations
 can be initiated only by the account itself, concretely this means that the migrate action sender can only be the account address
 itself, if the account wants to allow another address to migrate it on its behalf then it could create an execution message
 that makes the account migrate itself.
 ### x/accounts module
 In order to create accounts we define a new module `x/accounts`, note that `x/accounts` deploys account with no authentication
 credentials attached to it which means no action of an account can be incepted from a TX, we will later explore how the
 `x/authn` module uses `x/accounts` to deploy authenticated accounts.
 This also has another important implication for which account addresses are now fully decoupled from the authentication mechanism
 which makes in turn off-chain operations a little more complex, as the chain becomes the real link between account identifier
 and credentials.
 We could also introduce a way to deterministically compute the account address.
 Note, from the transaction point of view, the `init_message` and `execute_message` are opaque `google.Protobuf.Any`.
 The module protobuf definition for `x/accounts` are the following:
 ```protobuf
 // Msg defines the Msg service.
 service Msg {
  rpc Deploy(MsgDeploy) returns (MsgDeployResponse);
  rpc Execute(MsgExecute) returns (MsgExecuteResponse);
  rpc Migrate(MsgMigrate) returns (MsgMigrateResponse);
 }
 message MsgDeploy {
  string sender = 1;
  string kind = 2;
  google.Protobuf.Any init_message = 3;
  repeated google.Protobuf.Any authorize_messages = 4 [(gogoproto.nullable) = false];
 }
 message MsgDeployResponse {
  string address = 1;
  uint64 id = 2;
  google.Protobuf.Any data = 3;
 }
 message MsgExecute {
  string sender = 1;
  string address = 2;
  google.Protobuf.Any message = 3;
  repeated google.Protobuf.Any authorize_messages = 4 [(gogoproto.nullable) = false];
 }
 message MsgExecuteResponse {
  google.Protobuf.Any data = 1;
 }
 message MsgMigrate {
  string sender = 1;
  string new_account_kind = 2;
  google.Protobuf.Any migrate_message = 3;
 }
 message MsgMigrateResponse {
  google.Protobuf.Any data = 1;
 }
 ```
 #### MsgDeploy
 Deploys a new instance of the given account `kind` with initial settings represented by the `init_message` which is a `google.Protobuf.Any`.
 Of course the `init_message` can be empty. A response is returned containing the account ID and humanised address, alongside some response
 that the account instantiation might produce.
 #### Address derivation
 In order to decouple public keys from account addresses, we introduce a new address derivation mechanism which is
 #### MsgExecute
 Sends a `StateTransition` execution request, where the state transition is represented by the `message` which is a `google.Protobuf.Any`.
 The account can then decide if to process it or not based on the `sender`.
 ### MsgMigrate
 Migrates an account to a new version of itself, the new version is represented by the `new_account_kind`. The state transition
 can only be incepted by the account itself, which means that the `sender` must be the account address itself. During the migration
 the account current state is given to the new version of the account, which then executes the migration logic using the `migrate_message`,
 it might change state or not, it's up to the account to decide. The response contains possible data that the account might produce
 after the migration.
 #### Authorize Messages
 The `Deploy` and `Execute` messages have a field in common called `authorize_messages`, these messages are messages that the account
 can execute on behalf of the sender. For example, in case an account is expecting some funds to be sent from the sender,
 the sender can attach a `MsgSend` that the account can execute on the sender's behalf. These authorizations are short-lived,
 they live only for the duration of the `Deploy` or `Execute` message execution, or until they are consumed.
 An alternative would have been to add a `funds` field, like it happens in cosmwasm, which guarantees the called contract that
 the funds are available and sent in the context of the message execution. This would have been a simpler approach, but it would
 have been limited to the context of `MsgSend` only, where the asset is `sdk.Coins`. The proposed generic way, instead, allows
 the account to execute any message on behalf of the sender, which is more flexible, it could include NFT send execution, or
 more complex things like `MsgMultiSend` or `MsgDelegate`, etc.
 ### Further discussion
 #### Sub-accounts
 We could provide a way to link accounts to other accounts. Maybe during deployment the sender could decide to link the
 newly created to its own account, although there might be use-cases for which the deployer is different from the account
 that needs to be linked, in this case a handshake protocol on linking would need to be defined.
 #### Predictable address creation
 We need to provide a way to create an account with a predictable address, this might serve a lot of purposes, like accounts
 wanting to generate an address that:
 - nobody else can claim besides the account used to generate the new account
 - is predictable
 For example:
 ```protobuf
 message MsgDeployPredictable {
  string sender = 1;
  uint32 nonce = 2;
  ...
 }
 ```
 And then the address becomes `bechify(concat(sender, nonce))`
 `x/accounts` would still use the monotonically increasing sequence as account number.
 #### Joining Multiple Accounts
 As developers are building new kinds of accounts, it becomes necessary to provide a default way to combine the
 functionalities of different account types. This allows developers to avoid duplicating code and enables end-users to
 create or migrate to accounts with multiple functionalities without requiring custom development.
 To address this need, we propose the inclusion of a default account type called "MultiAccount". The MultiAccount type is
 designed to merge the functionalities of other accounts by combining their execution, query, and migration APIs.
 The account joining process would only fail in the case of API (intended as non-state Schema APIs) conflicts, ensuring
 compatibility and consistency.
 With the introduction of the MultiAccount type, users would have the option to either migrate their existing accounts to
 a MultiAccount type or extend an existing MultiAccount with newer APIs. This flexibility empowers users to leverage
 various account functionalities without compromising compatibility or resorting to manual code duplication.
 The MultiAccount type serves as a standardized solution for combining different account functionalities within the
 cosmos-sdk ecosystem. By adopting this approach, developers can streamline the development process and users can benefit
 from a modular and extensible account system.
 # ADR 071: Cryptography v2- Multi-curve support
 ## Change log
 - May 7th 2024: Initial Draft (Zondax AG: @raynaudoe @juliantoledano @jleni @educlerici-zondax @lucaslopezf)
 - June 13th 2024: Add CometBFT implementation proposal (Zondax AG: @raynaudoe @juliantoledano @jleni @educlerici-zondax @lucaslopezf)
 - July 2nd 2024: Split ADR proposal, add link to ADR in cosmos/crypto (Zondax AG: @raynaudoe @juliantoledano @jleni @educlerici-zondax @lucaslopezf)
 ## Status
 DRAFT
 ## Abstract
 This ADR proposes the refactoring of the existing `Keyring` and `cosmos-sdk/crypto` code to implement [ADR-001-CryptoProviders](https://github.com/cosmos/crypto/blob/main/docs/architecture/adr-001-crypto-provider.md).
 For in-depth details of the `CryptoProviders` and their design please refer to ADR mentioned above.
 ## Introduction
 The introduction of multi-curve support in the cosmos-sdk cryptographic package offers significant advantages. By not being restricted to a single cryptographic curve, developers can choose the most appropriate curve based on security, performance, and compatibility requirements. This flexibility enhances the application's ability to adapt to evolving security standards and optimizes performance for specific use cases, helping to future-proofing the sdk's cryptographic capabilities.
 The enhancements in this proposal not only render the ["Keyring ADR"](https://github.com/cosmos/cosmos-sdk/issues/14940) obsolete, but also encompass its key aspects, replacing it with a more flexible and comprehensive approach. Furthermore, the gRPC service proposed in the mentioned ADR can be easily implemented as a specialized `CryptoProvider`.
 ### Glossary
 1. **Interface**: In the context of this document, "interface" refers to Go's interface.
 2. **Module**: In this document, "module" refers to a Go module.
 3. **Package**: In the context of Go, a "package" refers to a unit of code organization.
 ## Context
 In order to fully understand the need for changes and the proposed improvements, it's crucial to consider the current state of affairs:
 - The Cosmos SDK currently lacks a comprehensive ADR for the cryptographic package.
 - If a blockchain project requires a cryptographic curve that is not supported by the current SDK, the most likely scenario is that they will need to fork the SDK repository and make modifications. These modifications could potentially make the fork incompatible with future updates from the upstream SDK, complicating maintenance and integration.
 - Type leakage of specific crypto data types expose backward compatibility and extensibility challenges.
 - The demand for a more flexible and extensible approach to cryptography and address management is high.
 - Architectural changes are necessary to resolve many of the currently open issues related to new curves support.
 - There is a current trend towards modularity in the Interchain stack (e.g., runtime modules).
 - Security implications are a critical consideration during the redesign work.
 ## Objectives
 The key objectives for this proposal are:
 - Leverage `CryptoProviders`: Utilize them as APIs for cryptographic tools, ensuring modularity, flexibility, and ease of integration.
 Developer-Centric Approach
 - Prioritize clear, intuitive interfaces and best-practice design principles.
 Quality Assurance
 - Enhanced Test Coverage: Improve testing methodologies to ensure the robustness and reliability of the module.
 ## Technical Goals
 New Keyring:
 - Design a new `Keyring` interface with modular backends injection system to support hardware devices and cloud-based HSMs. This feature is optional and tied to complexity; if it proves too complex, it will be deferred to a future release as an enhancement.
 ## Proposed architecture
 ### Components
 The main components to be used will be the same as those found in the [ADR-001](https://github.com/cosmos/crypto/blob/main/docs/architecture/adr-001-crypto-provider.md#components).
 #### Storage and persistence
 The storage and persistence layer is tasked with storing a `CryptoProvider`s. Specifically, this layer must:
 - Securely store the crypto provider's associated private key (only if stored locally, otherwise a reference to the private key will be stored instead).
 - Store the [`ProviderMetadata`](https://github.com/cosmos/crypto/blob/main/docs/architecture/adr-001-crypto-provider.md#metadata) struct which contains the data that distinguishes that provider.
 The purpose of this layer is to ensure that upon retrieval of the persisted data, we can access the provider's type, version, and specific configuration (which varies based on the provider type). This information will subsequently be utilized to initialize the appropriate factory, as detailed in the following section on the factory pattern.
 The storage proposal involves using a modified version of the [Record](https://github.com/cosmos/cosmos-sdk/blob/main/proto/cosmos/crypto/keyring/v1/record.proto) struct, which is already defined in **Keyring/v1**. Additionally, we propose utilizing the existing keyring backends (keychain, filesystem, memory, etc.) to store these `Record`s in the same manner as the current **Keyring/v1**.
 _Note: This approach will facilitate a smoother migration path from the current Keyring/v1 to the proposed architecture._
 Below is the proposed protobuf message to be included in the modified `Record.proto` file
 ##### Protobuf message structure
 The [record.proto](https://github.com/cosmos/cosmos-sdk/blob/main/proto/cosmos/crypto/keyring/v1/record.proto) file will be modified to include the `CryptoProvider` message as an optional field as follows.
 ```protobuf
 // record.proto
 message Record {
  string name = 1;
  google.protobuf.Any pub_key = 2;
  oneof item {
    Local local = 3;
    Ledger ledger = 4;
    Multi multi = 5;
    Offline offline = 6;
    CryptoProvider crypto_provider = 7; // <- New
  }
  message Local {
    google.protobuf.Any priv_key = 1;
  }
  message Ledger {
    hd.v1.BIP44Params path = 1;
  }
  message Multi {}
  message Offline {}
 }
 ```
 ##### Creating and loading a `CryptoProvider`
 For creating providers, we propose a _factory pattern_ and a _registry_ for these builders. Examples of these
 patterns can be found [here](https://github.com/cosmos/crypto/blob/main/docs/architecture/adr-001-crypto-provider.md#illustrative-code-snippets)
 ##### Keyring
 The new `Keyring` interface will serve as a central hub for managing and fetching `CryptoProviders`. To ensure a smoother migration path, the new Keyring will be backward compatible with the previous version. Since this will be the main API from which applications will obtain their `CryptoProvider` instances, the proposal is to extend the Keyring interface to include the methods:
 ```go
 type KeyringV2 interface {
  // methods from Keyring/v1
  // ListCryptoProviders returns a list of all the stored CryptoProvider metadata.
  ListCryptoProviders() ([]ProviderMetadata, error)
  // GetCryptoProvider retrieves a specific CryptoProvider by its id.
  GetCryptoProvider(id string) (CryptoProvider, error)
 }
 ```
 _Note_: Methods to obtain a provider from a public key or other means that make it easier to load the desired provider can be added.
 ##### Especial use case: remote signers
 It's important to note that the `CryptoProvider` interface is versatile enough to be implemented as a remote signer. This capability allows for the integration of remote cryptographic operations, which can be particularly useful in distributed or cloud-based environments where local cryptographic resources are limited or need to be managed centrally.
 ## Alternatives
 It is important to note that all the code presented in this document is not in its final form and could be subject to changes at the time of implementation. The examples and implementations discussed should be interpreted as alternatives, providing a conceptual framework rather than definitive solutions. This flexibility allows for adjustments based on further insights, technical evaluations, or changing requirements as development progresses.
 ## Decision
 We will:
 - Leverage crypto providers
 - Refactor the module structure as described above.
 - Define types and interfaces as the code attached.
 - Refactor existing code into new structure and interfaces.
 - Implement Unit Tests to ensure no backward compatibility issues.
 ## Consequences
 ### Impact on the SDK codebase
 We can divide the impact of this ADR into two main categories: state machine code and client related code.
 #### Client
 The major impact will be on the client side, where the current `Keyring` interface will be replaced by the new `KeyringV2` interface. At first, the impact will be low since `CryptoProvider` is an optional field in the `Record` message, so there's no mandatory requirement for migrating to this new concept right away. This allows a progressive transition where the risks of breaking changes or regressions are minimized.
 #### State Machine
 The impact on the state machine code will be minimal, the modules affected (at the time of writing this ADR)
 are the `x/accounts` module, specifically the `Authenticate` function and the `x/auth/ante` module. This function will need to be adapted to use a `CryptoProvider` service to make use of the `Verifier` instance.
 Worth mentioning that there's also the alternative of using `Verifier` instances in a standalone fashion (see note below).
 The specific way to adapt these modules will be deeply analyzed and decided at implementation time of this ADR.
 _Note_: All cryptographic tools (hashers, verifiers, signers, etc.) will continue to be available as standalone packages that can be imported and utilized directly without the need for a `CryptoProvider` instance. However, the `CryptoProvider` is the recommended method for using these tools as it offers a more secure way to handle sensitive data, enhanced modularity, and the ability to store configurations and metadata within the `CryptoProvider` definition.
 ### Backwards Compatibility
 The proposed migration path is similar to what the cosmos-sdk has done in the past. To ensure a smooth transition, the following steps will be taken:
 Once ADR-001 is implemented with a stable release:
 - Deprecate the old crypto package. The old crypto package will still be usable, but it will be marked as deprecated and users can opt to use the new package.
 - Migrate the codebase to use the new cosmos/crypto package and remove the old crypto one.
 ### Positive
 - Single place of truth
 - Easier to use interfaces
 - Easier to extend
 - Unit test for each crypto package
 - Greater maintainability
 - Incentivize addition of implementations instead of forks
 - Decoupling behavior from implementation
 - Sanitization of code
 ### Negative
 - It will involve an effort to adapt existing code.
 - It will require attention to detail and audition.
 ### Neutral
 - It will involve extensive testing.
 ## Test Cases
 - The code will be unit tested to ensure a high code coverage
 - There should be integration tests around Keyring and CryptoProviders.
 > While an ADR is in the DRAFT or PROPOSED stage, this section should contain a
 > summary of issues to be solved in future iterations (usually referencing comments
 > from a pull-request discussion).
 >
 > Later, this section can optionally list ideas or improvements the author or
 > reviewers found during the analysis of this ADR.
 # ADR-71 Bank V2
 ## Status
 DRAFT
 ## Changelog
 - 2024-05-08: Initial Draft (@samricotta, @julienrbrt)
 ## Abstract
 The primary objective of refactoring the bank module is to simplify and enhance the functionality of the Cosmos SDK. Over time the bank module has been burdened with numerous responsibilities including transaction handling, account restrictions, delegation counting, and the minting and burning of coins.
 In addition to the above, the bank module is currently too rigid and handles too many tasks, so this proposal aims to streamline the module by focusing on core functions `Send`, `Mint`, and `Burn`.
 Currently, the module is split across different keepers with scattered and duplicates functionalities (with 4 send functions for instance).
 Additionally, the integration of the token factory into the bank module allows for standardization, and better integration within the core modules.
 This rewrite will reduce complexity and enhance the efficiency and UX of the bank module.
 ## Context
 The current implementation of the bank module is characterised by its handling of a broad array of functions, leading to significant complexity in using and extending the bank module.
 These issues have underscored the need for a refactoring strategy that simplifies the module’s architecture and focuses on its most essential operations.
 Additionally, there is an overlap in functionality with a Token Factory module, which could be integrated to streamline oper.
 ## Decision
 **Permission Tightening**: Access to the module can be restricted to selected denominations only, ensuring that it operates within designated boundaries and does not exceed its intended scope. Currently, the permissions allow all denoms, so this should be changed. Send restrictions functionality will be maintained.
 **Simplification of Logic**: The bank module will focus on core functionalities `Send`, `Mint`, and `Burn`. This refinement aims to streamline the architecture, enhancing both maintainability and performance.
 **Integration of Token Factory**: The Token Factory will be merged into the bank module. This consolidation of related functionalities aims to reduce redundancy and enhance coherence within the system. Migrations functions will be provided for migrating from Osmosis' Token Factory module to bank/v2.
 **Legacy Support**: A legacy wrapper will be implemented to ensure compatibility with about 90% of existing functions. This measure will facilitate a smooth transition while keeping older systems functional.
 **Denom Implementation**: A asset interface will be added to standardise interactions such as transfers, balance inquiries, minting, and burning across different tokens. This will allow the bank module to support arbitrary asset types, enabling developers to implement custom, ERC20-like denominations.
 For example, currently if a team would like to extend the transfer method the changes would apply universally, affecting all denom’s. With the proposed Asset Interface, it allows teams to customise or extend the transfer method specifically for their own tokens without impacting others.
 These improvements are expected to enhance the flexibility of the bank module, allowing for the creation of custom tokens similar to ERC20 standards and assets backed by CosmWasm (CW) contracts. The integration efforts will also aim to unify CW20 with bank coins across the Cosmos chains.
 Example of denom interface:
 ```go
 type AssetInterface interface {
    Transfer(ctx sdk.Context, from sdk.AccAddress, to sdk.AccAddress, amount sdk.Coin) error
    Mint(ctx sdk.Context, to sdk.AccAddress, amount sdk.Coin) error
    Burn(ctx sdk.Context, from sdk.AccAddress, amount sdk.Coin) error
    QueryBalance(ctx sdk.Context, account sdk.AccAddress) (sdk.Coin, error)
 }
 ```
 Overview of flow:
 1. Alice initiates a transfer by entering Bob's address and the amount (100 ATOM)
 2. The Bank module verifies that the ATOM token implements the `AssetInterface` by querying the `ATOM_Denom_Account`, which is an `x/account` denom account.
 3. The Bank module executes the transfer by subtracting 100 ATOM from Alice’s balance and adding 100 ATOM to Bob’s balance.
 4. The Bank module calls the Transfer method on the `ATOM_Denom_Account`. The Transfer method, defined in the `AssetInterface`, handles the logic to subtract 100 ATOM from Alice’s balance and add 100 ATOM to Bob’s balance.
 5. The Bank module updates the chain and returns the new balances.
 6. Both Alice and Bob successfully receive the updated balances.
 ## Migration Plans
 Bank is a widely used module, so getting a v2 needs to be thought thoroughly. In order to not force all dependencies to immediately migrate to bank/v2, the same _upgrading_ path will be taken as for the `gov` module.
 This means `cosmossdk.io/bank` will stay one module and there won't be a new `cosmossdk.io/bank/v2` go module. Instead the bank protos will be versioned from `v1beta1` (current bank) to `v2`.
 Bank `v1beta1` endpoints will use the new bank v2 implementation for maximum backward compatibility.
 The bank `v1beta1` keepers will be deprecated and potentially eventually removed, but its proto and messages definitions will remain.
 Additionally, as bank plans to integrate token factory, migrations functions will be provided to migrate from Osmosis token factory implementation (most widely used implementation) to the new bank/v2 token factory.
 ## Consequences
 ### Positive
 - Simplified interaction with bank APIs
 - Backward compatible changes (no contracts or apis broken)
 - Optional migration (note: bank `v1beta1` won't get any new feature after bank `v2` release)
 ### Neutral
 - Asset implementation not available cross-chain (IBC-ed custom asset should possibly fallback to the default implementation)
 - Many assets may slow down bank balances requests
 ### Negative
 - Temporarily duplicate functionalities as bank `v1beta1` are `v2` are living alongside
 - Difficultity to ever completely remove bank `v1beta1`
 ### References
 - Current bank module implementation: https://github.com/cosmos/cosmos-sdk/blob/v0.50.6/x/bank/keeper/keeper.go#L22-L53
 - Osmosis token factory: https://github.com/osmosis-labs/osmosis/tree/v25.0.0/x/tokenfactory/keeper
@@ -1,685 +0,0 @@
 # Cosmos SDK Core Components
 ## Overview
 The Cosmos SDK is a framework for building secure blockchain applications on CometBFT. It provides:
 - ABCI implementation in Go
 - Multi-store persistence layer  
 - Transaction routing system
 ## Transaction Flow
 1. CometBFT consensus delivers transaction bytes
 2. SDK decodes transactions and extracts messages
 3. Messages routed to appropriate modules
 4. State changes committed to stores
 ```mermaid
 graph TD
    A[CometBFT] -->|Tx Bytes| B[SDK Decode]
    B -->|Messages| C[Module Router] 
    C -->|State Changes| D[Multi-store]
 ```
 ## `baseapp`
 `baseapp` is the boilerplate implementation of a Cosmos SDK application. It comes with an implementation of the ABCI to handle the connection with the underlying consensus engine. Typically, a Cosmos SDK application extends `baseapp` by embedding it in [`app.go`](../beginner/00-app-anatomy.md#core-application-file).
 Here is an example of this from `simapp`, the Cosmos SDK demonstration app:
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/v0.52.0-beta.1/simapp/app.go#L145-L186
 ```
 The goal of `baseapp` is to provide a secure interface between the store and the extensible state machine while defining as little about the state machine as possible (staying true to the ABCI).
 For more on `baseapp`, please click [here](../advanced/00-baseapp.md).
 ## Multistore
 The Cosmos SDK provides a [`multistore`](../advanced/04-store.md#multistore) for persisting state. The multistore allows developers to declare any number of [`KVStores`](../advanced/04-store.md#base-layer-kvstores). These `KVStores` only accept the `[]byte` type as value and therefore any custom structure needs to be marshalled using [a codec](../advanced/05-encoding.md) before being stored.
 The multistore abstraction is used to divide the state in distinct compartments, each managed by its own module. For more on the multistore, click [here](../advanced/04-store.md#multistore).
 ## Modules
 The power of the Cosmos SDK lies in its modularity. Cosmos SDK applications are built by aggregating a collection of interoperable modules. Each module defines a subset of the state and contains its own message/transaction processor, while the Cosmos SDK is responsible for routing each message to its respective module.
 Here is a simplified view of how a transaction is processed by the application of each full-node when it is received in a valid block:
 ```mermaid
 flowchart TD
    A[Transaction relayed from the full-node's CometBFT engine to the node's application via DeliverTx] --> B[APPLICATION]
    B -->|"Using baseapp's methods: Decode the Tx, extract and route the message(s)"| C[Message routed to the correct module to be processed]
    C --> D1[AUTH MODULE]
    C --> D2[BANK MODULE]
    C --> D3[STAKING MODULE]
    C --> D4[GOV MODULE]
    D1 -->|Handle message, Update state| E["Return result to CometBFT (0=Ok, 1=Err)"]
    D2 -->|Handle message, Update state| E["Return result to CometBFT (0=Ok, 1=Err)"]
    D3 -->|Handle message, Update state| E["Return result to CometBFT (0=Ok, 1=Err)"]
    D4 -->|Handle message, Update state| E["Return result to CometBFT (0=Ok, 1=Err)"]
 ```
 Each module can be seen as a little state-machine. Developers need to define the subset of the state handled by the module, as well as custom message types that modify the state (_Note:_ `messages` are extracted from `transactions` by `baseapp`). In general, each module declares its own `KVStore` in the `multistore` to persist the subset of the state it defines. Most developers will need to access other 3rd party modules when building their own modules. Given that the Cosmos SDK is an open framework, some of the modules may be malicious, which means there is a need for security principles to reason about inter-module interactions. These principles are based on [object-capabilities](../advanced/10-ocap.md). In practice, this means that instead of having each module keep an access control list for other modules, each module implements special objects called `keepers` that can be passed to other modules to grant a pre-defined set of capabilities.
 Cosmos SDK modules are defined in the `x/` folder of the Cosmos SDK. Some core modules include:
 - `x/auth`: Used to manage accounts and signatures.
 - `x/bank`: Used to enable tokens and token transfers.
 - `x/staking` + `x/slashing`: Used to build Proof-of-Stake blockchains.
 In addition to the already existing modules in `x/`, which anyone can use in their app, the Cosmos SDK lets you build your own custom modules. You can check an [example of that in the tutorial](https://tutorials.cosmos.network/).# Keepers
 :::note Synopsis
 `Keeper`s refer to a Cosmos SDK abstraction whose role is to manage access to the subset of the state defined by various modules. `Keeper`s are module-specific, i.e. the subset of state defined by a module can only be accessed by a `keeper` defined in said module. If a module needs to access the subset of state defined by another module, a reference to the second module's internal `keeper` needs to be passed to the first one. This is done in `app.go` during the instantiation of module keepers.
 :::
 :::note Pre-requisite Readings
 - [Introduction to Cosmos SDK Modules](./00-intro.md)
 :::
 ## Motivation
 The Cosmos SDK is a framework that makes it easy for developers to build complex decentralized applications from scratch, mainly by composing modules together. As the ecosystem of open-source modules for the Cosmos SDK expands, it will become increasingly likely that some of these modules contain vulnerabilities, as a result of the negligence or malice of their developer.
 The Cosmos SDK adopts an [object-capabilities-based approach](https://docs.cosmos.network/main/learn/advanced/ocap#ocaps-in-practice) to help developers better protect their application from unwanted inter-module interactions, and `keeper`s are at the core of this approach. A `keeper` can be considered quite literally to be the gatekeeper of a module's store(s). Each store (typically an [`IAVL` Store](../../learn/advanced/04-store.md#iavl-store)) defined within a module comes with a `storeKey`, which grants unlimited access to it. The module's `keeper` holds this `storeKey` (which should otherwise remain unexposed), and defines [methods](#implementing-methods) for reading and writing to the store(s).
 The core idea behind the object-capabilities approach is to only reveal what is necessary to get the work done. In practice, this means that instead of handling permissions of modules through access-control lists, module `keeper`s are passed a reference to the specific instance of the other modules' `keeper`s that they need to access (this is done in the [application's constructor function](../../learn/beginner/00-app-anatomy.md#constructor-function)). As a consequence, a module can only interact with the subset of state defined in another module via the methods exposed by the instance of the other module's `keeper`. This is a great way for developers to control the interactions that their own module can have with modules developed by external developers.
 ## Type Definition
 `keeper`s are generally implemented in a `/keeper/keeper.go` file located in the module's folder. By convention, the type `keeper` of a module is simply named `Keeper` and usually follows the following structure:
 ```go
 type Keeper struct {
    // External keepers, if any
    // Store key(s)
    // codec
    // authority
 }
 ```
 For example, here is the type definition of the `keeper` from the `staking` module:
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/v0.52.0-beta.1/x/staking/keeper/keeper.go#L54-L115
 ```
 Let us go through the different parameters:
 - An expected `keeper` is a `keeper` external to a module that is required by the internal `keeper` of said module. External `keeper`s are listed in the internal `keeper`'s type definition as interfaces. These interfaces are themselves defined in an `expected_keepers.go` file in the root of the module's folder. In this context, interfaces are used to reduce the number of dependencies, as well as to facilitate the maintenance of the module itself.
 - `KVStoreService`s grant access to the store(s) of the [multistore](../../learn/advanced/04-store.md) managed by the module. They should always remain unexposed to external modules.
 - `cdc` is the [codec](../../learn/advanced/05-encoding.md) used to marshal and unmarshal structs to/from `[]byte`. The `cdc` can be any of `codec.BinaryCodec`, `codec.JSONCodec` or `codec.Codec` based on your requirements. It can be either a proto or amino codec as long as they implement these interfaces.
 - The authority listed is a module account or user account that has the right to change module level parameters. Previously this was handled by the param module, which has been deprecated.
 Of course, it is possible to define different types of internal `keeper`s for the same module (e.g. a read-only `keeper`). Each type of `keeper` comes with its own constructor function, which is called from the [application's constructor function](../../learn/beginner/00-app-anatomy.md). This is where `keeper`s are instantiated, and where developers make sure to pass correct instances of modules' `keeper`s to other modules that require them.
 ## Implementing Methods
 `Keeper`s primarily expose methods for business logic, as validity checks should have already been performed by the [`Msg` server](./03-msg-services.md) when `keeper`s' methods are called.
 <!-- markdown-link-check-disable -->
 State management is recommended to be done via [Collections](../packages/collections)
 <!-- The above link is created via the script to generate docs  -->
 ## State Management
 In the Cosmos SDK, it is crucial to be methodical and selective when managing state within a module, as improper state management can lead to inefficiency, security risks, and scalability issues. Not all data belongs in the on-chain state; it's important to store only essential blockchain data that needs to be verified by consensus. Storing unnecessary information, especially client-side data, can bloat the state and slow down performance. Instead, developers should focus on using an off-chain database to handle supplementary data, extending the API as needed. This approach minimizes on-chain complexity, optimizes resource usage, and keeps the blockchain state lean and efficient, ensuring scalability and smooth operations.
 The Cosmos SDK leverages Protocol Buffers (protobuf) for efficient state management, providing a well-structured, binary encoding format that ensures compatibility and performance across different modules. The SDK’s recommended approach for managing state is through the [collections package](../pacakges/02-collections.md), which simplifies state handling by offering predefined data structures like maps and indexed sets, reducing the complexity of managing raw state data. While users can opt for custom encoding schemes if they need more flexibility or have specialized requirements, they should be aware that such custom implementations may not integrate seamlessly with indexers that decode state data on the fly. This could lead to challenges in data retrieval, querying, and interoperability, making protobuf a safer and more future-proof choice for most use cases.
 # Folder Structure
 :::note Synopsis
 This document outlines the structure of Cosmos SDK modules. These ideas are meant to be applied as suggestions. Application developers are encouraged to improve upon and contribute to module structure and development design.
 The required interface for a module is located in the module.go. Everything beyond this is suggestive.
 :::
 ## Structure
 A typical Cosmos SDK module can be structured as follows:
 ```shell
 proto
 └── {project_name}
    └── {module_name}
        └── {proto_version}
            ├── {module_name}.proto
            ├── genesis.proto
            ├── query.proto
            └── tx.proto
 ```
 - `{module_name}.proto`: The module's common message type definitions.
 - `genesis.proto`: The module's message type definitions related to genesis state.
 - `query.proto`: The module's Query service and related message type definitions.
 - `tx.proto`: The module's Msg service and related message type definitions.
 ```shell
 x/{module_name}
 ├── client
 │   ├── cli
 │   │   ├── query.go
 │   │   └── tx.go
 │   └── testutil
 │       ├── cli_test.go
 │       └── suite.go
 ├── exported
 │   └── exported.go
 ├── keeper
 │   ├── genesis.go
 │   ├── grpc_query.go
 │   ├── hooks.go
 │   ├── invariants.go
 │   ├── keeper.go
 │   ├── keys.go
 │   ├── msg_server.go
 │   └── querier.go
 ├── simulation
 │   ├── decoder.go
 │   ├── genesis.go
 │   ├── operations.go
 │   └── params.go
 ├── types
 │   ├── {module_name}.pb.go
 │   ├── codec.go
 │   ├── errors.go
 │   ├── events.go
 │   ├── events.pb.go
 │   ├── expected_keepers.go
 │   ├── genesis.go
 │   ├── genesis.pb.go
 │   ├── keys.go
 │   ├── msgs.go
 │   ├── params.go
 │   ├── query.pb.go
 │   └── tx.pb.go
 ├── module.go
 ├── abci.go
 ├── autocli.go
 ├── depinject.go
 └── README.md
 ```
 - `client/`: The module's CLI client functionality implementation and the module's CLI testing suite.
 - `exported/`: The module's exported types - typically interface types. If a module relies on keepers from another module, it is expected to receive the keepers as interface contracts through the `expected_keepers.go` file (see below) in order to avoid a direct dependency on the module implementing the keepers. However, these interface contracts can define methods that operate on and/or return types that are specific to the module that is implementing the keepers and this is where `exported/` comes into play. The interface types that are defined in `exported/` use canonical types, allowing for the module to receive the keepers as interface contracts through the `expected_keepers.go` file. This pattern allows for code to remain DRY and also alleviates import cycle chaos.
 - `keeper/`: The module's `Keeper` and `MsgServer` implementation.
  - `abci.go`: The module's `BeginBlocker` and `EndBlocker` implementations (this file is only required if `BeginBlocker` and/or `EndBlocker` need to be defined).
 - `simulation/`: The module's [simulation](./14-simulator.md) package defines functions used by the blockchain simulator application (`simapp`).
 - `README.md`: The module's specification documents outlining important concepts, state storage structure, and message and event type definitions. Learn more how to write module specs in the [spec guidelines](../spec/SPEC_MODULE.md).
 - `types/`: includes type definitions for messages, events, and genesis state, including the type definitions generated by Protocol Buffers.
  - `codec.go`: The module's registry methods for interface types.
  - `errors.go`: The module's sentinel errors.
  - `events.go`: The module's event types and constructors.
  - `expected_keepers.go`: The module's [expected keeper](./06-keeper.md#type-definition) interfaces.
  - `genesis.go`: The module's genesis state methods and helper functions.
  - `keys.go`: The module's store keys and associated helper functions.
  - `msgs.go`: The module's message type definitions and associated methods.
  - `params.go`: The module's parameter type definitions and associated methods.
  - `*.pb.go`: The module's type definitions generated by Protocol Buffers (as defined in the respective `*.proto` files above).
 - The root directory includes the module's `AppModule` implementation.
  - `autocli.go`: The module [autocli](https://docs.cosmos.network/main/core/autocli) options.
  - `depinject.go`: The module [depinject](./15-depinject.md#type-definition) options.
 > Note: although the above pattern is followed by most of the Cosmos SDK modules, there are some modules that don't follow this pattern. E.g `x/group` and `x/nft` dont have a `types` folder, instead all of the type definitions for messages, events, and genesis state are live in the root directory and the module's `AppModule` implementation lives in the `module` folder.
 ---
 ## sidebar_position: 1
 # `Msg` Services
 :::note Synopsis
 A Protobuf `Msg` service processes [messages](./02-messages-and-queries.md#messages). Protobuf `Msg` services are specific to the module in which they are defined, and only process messages defined within the said module. They are called from `BaseApp` during [`FinalizeBlock`](../../learn/advanced/00-baseapp.md#finalizeblock).
 :::
 :::note Pre-requisite Readings
 - [Module Manager](./01-module-manager.md)
 - [Messages and Queries](./02-messages-and-queries.md)
 :::
 ## Implementation of a module `Msg` service
 Each module should define a Protobuf `Msg` service, which will be responsible for processing requests (implementing `sdk.Msg`) and returning responses.
 As further described in [ADR 031](../architecture/adr-031-msg-service.md), this approach has the advantage of clearly specifying return types and generating server and client code.
 Protobuf generates a `MsgServer` interface based on the definition of `Msg` service. It is the role of the module developer to implement this interface, by implementing the state transition logic that should happen upon receival of each `transaction.Msg`. As an example, here is the generated `MsgServer` interface for `x/bank`, which exposes two `transaction.Msg`s:
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/28fa3b8/x/bank/types/tx.pb.go#L564-L579
 ```
 When possible, the existing module's [`Keeper`](./06-keeper.md) should implement `MsgServer`, otherwise a `msgServer` struct that embeds the `Keeper` can be created, typically in `./keeper/msg_server.go`:
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/28fa3b8/x/bank/keeper/msg_server.go#L16-L19
 ```
 `msgServer` methods can retrieve the auxiliary information or services using the environment variable, it is always located in the keeper:
 Environment:
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/07151304e2ec6a185243d083f59a2d543253cb15/core/appmodule/v2/environment.go#L14-L29
 ```
 Keeper Example:
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/07151304e2ec6a185243d083f59a2d543253cb15/x/bank/keeper/keeper.go#L56-L58
 ```
 `transaction.Msg` processing usually follows these 3 steps:
 ### Validation
 The message server must perform all validation required (both _stateful_ and _stateless_) to make sure the `message` is valid.
 The `signer` is charged for the gas cost of this validation.
 For example, a `msgServer` method for a `transfer` message should check that the sending account has enough funds to actually perform the transfer.
 It is recommended to implement all validation checks in a separate function that passes state values as arguments. This implementation simplifies testing. As expected, expensive validation functions charge additional gas. Example:
 ```go
 ValidateMsgA(msg MsgA, now Time, gm GasMeter) error {
 	if now.Before(msg.Expire) {
 		return sdkerrors.ErrInvalidRequest.Wrap("msg expired")
 	}
 	gm.ConsumeGas(1000, "signature verification")
 	return signatureVerificaton(msg.Prover, msg.Data)
 }
 ```
 :::warning
 Previously, the `ValidateBasic` method was used to perform simple and stateless validation checks.
 This way of validating is deprecated, this means the `msgServer` must perform all validation checks.
 :::
 ### State Transition
 After the validation is successful, the `msgServer` method uses the [`keeper`](./06-keeper.md) functions to access the state and perform a state transition.
 ### Events
 Before returning, `msgServer` methods generally emit one or more [events](../../learn/advanced/08-events.md) by using the `EventManager` held in `environment`.
 There are two ways to emit events, typed events using protobuf or arbitrary key & values.
 Typed Events:
 ```go
 ctx.EventManager().EmitTypedEvent(
 	&group.EventABC{Key1: Value1,  Key2, Value2})
 ```
 Arbitrary Events:
 ```go
 ctx.EventManager().EmitEvent(
 	sdk.NewEvent(
 		eventType,  // e.g. sdk.EventTypeMessage for a message, types.CustomEventType for a custom event defined in the module
 		sdk.NewAttribute(key1, value1),
 		sdk.NewAttribute(key2, value2),
 	),
 )
 ```
 These events are relayed back to the underlying consensus engine and can be used by service providers to implement services around the application. Click [here](../../learn/advanced/08-events.md) to learn more about events.
 The invoked `msgServer` method returns a `proto.Message` response and an `error`. These return values are then wrapped into an `*sdk.Result` or an `error`:
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-alpha.0/baseapp/msg_service_router.go#L160
 ```
 This method takes care of marshaling the `res` parameter to protobuf and attaching any events on the `EventManager()` to the `sdk.Result`.
 ```protobuf reference
 https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-alpha.0/proto/cosmos/base/abci/v1beta1/abci.proto#L93-L113
 ```
 This diagram shows a typical structure of a Protobuf `Msg` service, and how the message propagates through the module.
 ```mermaid
 sequenceDiagram
    participant User
    participant baseApp
    participant router
    participant handler
    participant msgServer
    participant keeper
    participant EventManager
    User->>baseApp: Transaction Type<Tx>
    baseApp->>router: Route(ctx, msgRoute)
    router->>handler: handler
    handler->>msgServer: Msg<Tx>(Context, Msg(..))
    alt addresses invalid, denominations wrong, etc.
        msgServer->>handler: error
        handler->>router: error
        router->>baseApp: result, error code
    else
        msgServer->>keeper: perform action, update context
        keeper->>msgServer: results, error code
        msgServer->>EventManager: Emit relevant events
        msgServer->>msgServer: maybe wrap results in more structure
        msgServer->>handler: result, error code
        handler->>router: result, error code
        router->>baseApp: result, error code
    end
    baseApp->>User: result, error code
 ```
 ## Telemetry
 New [telemetry metrics](../../learn/advanced/09-telemetry.md) can be created from `msgServer` methods when handling messages.
 This is an example from the `x/auth/vesting` module:
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-alpha.0/x/auth/vesting/msg_server.go#L76-L88
 ```
 :::Warning
 Telemetry adds a performance overhead to the chain. It is recommended to only use this in critical paths
 :::
 ---
 ## sidebar_position: 1
 # Query Services
 :::note Synopsis
 A Protobuf Query service processes [`queries`](./02-messages-and-queries.md#queries). Query services are specific to the module in which they are defined, and only process `queries` defined within said module. They are called from `BaseApp`'s [`Query` method](../../learn/advanced/00-baseapp.md#query).
 :::
 :::note Pre-requisite Readings
 - [Module Manager](./01-module-manager.md)
 - [Messages and Queries](./02-messages-and-queries.md)
 :::
 ## Implementation of a module query service
 ### gRPC Service
 When defining a Protobuf `Query` service, a `QueryServer` interface is generated for each module with all the service methods:
 ```go
 type QueryServer interface {
 	QueryBalance(context.Context, *QueryBalanceParams) (*types.Coin, error)
 	QueryAllBalances(context.Context, *QueryAllBalancesParams) (*QueryAllBalancesResponse, error)
 }
 ```
 These custom queries methods should be implemented by a module's keeper, typically in `./keeper/grpc_query.go`. The first parameter of these methods is a generic `context.Context`. Therefore, the Cosmos SDK provides a function `sdk.UnwrapSDKContext` to retrieve the `context.Context` from the provided
 `context.Context`.
 Here's an example implementation for the bank module:
 ```go reference
 https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-alpha.0/x/bank/keeper/grpc_query.go
 ```
 ### Calling queries from the State Machine
 The Cosmos SDK v0.47 introduces a new `cosmos.query.v1.module_query_safe` Protobuf annotation which is used to state that a query that is safe to be called from within the state machine, for example:
 - a Keeper's query function can be called from another module's Keeper,
 - ADR-033 intermodule query calls,
 - CosmWasm contracts can also directly interact with these queries.
 If the `module_query_safe` annotation set to `true`, it means:
 - The query is deterministic: given a block height it will return the same response upon multiple calls, and doesn't introduce any state-machine breaking changes across SDK patch versions.
 - Gas consumption never fluctuates across calls and across patch versions.
 If you are a module developer and want to use `module_query_safe` annotation for your own query, you have to ensure the following things:
 - the query is deterministic and won't introduce state-machine-breaking changes without coordinated upgrades
 - it has its gas tracked, to avoid the attack vector where no gas is accounted for
  on potentially high-computation queries.
  ***
  sidebar_position: 1
 ---
 # Blockchain Architecture
 ## Introduction
 Blockchain architecture is a complex topic that involves many different components. In this section, we will cover the main layers of a blockchain application built with the Cosmos SDK.
 At its core, a blockchain is a replicated deterministic state machine. This document explores the various layers of blockchain architecture, focusing on the execution, settlement, consensus, data availability, and interoperability layers.
 ```mermaid
 graph TD
    A[Modular SDK Blockchain Architecture]
    A --> B[Execution Layer]
    A --> C[Settlement Layer]
    A --> D[Consensus Layer]
    D --> E[Data Availability Layer]
    A --> F[Interoperability Layer]
 ```
 ## Layered Architecture
 Understanding blockchain architecture through the lens of different layers helps in comprehending its complex functionalities. We will give a high-level overview of the execution layer, settlement layer, consensus layer, data availability layer, and interoperability layer.
 ## Execution Layer
 The Execution Layer is where the blockchain processes and executes transactions. The state machine within the blockchain handles the execution of transaction logic. This is done by the blockchain itself, ensuring that every transaction follows the predefined rules and state transitions. When a transaction is submitted, the execution layer processes it, updates the state, and ensures that the output is deterministic and consistent across all nodes. In the context of the Cosmos SDK, this typically involves predefined modules and transaction types rather than general-purpose smart contracts, which are used in chains with CosmWasm.
 ### State machine
 At its core, a blockchain is a [replicated deterministic state machine](https://en.wikipedia.org/wiki/State_machine_replication).
 A state machine is a computer science concept whereby a machine can have multiple states, but only one at any given time. There is a `state`, which describes the current state of the system, and `transactions`, that trigger state transitions.
 Given a state S and a transaction T, the state machine will return a new state S'.
 ```mermaid
 flowchart LR
    A[S]
    B[S']
    A -->|"apply(T)"| B
 ```
 In practice, the transactions are bundled in blocks to make the process more efficient. Given a state S and a block of transactions B, the state machine will return a new state S'.
 ```mermaid
 flowchart LR
    A[S]
    B[S']
    A -->|"For each T in B: apply(T)"| B
 ```
 In a blockchain context, the state machine is [deterministic](https://en.wikipedia.org/wiki/Deterministic_system). This means that if a node is started at a given state and replays the same sequence of transactions, it will always end up with the same final state.
 The Cosmos SDK gives developers maximum flexibility to define the state of their application, transaction types and state transition functions. The process of building state machines with the Cosmos SDK will be described more in-depth in the following sections. But first, let us see how the state machine is replicated using various consensus engines, such as CometBFT.
 ## Settlement Layer
 The Settlement Layer is responsible for finalising and recording transactions on the blockchain. This layer ensures that all transactions are accurately settled and immutable, providing a verifiable record of all activities on the blockchain. It is critical for maintaining the integrity and trustworthiness of the blockchain.
 The settlement layer can be performed on the chain itself or it can be externalised, allowing for the possibility of plugging in a different settlement layer as needed. For example if we were to use Rollkit and celestia for our Data Availability and Consensus, we could separate our settlement layer by introducing fraud or validity proofs. From there the settlement layer can create trust-minimised light clients, further enhancing security and efficiency. This process ensures that all transactions are accurately finalized and immutable, providing a verifiable record of all activities.
 ## Consensus Layer
 The Consensus Layer ensures that all nodes in the network agree on the order and validity of transactions. This layer uses consensus algorithms like Byzantine Fault Tolerance (BFT) or Proof of Stake (PoS) to achieve agreement, even in the presence of malicious nodes. Consensus is crucial for maintaining the security and reliability of the blockchain.
 What has been a default consensus engine in the Cosmos SDK has been CometBFT. In the most recent releases we have been moving away from this and allowing users to plug and play their own consensus engines. This is a big step forward for the Cosmos SDK as it allows for more flexibility and customisation. Other consensus engine options for example can be Rollkit with Celestias Data Availability Layer.
 Here is an example of how the consensus layer works with CometBFT in the context of the Cosmos SDK:
 ### CometBFT
 Thanks to the Cosmos SDK, developers just have to define the state machine, and [_CometBFT_](https://docs.cometbft.com/v1.0/explanation/introduction/) will handle replication over the network for them.
 ```mermaid
 flowchart TD
    subgraph Blockchain_Node[Blockchain Node]
        subgraph SM[State-machine]
            direction TB
            SM1[Cosmos SDK]
        end
        subgraph CometBFT[CometBFT]
            direction TB
            Consensus
            Networking
        end
    end
    SM <--> CometBFT
    Blockchain_Node -->|Includes| SM
    Blockchain_Node -->|Includes| CometBFT
 ```
 [CometBFT](https://docs.cometbft.com/v1.0/explanation/introduction/) is an application-agnostic engine that is responsible for handling the _networking_ and _consensus_ layers of a blockchain. In practice, this means that CometBFT is responsible for propagating and ordering transaction bytes. CometBFT relies on an eponymous Byzantine-Fault-Tolerant (BFT) algorithm to reach consensus on the order of transactions.
 The [consensus algorithm adopted by CometBFT](https://docs.cometbft.com/v1.0/explanation/introduction/#consensus-overview) works with a set of special nodes called _Validators_. Validators are responsible for adding blocks of transactions to the blockchain. At any given block, there is a validator set V. A validator in V is chosen by the algorithm to be the proposer of the next block. This block is considered valid if more than two thirds of V signed a `prevote` and a `precommit` on it, and if all the transactions that it contains are valid. The validator set can be changed by rules written in the state-machine.
 ## ABCI
 CometBFT passes transactions to the application through an interface called the [ABCI](https://docs.cometbft.com/v1.0/spec/abci/), which the application must implement.
 ```mermaid
 graph TD
    A[Application]
    B[CometBFT]
    A <-->|ABCI| B
 ```
 Note that **CometBFT only handles transaction bytes**. It has no knowledge of what these bytes mean. All CometBFT does is order these transaction bytes deterministically. CometBFT passes the bytes to the application via the ABCI, and expects a return code to inform it if the messages contained in the transactions were successfully processed or not.
 Here are the most important messages of the ABCI:
 - `CheckTx`: When a transaction is received by CometBFT, it is passed to the application to check if a few basic requirements are met. `CheckTx` is used to protect the mempool of full-nodes against spam transactions. A special handler called the [`AnteHandler`](../beginner/04-gas-fees.md#antehandler) is used to execute a series of validation steps such as checking for sufficient fees and validating the signatures. If the checks are valid, the transaction is added to the [mempool](https://docs.cometbft.com/v1.0/explanation/core/mempool) and relayed to peer nodes. Note that transactions are not processed (i.e. no modification of the state occurs) with `CheckTx` since they have not been included in a block yet.
 - `DeliverTx`: When a [valid block](https://docs.cometbft.com/v1.0/spec/core/data_structures#block) is received by CometBFT, each transaction in the block is passed to the application via `DeliverTx` in order to be processed. It is during this stage that the state transitions occur. The `AnteHandler` executes again, along with the actual [`Msg` service](../../build/building-modules/03-msg-services.md) RPC for each message in the transaction.
 - `BeginBlock`/`EndBlock`: These messages are executed at the beginning and the end of each block, whether the block contains transactions or not. It is useful to trigger automatic execution of logic. Proceed with caution though, as computationally expensive loops could slow down your blockchain, or even freeze it if the loop is infinite.
 Find a more detailed view of the ABCI methods from the [CometBFT docs](https://docs.cometbft.com/v1.0/spec/abci/).
 Any application built on CometBFT needs to implement the ABCI interface in order to communicate with the underlying local CometBFT engine. Fortunately, you do not have to implement the ABCI interface. The Cosmos SDK provides a boilerplate implementation of it in the form of [baseapp](./03-sdk-design.md#baseapp).
 ## Data Availability Layer
 The Data Availability (DA) Layer is a critical component of within the umbrella of the consensus layer that ensures all necessary data for transactions is available to all network participants. This layer is essential for preventing data withholding attacks, where some nodes might attempt to disrupt the network by not sharing critical transaction data.
 If we use the example of Rollkit, a user initiates a transaction, which is then propagated through the rollup network by a light node. The transaction is validated by full nodes and aggregated into a block by the sequencer. This block is posted to a data availability layer like Celestia, ensuring the data is accessible and correctly ordered. The rollup light node verifies data availability from the DA layer. Full nodes then validate the block and generate necessary proofs, such as fraud proofs for optimistic rollups or zk-SNARKs/zk-STARKs for zk-rollups. These proofs are shared across the network and verified by other nodes, ensuring the rollup's integrity. Once all validations are complete, the rollup's state is updated, finalising the transaction
 ## Interoperability Layer
 The Interoperability Layer enables communication and interaction between different blockchains. This layer facilitates cross-chain transactions and data sharing, allowing various blockchain networks to interoperate seamlessly. Interoperability is key for building a connected ecosystem of blockchains, enhancing their functionality and reach.
 In this case we have separated the layers even further to really illustrate the components that make-up the blockchain architecture and it is important to note that the Cosmos SDK is designed to be interoperable with other blockchains. This is achieved through the use of the [Inter-Blockchain Communication (IBC) protocol](https://www.ibcprotocol.dev/), which allows different blockchains to communicate and transfer assets between each other.
 ---
 ## sidebar_position: 1
 # Application-Specific Blockchains
 :::note Synopsis
 This document explains what application-specific blockchains are, and why developers would want to build one as opposed to writing Smart Contracts.
 :::
 ## What are application-specific blockchains
 Application-specific blockchains are blockchains customized to operate a single application. Instead of building a decentralized application on top of an underlying blockchain like Ethereum, developers build their own blockchain from the ground up. This means building a full-node client, a light-client, and all the necessary interfaces (CLI, REST, ...) to interact with the nodes.
 ```mermaid
 flowchart TD
    subgraph Blockchain_Node[Blockchain Node]
        subgraph SM[State-machine]
            direction TB
            SM1[Cosmos SDK]
        end
        subgraph Consensus[Consensus]
            direction TB
        end
        subgraph Networking[Networking]
            direction TB
        end
    end
    SM <--> Consensus
    Consensus <--> Networking
    Blockchain_Node -->|Includes| SM
    Blockchain_Node -->|Includes| Consensus
    Blockchain_Node -->|Includes| Networking
 ```
 ## What are the shortcomings of Smart Contracts
 Virtual-machine blockchains like Ethereum addressed the demand for more programmability back in 2014. At the time, the options available for building decentralized applications were quite limited. Most developers would build on top of the complex and limited Bitcoin scripting language, or fork the Bitcoin codebase which was hard to work with and customize.
 Virtual-machine blockchains came in with a new value proposition. Their state-machine incorporates a virtual-machine that is able to interpret turing-complete programs called Smart Contracts. These Smart Contracts are very good for use cases like one-time events (e.g. ICOs), but they can fall short for building complex decentralized platforms. Here is why:
 - Smart Contracts are generally developed with specific programming languages that can be interpreted by the underlying virtual-machine. These programming languages are often immature and inherently limited by the constraints of the virtual-machine itself. For example, the Ethereum Virtual Machine does not allow developers to implement automatic execution of code. Developers are also limited to the account-based system of the EVM, and they can only choose from a limited set of functions for their cryptographic operations. These are examples, but they hint at the lack of **flexibility** that a smart contract environment often entails.
 - Smart Contracts are all run by the same virtual machine. This means that they compete for resources, which can severely restrain **performance**. And even if the state-machine were to be split in multiple subsets (e.g. via sharding), Smart Contracts would still need to be interpreted by a virtual machine, which would limit performance compared to a native application implemented at state-machine level (our benchmarks show an improvement on the order of 10x in performance when the virtual-machine is removed).
 - Another issue with the fact that Smart Contracts share the same underlying environment is the resulting limitation in **sovereignty**. A decentralized application is an ecosystem that involves multiple players. If the application is built on a general-purpose virtual-machine blockchain, stakeholders have very limited sovereignty over their application, and are ultimately superseded by the governance of the underlying blockchain. If there is a bug in the application, very little can be done about it.
 Application-Specific Blockchains are designed to address these shortcomings.
 ## Application-Specific Blockchains Benefits
 ### Flexibility
 Application-specific blockchains give maximum flexibility to developers:
 - In Cosmos blockchains, the state-machine is typically connected to the underlying consensus engine via an interface called the [ABCI](https://docs.cometbft.com/v1.0/spec/abci/) (Application Blockchain Interface). This interface can be wrapped in any programming language, meaning developers can build their state-machine in the programming language of their choice.
 - Developers can choose among multiple frameworks to build their state-machine. The most widely used today is the Cosmos SDK, but others exist (e.g. [Lotion](https://github.com/nomic-io/lotion), [Weave](https://github.com/iov-one/weave), ...). Typically the choice will be made based on the programming language they want to use (Cosmos SDK and Weave are in Golang, Lotion is in Javascript, ...).
 - The ABCI also allows developers to swap the consensus engine of their application-specific blockchain. Today, only CometBFT is production-ready, but in the future other consensus engines are expected to emerge.
 - Even when they settle for a framework and consensus engine, developers still have the freedom to tweak them if they don't perfectly match their requirements in their pristine forms.
 - Developers are free to explore the full spectrum of tradeoffs (e.g. number of validators vs transaction throughput, safety vs availability in asynchrony, ...) and design choices (DB or IAVL tree for storage, UTXO or account model, ...).
 - Developers can implement automatic execution of code. In the Cosmos SDK, logic can be automatically triggered at the beginning and the end of each block. They are also free to choose the cryptographic library used in their application, as opposed to being constrained by what is made available by the underlying environment in the case of virtual-machine blockchains.
 The list above contains a few examples that show how much flexibility application-specific blockchains give to developers. The goal of Cosmos and the Cosmos SDK is to make developer tooling as generic and composable as possible, so that each part of the stack can be forked, tweaked and improved without losing compatibility. As the community grows, more alternatives for each of the core building blocks will emerge, giving more options to developers.
 ### Performance
 Decentralized applications built with Smart Contracts are inherently capped in performance by the underlying environment. For a decentralized application to optimise performance, it needs to be built as an application-specific blockchain. Next are some of the benefits an application-specific blockchain brings in terms of performance:
 - Developers of application-specific blockchains can choose to operate with a novel consensus engine such as CometBFT.
 - An application-specific blockchain only operates a single application, so that the application does not compete with others for computation and storage. This is the opposite of most non-sharded virtual-machine blockchains today, where smart contracts all compete for computation and storage.
 - Even if a virtual-machine blockchain offered application-based sharding coupled with an efficient consensus algorithm, performance would still be limited by the virtual-machine itself. The real throughput bottleneck is the state-machine, and requiring transactions to be interpreted by a virtual-machine significantly increases the computational complexity of processing them.
 ### Security
 Security is hard to quantify, and greatly varies from platform to platform. That said here are some important benefits an application-specific blockchain can bring in terms of security:
 - Developers can choose proven programming languages like Go when building their application-specific blockchains, as opposed to smart contract programming languages that are often more immature.
 - Developers are not constrained by the cryptographic functions made available by the underlying virtual-machines. They can use their own custom cryptography, and rely on well-audited crypto libraries.
 - Developers do not have to worry about potential bugs or exploitable mechanisms in the underlying virtual-machine, making it easier to reason about the security of the application.
 ### Sovereignty
 One of the major benefits of application-specific blockchains is sovereignty. A decentralized application is an ecosystem that involves many actors: users, developers, third-party services, and more. When developers build on virtual-machine blockchain where many decentralized applications coexist, the community of the application is different than the community of the underlying blockchain, and the latter supersedes the former in the governance process. If there is a bug or if a new feature is needed, stakeholders of the application have very little leeway to upgrade the code. If the community of the underlying blockchain refuses to act, nothing can happen.
 The fundamental issue here is that the governance of the application and the governance of the network are not aligned. This issue is solved by application-specific blockchains. Because application-specific blockchains specialize to operate a single application, stakeholders of the application have full control over the entire chain. This ensures that the community will not be stuck if a bug is discovered, and that it has the freedom to choose how it is going to evolve.
@@ -1,141 +0,0 @@
 # `x/did`
 The Decentralized Identity module is responsible for managing native Sonr Accounts, their derived wallets, and associated user identification information.
 ## State
 The DID module maintains several key state structures:
 ### Controller State
 The Controller state represents a Sonr DWN Vault. It includes:
 - Unique identifier (number)
 - DID
 - Sonr address
 - Ethereum address
 - Bitcoin address
 - Public key
 - Keyshares pointer
 - Claimed block
 - Creation block
 ### Assertion State
 The Assertion state includes:
 - DID
 - Controller
 - Subject
 - Public key
 - Assertion type
 - Accumulator (metadata)
 - Creation block
 ### Authentication State
 The Authentication state includes:
 - DID
 - Controller
 - Subject
 - Public key
 - Credential ID
 - Metadata
 - Creation block
 ### Verification State
 The Verification state includes:
 - DID
 - Controller
 - DID method
 - Issuer
 - Subject
 - Public key
 - Verification type
 - Metadata
 - Creation block
 ## State Transitions
 State transitions are triggered by the following messages:
 - LinkAssertion
 - LinkAuthentication
 - UnlinkAssertion
 - UnlinkAuthentication
 - ExecuteTx
 - UpdateParams
 ## Messages
 The DID module defines the following messages:
 1. MsgLinkAuthentication
 2. MsgLinkAssertion
 3. MsgExecuteTx
 4. MsgUnlinkAssertion
 5. MsgUnlinkAuthentication
 6. MsgUpdateParams
 Each message triggers specific state machine behaviors related to managing DIDs, authentications, assertions, and module parameters.
 ## Query
 The DID module provides the following query endpoints:
 1. Params: Query all parameters of the module
 2. Resolve: Query the DID document by its ID
 3. Sign: Sign a message with the DID document
 4. Verify: Verify a message with the DID document
 ## Params
 The module parameters include:
 - Allowed public keys (map of KeyInfo)
 - Conveyance preference
 - Attestation formats
 ## Client
 The module provides gRPC and REST endpoints for all defined messages and queries.
 ## Future Improvements
 Potential future improvements could include:
 1. Enhanced privacy features for DID operations
 2. Integration with more blockchain networks
 3. Support for additional key types and cryptographic algorithms
 4. Improved revocation mechanisms for credentials and assertions
 ## Tests
 Acceptance tests should cover all major functionality, including:
 - Creating and managing DIDs
 - Linking and unlinking assertions and authentications
 - Executing transactions with DIDs
 - Querying and resolving DIDs
 - Parameter updates
 ## Appendix
 ### Account
 An Account represents a user's identity within the Sonr ecosystem. It includes information such as the user's public key, associated wallets, and other identification details.
 ### Decentralized Identifier (DID)
 A Decentralized Identifier (DID) is a unique identifier that is created, owned, and controlled by the user. It is used to establish a secure and verifiable digital identity.
 ### Verifiable Credential (VC)
 A Verifiable Credential (VC) is a digital statement that can be cryptographically verified. It contains claims about a subject (e.g., a user) and is issued by a trusted authority.
 ### Key Types
 The module supports various key types, including:
 - Role
 - Algorithm (e.g., ES256, EdDSA, ES256K)
 - Encoding (e.g., hex, base64, multibase)
 - Curve (e.g., P256, P384, P521, X25519, X448, Ed25519, Ed448, secp256k1)
 ### JSON Web Key (JWK)
 The module supports JSON Web Keys (JWK) for representing cryptographic keys, including properties such as key type (kty), curve (crv), and coordinates (x, y) for EC and OKP keys, as well as modulus (n) and exponent (e) for RSA keys.
@@ -1,145 +0,0 @@
 # `x/dwn`
 The DWN module is responsible for the management of IPFS deployed Decentralized Web Nodes (DWNs) and their associated data.
 ## Concepts
 The DWN module introduces several key concepts:
 1. Decentralized Web Node (DWN): A distributed network for storing and sharing data.
 2. Schema: A structure defining the format of various data types in the dwn.
 3. IPFS Integration: The module can interact with IPFS for decentralized data storage.
 ## State
 The DWN module maintains the following state:
 ### DWN State
 The DWN state is stored using the following structure:
 ```protobuf
 message DWN {
  uint64 id = 1;
  string alias = 2;
  string cid = 3;
  string resolver = 4;
 }
 ```
 This state is indexed by ID, alias, and CID for efficient querying.
 ### Params State
 The module parameters are stored in the following structure:
 ```protobuf
 message Params {
  bool ipfs_active = 1;
  bool local_registration_enabled = 2;
  Schema schema = 4;
 }
 ```
 ### Schema State
 The Schema state defines the structure for various data types:
 ```protobuf
 message Schema {
  int32 version = 1;
  string account = 2;
  string asset = 3;
  string chain = 4;
  string credential = 5;
  string did = 6;
  string jwk = 7;
  string grant = 8;
  string keyshare = 9;
  string profile = 10;
 }
 ```
 ## State Transitions
 State transitions in the DWN module are primarily triggered by:
 1. Updating module parameters
 2. Allocating new dwns
 3. Syncing DID documents
 ## Messages
 The DWN module defines the following message:
 1. `MsgUpdateParams`: Used to update the module parameters.
 ```protobuf
 message MsgUpdateParams {
  string authority = 1;
  Params params = 2;
 }
 ```
 ## Begin Block
 No specific begin-block operations are defined for this module.
 ## End Block
 No specific end-block operations are defined for this module.
 ## Hooks
 The DWN module does not define any hooks.
 ## Events
 The DWN module does not explicitly define any events. However, standard Cosmos SDK events may be emitted during state transitions.
 ## Client
 The DWN module provides the following gRPC query endpoints:
 1. `Params`: Queries all parameters of the module.
 2. `Schema`: Queries the DID document schema.
 3. `Allocate`: Initializes a Target DWN available for claims.
 4. `Sync`: Queries the DID document by its ID and returns required information.
 ## Params
 The module parameters include:
 - `ipfs_active` (bool): Indicates if IPFS integration is active.
 - `local_registration_enabled` (bool): Indicates if local registration is enabled.
 - `schema` (Schema): Defines the structure for various data types in the dwn.
 ## Future Improvements
 Potential future improvements could include:
 1. Enhanced IPFS integration features.
 2. Additional authentication mechanisms beyond WebAuthn.
 3. Improved DID document management and querying capabilities.
 ## Tests
 Acceptance tests should cover:
 1. Parameter updates
 2. DWN state management
 3. Schema queries
 4. DWN allocation process
 5. DID document syncing
 ## Appendix
 | Concept                                     | Description                                                                                                                                                                           |
 | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Decentralized Web Node (DWN)                | A decentralized, distributed, and secure network of nodes that store and share data. It is a decentralized alternative to traditional web hosting services.                           |
 | Decentralized Identifier (DID)              | A unique identifier that is created, owned, and controlled by the user. It is used to establish a secure and verifiable digital identity.                                             |
 | HTMX (Hypertext Markup Language eXtensions) | A set of extensions to HTML that allow for the creation of interactive web pages. It is used to enhance the user experience and provide additional functionality to web applications. |
 | IPFS (InterPlanetary File System)           | A decentralized, peer-to-peer network for storing and sharing data. It is a distributed file system that allows for the creation and sharing of content across a network of nodes.    |
 | WebAuthn (Web Authentication)               | A set of APIs that allow websites to request user authentication using biometric or non-biometric factors.                                                                            |
 | WebAssembly (Web Assembly)                  | A binary instruction format for a stack-based virtual machine.                                                                                                                        |
 | Verifiable Credential (VC)                  | A digital statement that can be cryptographically verified.                                                                                                                           |
@@ -1,91 +0,0 @@
 # `x/svc`
 The svc module is responsible for managing the registration and authorization of services within the Sonr ecosystem. It provides a secure and verifiable mechanism for registering and authorizing services using Decentralized Identifiers (DIDs).
 ## Concepts
 - **Service**: A decentralized svc on the Sonr Blockchain with properties such as ID, authority, origin, name, description, category, tags, and expiry height.
 - **Profile**: Represents a DID alias with properties like ID, subject, origin, and controller.
 - **Metadata**: Contains information about a svc, including name, description, category, icon, and tags.
 ### Dependencies
 - [x/did](https://github.com/onsonr/sonr/tree/master/x/did)
 - [x/group](https://github.com/onsonr/sonr/tree/master/x/group)
 - [x/nft](https://github.com/onsonr/sonr/tree/master/x/nft)
 ## State
 The module uses the following state structures:
 ### Metadata
 Stores information about services:
 - Primary key: `id` (auto-increment)
 - Unique index: `origin`
 - Fields: id, origin, name, description, category, icon (URI), tags
 ### Profile
 Stores DID alias information:
 - Primary key: `id`
 - Unique index: `subject,origin`
 - Fields: id, subject, origin, controller
 ## Messages
 ### MsgUpdateParams
 Updates the module parameters. Can only be executed by the governance account.
 ### MsgRegisterService
 Registers a new svc on the blockchain. Requires a valid TXT record in DNS for the origin.
 ## Params
 The module has the following parameters:
 - `categories`: List of allowed svc categories
 - `types`: List of allowed svc types
 ## Query
 The module provides the following query:
 ### Params
 Retrieves all parameters of the module.
 ## Client
 ### gRPC
 The module provides a gRPC Query svc with the following RPC:
 - `Params`: Get all parameters of the module
 ### CLI
 (TODO: Add CLI commands for interacting with the module)
 ## Events
 (TODO: List and describe event tags used by the module)
 ## Future Improvements
 - Implement svc discovery mechanisms
 - Add support for svc reputation and rating systems
 - Enhance svc metadata with more detailed information
 - Implement svc update and deactivation functionality
 ## Tests
 (TODO: Add acceptance tests for the module)
 ## Appendix
 This module is part of the Sonr blockchain project and interacts with other modules such as DID and NFT modules to provide a comprehensive decentralized svc ecosystem.
@@ -1,897 +0,0 @@
 # User Controlled Authorization Network (UCAN) Specification
 ## Version 1.0.0-rc.1
 ## Editors
 - [Brooklyn Zelenka], [Witchcraft Software]
 ## Authors
 - [Irakli Gozalishvili], [Protocol Labs]
 - [Daniel Holmgren], [Bluesky]
 - [Philipp Krüger], [number zero]
 - [Brooklyn Zelenka], [Witchcraft Software]
 ## Sub-Specifications
 - [UCAN Delegation][delegation]
 - [UCAN Invocation][invocation]
 - [UCAN Promise][promise]
 - [UCAN Revocation][revocation]
 ## Language
 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [BCP 14] when, and only when, they appear in all capitals, as shown here.
 # Abstract
 User-Controlled Authorization Network (UCAN) is a [trustless], secure, [local-first], user-originated, distributed authorization scheme. This document provides a high level overview of the components of the system, concepts, and motivation. Exact formats are given in [sub-specifications].
 # Introduction
 User-Controlled Authorization Network (UCAN) is a [trustless], secure, [local-first], user-originated, distributed authorization scheme. It provides public-key verifiable, delegable, expressive, openly extensible [capabilities]. UCANs achieve public verifiability with late-bound certificate chains and principals represented by [decentralized identifiers (DIDs)][DID].
 UCAN improves the familiarity and adoptability of schemes like [SPKI/SDSI][SPKI] for web and native application contexts. UCAN allows for the creation, delegation, and invocation of authority by any agent with a DID, including traditional systems and peer-to-peer architectures beyond traditional cloud computing.
 ## Motivation
 > If we practice our principles, we could have both security and functionality. Treating security as a separate concern has not succeeded in bridging the gap between principle and practice, because it operates without knowledge of what constitutes least authority.
 >
 > — [Miller][Mark Miller] et al, [The Structure of Authority]
 Since at least [Multics], access control lists ([ACL]s) have been the most popular form of digital authorization, where a list of what each user is allowed to do is maintained on the resource. ACLs (and later [RBAC]) have been a successful model suited to architectures where persistent access to a single list is viable. ACLs require that rules are sufficiently well specified, such as in a centralized database with rules covering all possible permutations of scenario. This both imposes a very high maintenance burden on programmers as a systems grows in complexity, and is a key vector for [confused deputies][confused deputy problem].
 With increasing interconnectivity between machines becoming commonplace, authorization needs to scale to meet the load demands of distributed systems while providing partition tolerance. However, it is not always practical to maintain a single central authorization source. Even when copies of the authorization list are distributed to the relevant servers, latency and partitions introduce troublesome challenges with conflicting updates, to say nothing of storage requirements.
 A large portion of personal information now also moves through connected systems. As a result, data privacy is a prominent theme when considering the design of modern applications, to the point of being legislated in parts of the world.
 Ahead-of-time coordination is often a barrier to development in many projects. Flexibility to define specialized authorization semantics for resources and the ability to integrate with external systems trustlessly are essential as the number of autonomous, specialized, and coordinated applications increases.
 Many high-value applications run in hostile environments. In recognition of this, many vendors now include public key functionality, such as [non-extractable keys in browsers][browser api crypto key], [certificate systems for external keys][fido], [platform keys][passkey], and [secure hardware enclaves] in widespread consumer devices.
 Two related models that work exceptionally well in the above context are Simple Public Key Infrastructure ([SPKI][spki rfc]) and object capabilities ([OCAP]). Since offline operation and self-verifiability are two requirements, UCAN adopts a [certificate capability model] related to [SPKI].
 ## Intuition for Auth System Differences
 The following analogies illustrate several significant trade-offs between these systems but are only accurate enough to build intuition. A good resource for a more thorough presentation of these trade-offs is [Capability Myths Demolished]. In this framework, UCAN approximates SPKI with some dynamic features.
 ### Access Control Lists
 By analogy, ACLs are like a bouncer at an exclusive event. This bouncer has a list attendees allowed in and which of those are VIPs that get extra access. People trying to get in show their government-issued ID and are accepted or rejected. In addition, they may get a lanyard to identify that they have previously been allowed in. If someone is disruptive, they can simply be crossed off the list and denied further entry.
 If there are many such events at many venues, the organizers need to coordinate ahead of time, denials need to be synchronized, and attendees need to show their ID cards to many bouncers. The likelihood of the bouncer letting in the wrong person due to synchronization lag or confusion by someone sharing a name is nonzero.
 ### Certificate Capabilities
 UCANs work more like [movie tickets][caps as keys] or a festival pass. No one needs to check your ID; who you are is irrelevant. For example, if you have a ticket issued by the theater to see Citizen Kane, you are admitted to Theater 3. If you cannot attend an event, you can hand this ticket to a friend who wants to see the film instead, and there is no coordination required with the theater ahead of time. However, if the theater needs to cancel tickets for some reason, they need a way of uniquely identifying them and sharing this information between them.
 ### Object Capabilities
 Object capability ("ocap") systems use a combination of references, encapsulated state, and proxy forwarding. As the name implies, this is fairly close to object-oriented or actor-based systems. Object capabilities are [robust][Robust Composition], flexible, and expressive.
 To achieve these properties, object capabilities have two requirements: [fail-safe], and locality preservation. The emphasis on consistency rules out partition tolerance[^pcec].
 ## Security Considerations
 Each UCAN includes an assertions of what it is allowed to do. "Proofs" are positive evidence (elsewhere called "witnesses") of the possession of rights. They are cryptographically verifiable chains showing that the UCAN issuer either claims to directly own a resource, or that it was delegated to them by some claimed owner. In the most common case, the root owner's ID is the only globally unique identity for the resource.
 Root capability issuers function as verifiable, distributed roots of trust. The delegation chain is by definition a provenance log. Private keys themselves SHOULD NOT move from one context to another. Keeping keys unique to each physical device and unique per use case is RECOMMENDED to reduce opportunity for keys to leak, and limit blast radius in the case of compromises. "Sharing authority without sharing keys" is provided by capabilities, so there is no reason to share keys directly.
 Note that a structurally and cryptographically valid UCAN chain can be semantically invalid. The executor MUST verify the ownership of any external resources at execution time. While not possible for all use cases (e.g. replicated state machines and eventually consistent data), having the Executor be the resource itself is RECOMMENDED.
 While certificate chains go a long way toward improving security, they do not provide [confinement] on their own. The principle of least authority SHOULD be used when delegating a UCAN: minimizing the amount of time that a UCAN is valid for and reducing authority to the bare minimum required for the delegate to complete their task. This delegate should be trusted as little as is practical since they can further sub-delegate their authority to others without alerting their delegator. UCANs do not offer confinement (as that would require all processes to be online), so it is impossible to guarantee knowledge of all of the sub-delegations that exist. The ability to revoke some or all downstream UCANs exists as a last resort.
 ## Inversion of Control
 [Inversion of control] is achieved due to two properties: self-certifying delegation and reference passing. There is no Authorization Server (AS) that sits between requestors and resources. In traditional terms, the owner of a UCAN resource is the resource server (RS) directly.
 This inverts the usual relationship between resources and users: the resource grants some (or all) authority over itself to agents, as opposed to an Authorization Server managing the relationship between them. This has several major advantages:
 - Fully distributed and scalable
 - Self-contained request without intermediary
 - Partition tolerance, [support for replicated data and machines][overcoming SSI]
 - Flexible granularity
 - Compositionality: no distinction between resources residing together or apart
 ```
 ┌─────────────┐   ┌─────────────┐   ┌─────────────┐
 │             │   │             │   │             │
 │             │   │ ┌─────────┐ │   │             │
 │             │   │ │  Bob's  │ │   │             │
 │             │   │ │  Photo  │ │   │             │
 │             │   │ │ Gallery │ │   │             │
 │             │   │ └─────────┘ │   │             │
 │             │   │             │   │             │
 │   Alice's   │   │    Bob's    │   │   Carol's   │
 │    Stuff    │   │    Stuff    │   │    Stuff    │
 │             │   │             │   │             │
 │     ┌───────┼───┼─────────────┼───┼──┐          │
 │     │       │   │             │   │  │          │
 │     │       │   │         ┌───┼───┼──┼────────┐ │
 │     │       │   │ Alice's │   │   │  │        │ │
 │     │       │   │  Music  │   │   │  │Carol's │ │
 │     │       │   │ Player  │   │   │  │  Game  │ │
 │     │       │   │         │   │   │  │        │ │
 │     │       │   │         └───┼───┼──┼────────┘ │
 │     │       │   │             │   │  │          │
 │     └───────┼───┼─────────────┼───┼──┘          │
 │             │   │             │   │             │
 └─────────────┘   └─────────────┘   └─────────────┘
 ```
 This additionally allows UCAN to model auth for [eventually consistent and replicated state][overcoming SSI].
 # Roles
 There are several roles that an agent MAY assume:
 | Name      | Description                                                                                      |
 | --------- | ------------------------------------------------------------------------------------------------ |
 | Agent     | The general class of entities and principals that interact with a UCAN                           |
 | Audience  | The Principal delegated to in the current UCAN. Listed in the `aud` field                        |
 | Executor  | The Agent that actually performs the action described in an invocation                           |
 | Invoker   | A Principal that requests an Executor perform some action that uses the Invoker's authority      |
 | Issuer    | The Principal of the current UCAN. Listed in the `iss` field                                     |
 | Owner     | A Subject that controls some external resource                                                   |
 | Principal | An agent identified by DID (listed in a UCAN's `iss` or `aud` field)                             |
 | Revoker   | The Issuer listed in a proof chain that revokes a UCAN                                           |
 | Subject   | The Principal who's authority is delegated or invoked                                            |
 | Validator | Any Agent that interprets a UCAN to determine that it is valid, and which capabilities it grants |
 ```mermaid
 flowchart TD
    subgraph Agent
        subgraph Principal
            direction TB
            subgraph Issuer
                direction TB
                subgraph Subject
                    direction TB
                    Executor
                    Owner
                end
                Revoker
            end
            subgraph Audience
                Invoker
            end
        end
        Validator
    end
 ```
 ## Subject
 > At the very least every object should have a URL
 >
 > — [Alan Kay], [The computer revolution hasn't happened yet]
 > Every Erlang process in the universe should be addressable and introspective
 >
 > — [Joe Armstrong], [Code Mesh 2016]
 A [Subject] represents the Agent that a capability is for. A Subject MUST be referenced by [DID]. This behaves much like a [GUID], with the addition of public key verifiability. This unforgeability prevents malicious namespace collisions which can lead to [confused deputies][confused deputy problem].
 ### Resource
 A resource is some data or process that can be uniquely identified by a [URI]. It can be anything from a row in a database, a user account, storage quota, email address, etc. Resource MAY be as coarse or fine grained as desired. Finer-grained is RECOMMENDED where possible, as it is easier to model the principle of least authority ([PoLA]).
 A resource describes the noun of a capability. The resource pointer MUST be provided in [URI] format. Arbitrary and custom URIs MAY be used, provided that the intended recipient can decode the URI. The URI is merely a unique identifier to describe the pointer to — and within — a resource.
 Having a unique agent represent a resource (and act as its manager) is RECOMMENDED. However, to help traditional ACL-based systems transition to certificate capabilities, an agent MAY manage multiple resources, and [act as the registrant in the ACL system][wrapping existing systems].
 Unless explicitly stated, the Resource of a UCAN MUST be the Subject.
 ## Issuer & Audience
 The Issuer (`iss`) and Audience (`aud`) can be conceptualized as the sender and receiver (respectively) of a postal letter. Every UCAN MUST be signed with the private key associated with the DID in the `iss` field.
 For example:
 ```js
 "aud": "did:key:z6MkiTBz1ymuepAQ4HEHYSF1H8quG5GLVVQR3djdX3mDooWp",
 "iss": "did:key:zDnaerDaTF5BXEavCrfRZEk316dpbLsfPDZ3WJ5hRTPFU2169",
 ```
 Please see the [Cryptosuite] section for more detail on DIDs.
 # Lifecycle
 The UCAN lifecycle has four components:
 | Spec         | Description                                                              | Requirement Level |
 | ------------ | ------------------------------------------------------------------------ | ----------------- |
 | [Delegation] | Pass, attenuate, and secure authority in a partition-tolerant way        | REQUIRED          |
 | [Invocation] | Exercise authority that has been delegated through one or more delegates | REQUIRED          |
 | [Promise]    | Await the result of an Invocation inside another Invocation              | RECOMMENDED       |
 | [Revocation] | Undo a delegation, breaking a delegation chain for malicious users       | RECOMMENDED       |
 ```mermaid
 flowchart TD
    prm(Promise)
    inv(Invocation)
    del(Delegation)
    rev(Revocation)
    prm -->|awaits| inv
    del -->|proves| inv
    rev -.->|kind of| inv
    rev -->|invalidates| del
    click del href "https://github.com/ucan-wg/delegation" "UCAN Delegation Spec"
    click inv href "https://github.com/ucan-wg/invocation" "UCAN Invocation Spec"
    click rev href "https://github.com/ucan-wg/revocation" "UCAN Revocation Spec"
 ```
 ## Time
 It is often useful to talk about a UCAN in the context of some action. For example, a UCAN delegation may be valid when it was created, but expired when invoked.
 ```mermaid
 sequenceDiagram
    Alice -->> Bob: Delegate
    Bob ->> Bob: Validate
    Bob -->> Carol: Delegate
    Carol ->> Carol: Validate
    Carol ->> Alice: Invoke
    Alice ->> Alice: Validate
    Alice ->> Alice: Execute
 ```
 ### Validity Interval
 The period of time that a capability is valid from and until. This is the range from the latest "not before" to the earliest expiry in the UCAN delegation chain.
 ### Delegation-Time
 The moment at which a delegation is asserted. This MAY be captured by an `iat` field, but is generally superfluous to capture in the token.
 ### Invocation-Time
 The moment a UCAN Invocation is created. It must be within the Validity Interval.
 ### Validation-Time
 Validation MAY occur at multiple points during a UCAN's lifecycle. The main two are:
 - On receipt of a delegation
 - When executing an invocation
 ### Execution-Time
 To avoid the overloaded word "runtime", UCAN adopts the term "execution-time" to express the moment that the executor attempts to use the authority captured in an invocation and associated delegation chain. Validation MUST occur at this time.
 ## Time Bounds
 `nbf` and `exp` stand for "not before" and "expires at," respectively. These MUST be expressed as seconds since the Unix epoch in UTC, without time zone or other offset. Taken together, they represent the time bounds for a token. These timestamps MUST be represented as the number of integer seconds since the Unix epoch. Due to limitations[^js-num-size] in numerics for certain common languages, timestamps outside of the range from $-2^{53} – 1$ to $2^{53} – 1$ MUST be rejected as invalid.
 The `nbf` field is OPTIONAL. When omitted, the token MUST be treated as valid beginning from the Unix epoch. Setting the `nbf` field to a time in the future MUST delay invoking a UCAN. For example, pre-provisioning access to conference materials ahead of time but not allowing access until the day it starts is achievable with judicious use of `nbf`.
 The `exp` field is RECOMMENDED. Following the [principle of least authority][PoLA], it is RECOMMENDED to give a timestamp expiry for UCANs. If the token explicitly never expires, the `exp` field MUST be set to `null`. If the time is in the past at validation time, the token MUST be treated as expired and invalid.
 Keeping the window of validity as short as possible is RECOMMENDED. Limiting the time range can mitigate the risk of a malicious user abusing a UCAN. However, this is situationally dependent. It may be desirable to limit the frequency of forced reauthorizations for trusted devices. Due to clock drift, time bounds SHOULD NOT be considered exact. A buffer of ±60 seconds is RECOMMENDED.
 Several named points of time in the UCAN lifecycle can be found in the [high level spec][UCAN].
 Below are a couple examples:
 ```js
 {
  // ...
  "nbf": 1529496683,
  "exp": 1575606941
 }
 ```
 ```js
 {
  // ...
  "exp": 1575606941
 }
 ```
 ```js
 {
  // ...
  "nbf": 1529496683,
  "exp": null
 }
 ```
 ## Lifecycle Example
 Here is a concrete example of all stages of the UCAN lifecycle for database write access.
 ```mermaid
 sequenceDiagram
    participant Database
    actor DBAgent
    actor Alice
    actor Bob
    Note over Database, DBAgent: Set Up Agent-Owned Resource
    DBAgent ->> Database: createDB()
    autonumber 1
    Note over DBAgent, Bob: Delegation
    DBAgent -->> Alice: delegate(DBAgent, write)
    Alice -->> Bob: delegate(DBAgent, write)
    Note over Database, Bob: Invocation
    Bob ->> DBAgent: invoke(DBAgent, [write, [key, value]], proof: [➊,➋])
    DBAgent ->> Database: write(key, value)
    DBAgent ->> Bob: ACK
    Note over DBAgent, Bob: Revocation
    Alice ->> DBAgent: revoke(➋, proof: [➊,➋])
    Bob ->> DBAgent: invoke(DBAgent, [write, [key, newValue]], proof: [➊,➋])
    DBAgent -X Bob: NAK(➏) [rejected]
 ```
 ## Capability
 A capability is the association of an ability to a subject: `subject x command x policy`.
 The Subject and Command fields are REQUIRED. Any non-normative extensions are OPTIONAL.
 For example, a capability may used to represent the ability to send email from a certain address to others at `@example.com`.
 | Field   | Example                                                                                      |
 | ------- | -------------------------------------------------------------------------------------------- |
 | Subject | `did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK`                                   |
 | Command | `/msg/send`                                                                                  |
 | Policy  | `["or", ["==", ".from", "mailto:me@example.com"], ["match", ".cc", "mailto:*@example.com"]]` |
 For a more complete treatment, please see the [UCAN Delegation][delegation] spec.
 ## Authority
 > Whether to enable cooperation or to limit vulnerability, we care about _authority_ rather than _permissions._ Permissions determine what actions an individual program may perform on objects it can directly access. Authority describes the effects that a program may cause on objects it can access, either directly by permission, or indirectly by permitted interactions with other programs.
 >
 > —[Mark Miller], [Robust Composition]
 The set of capabilities delegated by a UCAN is called its "authority." To frame it another way, it's the set of effects that a principal can cause, and acts as a declarative description of delegated abilities.
 Merging capability authorities MUST follow set semantics, where the result includes all capabilities from the input authorities. Since broader capabilities automatically include narrower ones, this process is always additive. Capability authorities can be combined in any order, with the result always being at least as broad as each of the original authorities.
 ```plaintext
                   ┌───────────────────────┐  ┐
                   │                       │  │
                   │                       │  │
                   │                       │  │
                   │                       │  │
                   │       Subject B       │  │
 ┌──────────────────┼ ─ ─       x           │  │
 │                       │  Ability Z       │  ├──    BxZ
 │                  │                       │  │  Capability
 │                       │                  │  │
 │                  │                       │  │
 │       Subject A       │                  │  │
 │           x      │                       │  │
 │       Ability Y   ─  ─┼──────────────────┘  ┘
 │                       │
 │                       │
 │                       │
 │                       │
 │                       │
 └───────────────────────┘
 └─────────────────────┬────────────────────┘
                      │
                  AxY U BxZ
                  Capability
 ```
 The capability authority is the total rights of the authorization space down to the relevant volume of authorizations. Individual capabilities MAY overlap; the authority is the union. Every unique delegated capability MUST have equal or narrower capabilities from their delegator. Inside this content space, you can draw a boundary around some resource(s) (their type, identifiers, and paths or children) and their capabilities.
 ## Command
 Commands are concrete messages ("verbs") that MUST be unambiguously interpretable by the Subject of a UCAN. Commands are REQUIRED in invocations. Some examples include `/msg/send`, `/crud/read`, and `/ucan/revoke`.
 Much like other message-passing systems, the specific resource MUST define the behavior for a particular message. For instance, `/crud/update` MAY be used to destructively update a database row, or append to a append-only log. Specific messages MAY be created at will; the only restriction is that the Executor understand how to interpret that message in the context of a specific resource.
 While arbitrary semantics MAY be described, they MUST apply to the target resource. For instance, it does not make sense to apply `/msg/send` to a typical file system.
 ### Segment Structure
 Commands MUST be lowercase, and begin with a slash (`/`). Segments MUST be separated by a slash. A trailing slash MUST NOT be present. All of the following are syntactically valid Commands:
 - `/`
 - `/crud`
 - `/crud/create`
 - `/stack/pop`
 - `/crypto/sign`
 - `/foo/bar/baz/qux/quux`
 - `/ほげ/ふが`
 Segment structure is important since shorter Commands prove longer paths. For example, `/` can be used as a proof of _any_ other Command. For example, `/crypto` MAY be used to prove `/crypto/sign` but MUST NOT prove `/stack/pop` or `/cryptocurrency`.
 ### `/` AKA "Top"
 _"Top" (`/`) is the most powerful ability, and as such it SHOULD be handled with care and used sparingly._
 The "top" (or "any", or "wildcard") ability MUST be denoted `/`. This can be thought of as something akin to a super user permission in RBAC.
 The wildcard ability grants access to all other capabilities for the specified resource, across all possible namespaces. The wildcard ability is useful when "linking" agents by delegating all access to another device controlled by the same user, and that should behave as the same agent. It is extremely powerful, and should be used with care. Among other things, it permits the delegate to update a Subject's mutable DID document (change their private keys), revoke UCAN delegations, and use any resources delegated to the Subject by others.
 ```mermaid
 %%{ init: { 'flowchart': { 'curve': 'linear' } } }%%
 flowchart BT
  /
  /msg --> /
  subgraph msgGraph [ ]
    /msg/send --> /msg
    /msg/receive --> /msg
  end
  /crud --> /
  subgraph crudGraph [ ]
    /crud/read --> /crud
    /crud/mutate --> /crud
    subgraph mutationGraph [ ]
        /crud/mutate/create --> /crud/mutate
        /crud/mutate/update --> /crud/mutate
        /crud/mutate/destroy --> /crud/mutate
    end
  end
  ... --> /
 ```
 ### Reserved Commands
 #### `/ucan` Namespace
 The `/ucan` Command namespace MUST be reserved. This MUST include any ability string matching the regex `^ucan\/.*`. This is important for keeping a space for community-blessed Commands in the future, such as standard library Commands, such as [Revocation].
 ## Attenuation
 Attenuation is the process of constraining the capabilities in a delegation chain. Each direct delegation MUST either directly restate or attenuate (diminish) its capabilities.
 # Token Resolution
 Token resolution is transport specific. The exact format is left to the relevant UCAN transport specification. At minimum, such a specification MUST define at least the following:
 1. Request protocol
 2. Response protocol
 3. Collections format
 Note that if an instance cannot dereference a CID at runtime, the UCAN MUST fail validation. This is consistent with the [constructive semantics] of UCAN.
 # Nonce
 The REQUIRED nonce parameter `nonce` MAY be any value. A randomly generated string is RECOMMENDED to provide a unique UCAN, though it MAY also be a monotonically increasing count of the number of links in the hash chain. This field helps prevent replay attacks and ensures a unique CID per delegation. The `iss`, `aud`, and `exp` fields together will often ensure that UCANs are unique, but adding the nonce ensures uniqueness.
 The recommended size of the nonce differs by key type. In many cases, a random 12-byte nonce is sufficient. If uncertain, check the nonce in your DID's crypto suite.
 This field SHOULD NOT be used to sign arbitrary data, such as signature challenges. See the [`meta`][Metadata] field for more.
 Here is a simple example.
 ```js
 {
  // ...
  "nonce": {"/": {"bytes": "bGlnaHQgd29yay4"}}
 }
 ```
 # Metadata
 The OPTIONAL `meta` field contains a map of arbitrary metadata, facts, and proofs of knowledge. The enclosed data MUST be self-evident and externally verifiable. It MAY include information such as hash preimages, server challenges, a Merkle proof, dictionary data, etc.
 The data contained in this map MUST NOT be semantically meaningful to delegation chains.
 Below is an example:
 ```js
 {
  // ...
  "meta": {
    "challenges": {
      "example.com": "abcdef",
      "another.example.net": "12345"
    },
    "sha3_256": {
      "B94D27B9934D3E08A52E52D7DA7DABFAC484EFE37A5380EE9088F7ACE2EFCDE9": "hello world"
    }
  }
 }
 ```
 # Canonicalization
 ## Cryptosuite
 Across all UCAN specifications, the following cryptosuite MUST be supported:
 | Role      | REQUIRED Algorithms               | Notes                                |
 | --------- | --------------------------------- | ------------------------------------ |
 | Hash      | [SHA-256]                         |                                      |
 | Signature | [Ed25519], [P-256], [`secp256k1`] | Preference of Ed25519 is RECOMMENDED |
 | [DID]     | [`did:key`]                       |                                      |
 ## Encoding
 All UCANs MUST be canonically encoded with [DAG-CBOR] for signing. A UCAN MAY be presented or stored in other [IPLD] formats (such as [DAG-JSON]), but converted to DAG-CBOR for signature validation.
 ## Content Identifiers
 A UCAN token MUST be configured as follows:
 | Parameter    | REQUIRED Configuration |
 | ------------ | ---------------------- |
 | Version      | [CIDv1]                |
 | [Multibase]  | [`base58btc`]          |
 | [Multihash]  | [SHA-256]              |
 | [Multicodec] | [DAG-CBOR]             |
 > [!NOTE]
 > All CIDs encoded as above start with the characters `zdpu`.
 The resolution of these addresses is left to the implementation and end-user, and MAY (non-exclusively) include the following: local store, a distributed hash table (DHT), gossip network, or RESTful service.
 ## Envelope
 All UCAN formats MUST use the following envelope format:
 | Field                             | Type           | Description                                                    |
 | --------------------------------- | -------------- | -------------------------------------------------------------- |
 | `.0`                              | `Bytes`        | A signature by the Payload's `iss` over the `SigPayload` field |
 | `.1`                              | `SigPayload`   | The content that was signed                                    |
 | `.1.h`                            | `VarsigHeader` | The [Varsig] v1 header                                         |
 | `.1.ucan/<subspec-tag>@<version>` | `TokenPayload` | The UCAN token payload                                         |
 ```mermaid
 flowchart TD
    subgraph Ucan ["UCAN Envelope"]
        SignatureBytes["Signature (raw bytes)"]
        subgraph SigPayload ["Signature Payload"]
            VarsigHeader["Varsig Header"]
            subgraph UcanPayload ["Token Payload"]
                fields["..."]
            end
        end
    end
 ```
 For example:
 ```js
 [
  {
    "/": {
      bytes:
        "7aEDQLYvb3lygk9yvAbk0OZD0q+iF9c3+wpZC4YlFThkiNShcVriobPFr/wl3akjM18VvIv/Zw2LtA4uUmB5m8PWEAU",
    },
  },
  {
    h: { "/": { bytes: "NBIFEgEAcQ" } },
    "ucan/example@1.0.0-rc.1": {
      hello: "world",
    },
  },
 ];
 ```
 ### Payload
 A UCAN's Payload MUST contain at least the following fields:
 | Field   | Type                                      | Required | Description                                                 |
 | ------- | ----------------------------------------- | -------- | ----------------------------------------------------------- |
 | `iss`   | `DID`                                     | Yes      | Issuer DID (sender)                                         |
 | `aud`   | `DID`                                     | Yes      | Audience DID (receiver)                                     |
 | `sub`   | `DID`                                     | Yes      | Principal that the chain is about (the [Subject])           |
 | `cmd`   | `String`                                  | Yes      | The [Command] to eventually invoke                          |
 | `args`  | `{String : Any}`                          | Yes      | Any [Arguments] that MUST be present in the Invocation      |
 | `nonce` | `Bytes`                                   | Yes      | Nonce                                                       |
 | `meta`  | `{String : Any}`                          | No       | [Meta] (asserted, signed data) — is not delegated authority |
 | `nbf`   | `Integer` (53-bits[^js-num-size])         | No       | "Not before" UTC Unix Timestamp in seconds (valid from)     |
 | `exp`   | `Integer \| Null` (53-bits[^js-num-size]) | Yes      | Expiration UTC Unix Timestamp in seconds (valid until)      |
 # Implementation Recommendations
 ## Delegation Store
 A validator MAY keep a local store of UCANs that it has received. UCANs are immutable but also time-bound so that this store MAY evict expired or revoked UCANs.
 This store SHOULD be indexed by CID (content addressing). Multiple indices built on top of this store MAY be used to improve capability search or selection performance.
 ## Memoized Validation
 Aside from revocation, capability validation is idempotent. Marking a CID (or capability index inside that CID) as valid acts as memoization, obviating the need to check the entire structure on every validation. This extends to distinct UCANs that share a proof: if the proof was previously reviewed and is not revoked, it is RECOMMENDED to consider it valid immediately.
 Revocation is irreversible. Suppose the validator learns of revocation by UCAN CID. In that case, the UCAN and all of its derivatives in such a cache MUST be marked as invalid, and all validations immediately fail without needing to walk the entire structure.
 ## Replay Attack Prevention
 Replay attack prevention is REQUIRED. Every UCAN token MUST hash to a unique [CIDv1]. Some simple strategies for implementing uniqueness tracking include maintaining a set of previously seen CIDs, or requiring that nonces be monotonically increasing per principal. This MAY be the same structure as a validated UCAN memoization table (if one is implemented).
 Maintaining a secondary token expiry index is RECOMMENDED. This enables garbage collection and more efficient search. In cases of very large stores, normal cache performance techniques MAY be used, such as Bloom filters, multi-level caches, and so on.
 ## Beyond Single System Image
 > As we continue to increase the number of globally connected devices, we must embrace a design that considers every single member in the system as the primary site for the data that it is generates. It is completely impractical that we can look at a single, or a small number, of globally distributed data centers as the primary site for all global information that we desire to perform computations with.
 >
 > —[Meiklejohn], [A Certain Tendency Of The Database Community]
 Unlike many authorization systems where a service controls access to resources in their care, location-independent, offline, and leaderless resources require control to live with the user. Therefore, the same data MAY be used across many applications, data stores, and users. Since they don't have a single location, applying UCAN to [RSM]s and [CRDT]s MAY be modelled by lifting the requirement that the Executor be the Subject.
 Ultimately this comes down to a question of push vs pull. In push, the subject MUST be the specific site being pushed to ("I command you to apply the following updates to your state").
 Pull is the broad class of situations where an Invoker doesn't require that a particular replica apply its state. Applying a change to a local CRDT replica and maintaining a UCAN invocation log is a valid update to "the CRDT": a version of the CRDT Subject exists locally even if the Subject's private key is not present. Gossiping these changes among agents allows each to apply changes that it becomes aware of. Thanks to the invocation log (or equivalent integrated directly into the CRDT), provenance of authority is made transparent.
 ```mermaid
 sequenceDiagram
    participant CRDT as Initial Grow-Only Set (CRDT)
    actor Alice
    actor Bob
    actor Carol
    autonumber
    Note over CRDT, Bob: Setup
    CRDT -->> Alice: delegate(CRDT_ID, merge)
    CRDT -->> Bob: delegate(CRDT_ID, merge)
    Note over Bob, Carol: Bob Invites Carol
    Bob -->> Carol: delegate(CRDT_ID, merge)
    Note over Alice, Carol: Direct P2P Gossip
    Carol ->> Bob: invoke(CRDT_ID, merge, {"Carrot"}, proof: [➋,❸])
    Alice ->> Carol: invoke(CRDT_ID, merge, {"Apple"}}, proof: [➊])
    Bob ->> Alice: invoke(CRDT_ID, merge, {"Banana", "Carrot"}, proof: [➋])
 ```
 ## Wrapping Existing Systems
 In the RECOMMENDED scenario, the agent controlling a resource has a unique reference to it. This is always possible in a system that has adopted capabilities end-to-end.
 Interacting with existing systems MAY require relying on ambient authority contained in an ACL, non-unique reference, or other authorization logic. These cases are still compatible with UCAN, but the security guarantees are weaker since 1. the surface area is larger, and 2. part of the auth system lives outside UCAN.
 ```mermaid
 sequenceDiagram
    participant Database
    participant ACL as External Auth System
    actor DBAgent
    actor Alice
    actor Bob
    Note over ACL, DBAgent: Setup
    DBAgent ->> ACL: signup(DBAgent)
    ACL ->> ACL: register(DBAgent)
    autonumber 1
    Note over DBAgent, Bob: Delegation
    DBAgent -->> Alice: delegate(DBAgent, write)
    Alice -->> Bob: delegate(DBAgent, write)
    Note over Database, Bob: Invocation
    Bob ->>+ DBAgent: invoke(DBAgent, [write, key, value], proof: [➊,➋])
    critical External System
        DBAgent ->> ACL: getToken(write, key, AuthGrant)
        ACL ->> DBAgent: AccessToken
        DBAgent ->> Database: request(write, value, AccessToken)
        Database ->> DBAgent: ACK
    end
    DBAgent ->>- Bob: ACK
 ```
 # FAQ
 ## What prevents an unauthorized party from using an intercepted UCAN?
 UCANs always contain information about the sender and receiver. A UCAN is signed by the sender (the `iss` field DID) and can only be created by an agent in possession of the relevant private key. The recipient (the `aud` field DID) is required to check that the field matches their DID. These two checks together secure the certificate against use by an unauthorized party. [UCAN Invocations][invocation] prevent use by an unauthorized party by signing over a request to use the capability granted in a delegation chain.
 ## What prevents replay attacks on the invocation use case?
 All UCAN Invocations MUST have a unique CID. The executing agent MUST check this validation uniqueness against a local store of unexpired UCAN hashes.
 This is not a concern when simply delegating since receiving a delegation is idempotent.
 ## Is UCAN secure against person-in-the-middle attacks?
 _UCAN does not have any special protection against person-in-the-middle (PITM) attacks._
 If a PITM attack was successfully performed on a UCAN delegation, the proof chain would contain the attacker's DID(s). It is possible to detect this scenario and revoke the relevant UCAN but this does require special inspection of the topmost `iss` field to check if it is the expected DID. Therefore, it is strongly RECOMMENDED to only delegate UCANs to agents that are both trusted and authenticated and over secure channels.
 ## Can my implementation support more cryptographic algorithms?
 It is possible to use other algorithms, but doing so limits interoperability with the broader UCAN ecosystem. This is thus considered "off spec" (i.e. non-interoperable). If you choose to extend UCAN with additional algorithms, you MUST include this metadata in the (self-describing) [Varsig] header.
 # Related Work and Prior Art
 [SPKI/SDSI] is closely related to UCAN. A different encoding format is used, and some details vary (such as a delegation-locking bit), but the core idea and general usage pattern are very close. UCAN can be seen as making these ideas more palatable to a modern audience and adding a few features such as content IDs that were less widespread at the time SPKI/SDSI were written.
 [ZCAP-LD] is closely related to UCAN. The primary differences are in formatting, addressing by URL instead of CID, the mechanism of separating invocation from authorization, and single versus multiple proofs.
 [CACAO] is a translation of many of these ideas to a cross-blockchain delegated bearer token model. It contains the same basic concepts as UCAN delegation, but is aimed at small messages and identities that are rooted in mutable documents rooted on a blockchain and lacks the ability to subdelegate capabilities.
 [Local-First Auth] is a non-certificate-based approach, instead relying on a CRDT to build up a list of group members, devices, and roles. It has a friendly invitation mechanism based on a [Seitan token exchange]. It is also straightforward to see which users have access to what, avoiding the confinement problem seen in many decentralized auth systems.
 [Macaroon] is a MAC-based capability and cookie system aimed at distributing authority across services in a trusted network (typically in the context of a Cloud). By not relying on asymmetric signatures, Macaroons achieve excellent space savings and performance, given that the MAC can be checked against the relevant services during discharge. The authority is rooted in an originating server rather than with an end-user.
 [Biscuit] uses Datalog to describe capabilities. It has a specialized format but is otherwise in line with UCAN.
 [Verifiable credentials] are a solution for data about people or organizations. However, they are aimed at a related-but-distinct problem: asserting attributes about the holder of a DID, including things like work history, age, and membership.
 # Acknowledgments
 Thank you to [Brendan O'Brien] for real-world feedback, technical collaboration, and implementing the first Golang UCAN library.
 Thank you [Blaine Cook] for the real-world feedback, ideas on future features, and lessons from other auth standards.
 Many thanks to [Hugo Dias], [Mikael Rogers], and the entire DAG House team for the real world feedback, and finding inventive new use cases.
 Thank to [Hannah Howard] and [Alan Shaw] at [Storacha] for their team's feedback from real world use cases.
 Many thanks to [Brian Ginsburg] and [Steven Vandevelde] for their many copy edits, feedback from real world usage, maintenance of the TypeScript implementation, and tools such as [ucan.xyz].
 Many thanks to [Christopher Joel] for his real-world feedback, raising many pragmatic considerations, and the Rust implementation and related crates.
 Many thanks to [Christine Lemmer-Webber] for her handwritten(!) feedback on the design of UCAN, spearheading the [OCapN] initiative, and her related work on [ZCAP-LD].
 Many thanks to [Alan Karp] for sharing his vast experience with capability-based authorization, patterns, and many right words for us to search for.
 Thanks to [Benjamin Goering] for the many community threads and connections to [W3C] standards.
 Thanks to [Juan Caballero] for the numerous questions, clarifications, and general advice on putting together a comprehensible spec.
 Thank you [Dan Finlay] for being sufficiently passionate about [OCAP] that we realized that capability systems had a real chance of adoption in an ACL-dominated world.
 Thanks to [Peter van Hardenberg][PvH] and [Martin Kleppmann] of [Ink & Switch] for conversations exploring options for access control on CRDTs and [local-first] applications.
 Thanks to the entire [SPKI WG][SPKI/SDSI] for their closely related pioneering work.
 We want to especially recognize [Mark Miller] for his numerous contributions to the field of distributed auth, programming languages, and networked security writ large.
 <!-- Footnotes -->
 [^js-num-size]: JavaScript has a single numeric type ([`Number`][JS Number]) for both integers and floats. This representation is defined as a [IEEE-754] double-precision floating point number, which has a 53-bit significand.
 [^pcec]: To be precise, this is a [PC/EC][PACELC] system, which is a critical trade-off for many systems. UCAN can be used to model both PC/EC and PA/EL, but is most typically PC/EL.
 <!-- Internal Links -->
 [Command]: #command
 [Cryptosuite]: #cryptosuite
 [overcoming SSI]: #beyond-single-system-image
 [sub-specifications]: #sub-specifications
 [wrapping existing systems]: #wrapping-existing-systems
 <!-- External Links -->
 [IEEE-754]: https://ieeexplore.ieee.org/document/8766229
 [A Certain Tendency Of The Database Community]: https://arxiv.org/pdf/1510.08473.pdf
 [ACL]: https://en.wikipedia.org/wiki/Access-control_list
 [Alan Karp]: https://github.com/alanhkarp
 [Alan Kay]: https://en.wikipedia.org/wiki/Alan_Kay
 [Alan Shaw]: https://github.com/alanshaw
 [BCP 14]: https://www.rfc-editor.org/info/bcp14
 [BLAKE3]: https://github.com/BLAKE3-team/BLAKE3
 [Benjamin Goering]: https://github.com/gobengo
 [Biscuit]: https://github.com/biscuit-auth/biscuit/
 [Blaine Cook]: https://github.com/blaine
 [Bluesky]: https://blueskyweb.xyz/
 [Brendan O'Brien]: https://github.com/b5
 [Brian Ginsburg]: https://github.com/bgins
 [Brooklyn Zelenka]: https://github.com/expede
 [CACAO]: https://blog.ceramic.network/capability-based-data-security-on-ceramic/
 [CIDv1]: https://docs.ipfs.io/concepts/content-addressing/#identifier-formats
 [CIDv1]: https://github.com/multiformats/cid
 [CRDT]: https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type
 [Capability Myths Demolished]: https://srl.cs.jhu.edu/pubs/SRL2003-02.pdf
 [Christine Lemmer-Webber]: https://github.com/cwebber
 [Christopher Joel]: https://github.com/cdata
 [Code Mesh 2016]: https://www.codemesh.io/codemesh2016
 [DAG-CBOR]: https://ipld.io/specs/codecs/dag-cbor/spec/
 [DAG-JSON]: https://ipld.io/specs/codecs/dag-json/spec/
 [DID fragment]: https://www.w3.org/TR/did-core/#fragment
 [DID path]: https://www.w3.org/TR/did-core/#path
 [DID subject]: https://www.w3.org/TR/did-core/#dfn-did-subjects
 [DID]: https://www.w3.org/TR/did-core/
 [Dan Finlay]: https://github.com/danfinlay
 [Daniel Holmgren]: https://github.com/dholms
 [ECDSA security]: https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm#Security
 [Ed25519]: https://en.wikipedia.org/wiki/EdDSA#Ed25519
 [EdDSA]: https://datatracker.ietf.org/doc/html/rfc8032#section-5.1
 [Email about SPKI]: https://web.archive.org/web/20140724054706/http://wiki.erights.org/wiki/Capability-based_Active_Invocation_Certificates
 [FIDO]: https://fidoalliance.org/what-is-fido/
 [Fission]: https://fission.codes
 [GUID]: https://en.wikipedia.org/wiki/Universally_unique_identifier
 [Hannah Howard]: https://github.com/hannahhoward
 [Hugo Dias]: https://github.com/hugomrdias
 [IPLD]: https://ipld.io/
 [Ink & Switch]: https://www.inkandswitch.com/
 [Inversion of control]: https://en.wikipedia.org/wiki/Inversion_of_control
 [Irakli Gozalishvili]: https://github.com/Gozala
 [JWT]: https://www.rfc-editor.org/rfc/rfc7519
 [Joe Armstrong]: https://en.wikipedia.org/wiki/Joe_Armstrong_(programmer)
 [Juan Caballero]: https://github.com/bumblefudge
 [Local-First Auth]: https://github.com/local-first-web/auth
 [Macaroon]: https://storage.googleapis.com/pub-tools-public-publication-data/pdf/41892.pdf
 [Mark Miller]: https://github.com/erights
 [Martin Kleppmann]: https://martin.kleppmann.com/
 [Meiklejohn]: https://christophermeiklejohn.com/
 [Mikael Rogers]: https://github.com/mikeal/
 [Multibase]: https://github.com/multiformats/multibase
 [Multicodec]: https://github.com/multiformats/multicodec
 [Multics]: https://en.wikipedia.org/wiki/Multics
 [Multihash]: https://www.multiformats.io/multihash/
 [OCAP]: http://erights.org/elib/capability/index.html
 [OCapN]: https://github.com/ocapn/ocapn
 [P-256]: https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf#page=111
 [PACELC]: https://en.wikipedia.org/wiki/PACELC_theorem
 [Philipp Krüger]: https://github.com/matheus23
 [PoLA]: https://en.wikipedia.org/wiki/Principle_of_least_privilege
 [Protocol Labs]: https://protocol.ai/
 [PvH]: https://www.pvh.ca
 [RBAC]: https://en.wikipedia.org/wiki/Role-based_access_control
 [RFC 2119]: https://datatracker.ietf.org/doc/html/rfc2119
 [RFC 3339]: https://www.rfc-editor.org/rfc/rfc3339
 [RFC 8037]: https://datatracker.ietf.org/doc/html/rfc8037
 [RSM]: https://en.wikipedia.org/wiki/State_machine_replication
 [Robust Composition]: http://www.erights.org/talks/thesis/markm-thesis.pdf
 [SHA-256]: https://en.wikipedia.org/wiki/SHA-2
 [SPKI/SDSI]: https://datatracker.ietf.org/wg/spki/about/
 [SPKI]: https://theworld.com/~cme/html/spki.html
 [Seitan token exchange]: https://book.keybase.io/docs/teams/seitan
 [Steven Vandevelde]: https://github.com/icidasset
 [Storacha]: https://storacha.network/
 [The Structure of Authority]: http://erights.org/talks/no-sep/secnotsep.pdf
 [The computer revolution hasn't happened yet]: https://www.youtube.com/watch?v=oKg1hTOQXoY
 [UCAN Promise]: https://github.com/ucan-wg/promise
 [URI]: https://www.rfc-editor.org/rfc/rfc3986
 [Varsig]: https://github.com/ChainAgnostic/varsig
 [Verifiable credentials]: https://www.w3.org/2017/vc/WG/
 [W3C]: https://www.w3.org/
 [WebCrypto API]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API
 [Witchcraft Software]: https://github.com/expede
 [ZCAP-LD]: https://w3c-ccg.github.io/zcap-spec/
 [`base58btc`]: https://github.com/multiformats/multibase/blob/master/multibase.csv#L21
 [`did:key`]: https://w3c-ccg.github.io/did-method-key/
 [`secp256k1`]: https://en.bitcoin.it/wiki/Secp256k1
 [browser api crypto key]: https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey
 [capabilities]: https://en.wikipedia.org/wiki/Object-capability_model
 [caps as keys]: http://www.erights.org/elib/capability/duals/myths.html#caps-as-keys
 [certificate capability model]: https://web.archive.org/web/20140724054706/http://wiki.erights.org/wiki/Capability-based_Active_Invocation_Certificates
 [confinement]: http://www.erights.org/elib/capability/dist-confine.html
 [confused deputy problem]: https://en.wikipedia.org/wiki/Confused_deputy_problem
 [constructive semantics]: https://en.wikipedia.org/wiki/Intuitionistic_logic
 [content addressable storage]: https://en.wikipedia.org/wiki/Content-addressable_storage
 [content addressing]: https://en.wikipedia.org/wiki/Content-addressable_storage
 [dag-json multicodec]: https://github.com/multiformats/multicodec/blob/master/table.csv#L104
 [delegation]: https://github.com/ucan-wg/delegation
 [fail-safe]: https://en.wikipedia.org/wiki/Fail-safe
 [invocation]: https://github.com/ucan-wg/invocation
 [local-first]: https://www.inkandswitch.com/local-first/
 [number zero]: https://n0.computer/
 [passkey]: https://www.passkeys.com/
 [promise]: https://github.com/ucan-wg/promise
 [raw data multicodec]: https://github.com/multiformats/multicodec/blob/a03169371c0a4aec0083febc996c38c3846a0914/table.csv?plain=1#L41
 [revocation]: https://github.com/ucan-wg/revocation
 [secure hardware enclave]: https://support.apple.com/en-ca/guide/security/sec59b0b31ff
 [spki rfc]: https://www.rfc-editor.org/rfc/rfc2693.html
 [time definition]: https://en.wikipedia.org/wiki/Temporal_database
 [trustless]: https://blueskyweb.xyz/blog/3-6-2022-a-self-authenticating-social-protocol
 [ucan.xyz]: https://ucan.xyz
@@ -8,4 +8,4 @@ updates:
  - package-ecosystem: "gomod" # See documentation for possible values
    directory: "/" # Location of package manifests
    schedule:
-      interval: "weekly"
+      interval: "monthly"
@@ -0,0 +1,427 @@
 [
  {
    "name": "app-chain",
    "path": "app",
    "docs": [
      {
        "keywords": [
          "module",
          "cosmos"
        ],
        "url": "https://docs.cosmos.network/v0.50/build/building-modules/module-manager"
      },
      {
        "keywords": [
          "protobuf",
          "cosmos"
        ],
        "url": "https://docs.cosmos.network/v0.50/build/building-modules/messages-and-queries"
      },
      {
        "keywords": [
          "rpc",
          "protobuf",
          "service",
          "cosmos"
        ],
        "url": "https://docs.cosmos.network/v0.50/build/building-modules/msg-services"
      },
      {
        "keywords": [
          "protobuf",
          "rpc",
          "cosmos",
          "query"
        ],
        "url": "https://docs.cosmos.network/v0.50/build/building-modules/query-services"
      },
      {
        "keywords": [
          "cosmos",
          "depinject",
          "sdk"
        ],
        "url": "https://docs.cosmos.network/v0.50/build/building-modules/depinject"
      }
    ]
  },
  {
    "name": "ibc-protocol",
    "path": "app",
    "docs": [
      {
        "keywords": [
          "cosmos",
          "interchain",
          "accounts"
        ],
        "url": "https://ibc.cosmos.network/v8/apps/interchain-accounts/overview/"
      },
      {
        "keywords": [],
        "url": "https://ibc.cosmos.network/v8/apps/transfer/overview/"
      },
      {
        "keywords": [],
        "url": "https://docs.osmosis.zone/osmosis-core/asset-info/"
      },
      {
        "keywords": [],
        "url": "https://docs.osmosis.zone/osmosis-core/modules/tokenfactory"
      },
      {
        "keywords": [
          "usdc",
          "mint",
          "cosmos",
          "noble"
        ],
        "url": "https://docs.noble.xyz/cctp/mint"
      },
      {
        "keywords": [
          "usdc"
        ],
        "url": "https://docs.noble.xyz/cctp/mint_forward"
      },
      {
        "keywords": [],
        "url": "https://docs.evmos.org/protocol/modules/erc20"
      },
      {
        "keywords": [],
        "url": "https://docs.nomic.io/nbtc"
      }
    ]
  },
  {
    "name": "crypto-mpc",
    "path": "crypto/mpc",
    "docs": [
      {
        "keywords": [
          "mpc",
          "wallet",
          "security",
          "advanced cryptography"
        ],
        "url": "https://csrc.nist.gov/CSRC/media/Events/NTCW19/papers/paper-DKLS.pdf"
      }
    ]
  },
  {
    "name": "crypto-ucan",
    "path": "crypto/ucan",
    "docs": [
      {
        "keywords": [],
        "url": "https://raw.githubusercontent.com/ucan-wg/spec/refs/heads/main/README.md"
      }
    ]
  },
  {
    "name": "crypto-zkp",
    "path": "crypto/accumulator",
    "docs": [
      {
        "keywords": [],
        "url": "https://eprint.iacr.org/2021/1672.pdf"
      }
    ]
  },
  {
    "name": "sonr-hway",
    "path": "pkg/gateway/handlers",
    "docs": [
      {
        "keywords": [],
        "url": "https://echo.labstack.com/docs/cookbook/sse"
      },
      {
        "keywords": [],
        "url": "https://echo.labstack.com/docs/cookbook/websocket"
      },
      {
        "keywords": [],
        "url": "https://echo.labstack.com/docs/cookbook/subdomain"
      }
    ]
  },
  {
    "name": "database-orm",
    "path": "pkg/gateway/internal/database",
    "docs": [
      {
        "keywords": [],
        "url": "https://docs.tigerbeetle.com/coding/data-modeling"
      },
      {
        "keywords": [],
        "url": "https://docs.tigerbeetle.com/coding/two-phase-transfers"
      },
      {
        "keywords": [],
        "url": "https://docs.tigerbeetle.com/coding/reliable-transaction-submission"
      },
      {
        "keywords": [
          "currency"
        ],
        "url": "https://docs.tigerbeetle.com/coding/recipes/currency-exchange"
      },
      {
        "keywords": [
          "balance"
        ],
        "url": "https://docs.tigerbeetle.com/coding/recipes/balance-conditional-transfers"
      },
      {
        "keywords": [],
        "url": "https://docs.tigerbeetle.com/reference/account"
      },
      {
        "keywords": [],
        "url": "https://docs.tigerbeetle.com/reference/transfer"
      },
      {
        "keywords": [],
        "url": "https://docs.substreams.dev/documentation/consume/packages"
      },
      {
        "keywords": [],
        "url": "https://docs.substreams.dev/documentation/consume/sql/deployable-services/local-service"
      },
      {
        "keywords": [],
        "url": "https://docs.substreams.dev/tutorials/cosmos/injective/foundational"
      }
    ]
  },
  {
    "name": "sonr-vault",
    "path": "pkg/vault/handlers",
    "docs": [
      {
        "keywords": [],
        "url": "https://echo.labstack.com/docs/cookbook/jwt"
      },
      {
        "keywords": [],
        "url": "https://echo.labstack.com/docs/middleware/secure"
      },
      {
        "keywords": [],
        "url": "https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API"
      }
    ]
  },
  {
    "name": "motr-worker",
    "path": "pkg/vault/internal/database",
    "docs": [
      "https://dexie.org/docs/ExportImport/dexie-export-import",
      "https://dexie.org/docs/API-Reference#quick-reference",
      "https://templ.guide/syntax-and-usage/script-templates"
    ]
  },
  {
    "name": "ipfs-service",
    "path": "pkl/ipfs.net",
    "docs": [
      {
        "keywords": [],
        "url": "https://github.com/ipfs/kubo/blob/master/docs/config.md"
      },
      {
        "keywords": [],
        "url": "https://pkl-lang.org/main/current/language-reference/index.html"
      }
    ]
  },
  {
    "name": "matrix-service",
    "path": "pkl/matrix.net",
    "docs": [
      {
        "keywords": [],
        "url": "https://element-hq.github.io/synapse/latest/usage/configuration/config_documentation.html"
      },
      {
        "keywords": [],
        "url": "https://pkl-lang.org/main/current/language-reference/index.html"
      }
    ]
  },
  {
    "name": "chain-config",
    "path": "pkl/sonr.chain",
    "docs": [
      "https://tutorials.cosmos.network/tutorials/9-path-to-prod/5-network.html",
      "https://tutorials.cosmos.network/tutorials/9-path-to-prod/4-genesis.html",
      "https://pkl-lang.org/main/current/language-reference/index.html",
      "https://docs.cosmos.network/v0.50/user/run-node/run-testnet"
    ]
  },
  {
    "name": "gateway-config",
    "path": "pkl/sonr.hway",
    "docs": [
      {
        "keywords": [],
        "url": "https://pkl-lang.org/main/current/language-reference/index.html"
      }
    ]
  },
  {
    "name": "client-config",
    "path": "pkl/sonr.motr",
    "docs": [
      {
        "keywords": [],
        "url": "https://pkl-lang.org/main/current/language-reference/index.html"
      },
      {
        "keywords": [],
        "url": "https://web.dev/learn/pwa/service-workers/"
      },
      {
        "keywords": [],
        "url": "https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API"
      }
    ]
  },
  {
    "name": "core-dids",
    "path": "proto/did",
    "docs": [
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/packages/orm"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/building-modules/protobuf-annotations"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/modules/auth"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/packages/collections"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/modules/bank"
      }
    ]
  },
  {
    "name": "core-dwns",
    "path": "proto/dwn",
    "docs": [
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/building-modules/protobuf-annotations"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/packages/orm"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/modules/authz"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/packages/collections"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/modules/gov"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/modules/staking"
      }
    ]
  },
  {
    "name": "core-svcs",
    "path": "proto/svc",
    "docs": [
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/packages/collections"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/building-modules/protobuf-annotations"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/packages/orm"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/modules/group"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/modules/nft"
      }
    ]
  },
  {
    "name": "ci-cd",
    "path": "deploy",
    "docs": [
      {
        "keywords": [],
        "url": "https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions"
      },
      {
        "keywords": [],
        "url": "https://docs.cosmos.network/v0.50/build/tooling/cosmovisor"
      },
      {
        "keywords": [],
        "url": "https://f1bonacc1.github.io/process-compose/configuration/"
      },
      {
        "keywords": [],
        "url": "https://docs.nomic.io/network/ibc-relayer"
      },
      {
        "keywords": [],
        "url": "https://www.jetify.com/docs/devbox"
      },
      {
        "keywords": [],
        "url": "https://taskfile.dev/reference/cli"
      },
      {
        "keywords": [],
        "url": "https://taskfile.dev/reference/schema"
      },
      {
        "keywords": [],
        "url": "https://taskfile.dev/reference/templating/"
      }
    ]
  },
  {
    "name": "write-docs",
    "path": "docs",
    "docs": [
      {
        "keywords": [],
        "url": "https://squidfunk.github.io/mkdocs-material/reference/"
      },
      {
        "keywords": [],
        "url": "https://github.com/mkdocs/catalog/blob/main/README.md"
      }
    ]
  }
 ]
@@ -1,7 +0,0 @@
 #!/usr/bin/env bash
 set -e
 ROOT_DIR=$(git rev-parse --show-toplevel)
@@ -0,0 +1,70 @@
 #!/bin/bash
 set -e
 ROOT_DIR=$(git rev-parse --show-toplevel)
 # Extract scope name and path using jq, and pass it to fzf for selection
 SCOPE=$(cat "$ROOT_DIR/.github/scopes.json" | jq -r '.[] | "\(.name)"' | fzf --prompt "Select scope:")
 DOCS=$(cat "$ROOT_DIR/.github/scopes.json" | jq -r ".[] | select(.name == \"$SCOPE\") | .docs[].url")
 # Write Title
 TITLE=$(gum input --placeholder "Issue Title...")
 # Write Goal
 GOAL=$(mods --role "determine-issue-goal" "$SCOPE $TITLE")
 # Input Requirements
 REQUIREMENTS=()
 while true; do
    if [ ${#REQUIREMENTS[@]} -ge 2 ]; then
        if ! gum confirm "Do you want to add another requirement?"; then
            break
        fi
    fi
    REQUIREMENT=$(gum input --placeholder "Add a requirement...")
    if [ -n "$REQUIREMENT" ]; then
        REQUIREMENTS+=("$REQUIREMENT")
    else
        echo "Requirement cannot be empty. Please enter a valid requirement."
    fi
 done
 create_body() {
    echo "### Goal(s):"
    echo "$GOAL"
    echo "### Requirements:"
    for i in "${!REQUIREMENTS[@]}"; do
        echo "$(($i + 1)). ${REQUIREMENTS[$i]}"
    done
    echo "### Resources:"
    while IFS= read -r doc; do
        echo "- $doc"
    done <<< "$DOCS"
 }
 ISSUE_BODY=$(create_body)
 # Function to collect output
 preview_output() {
    echo "# ($SCOPE) $TITLE"
    echo "$ISSUE_BODY"
 }
 # Display the formatted output
 preview_output | gum format
 # Confirm to create a GitHub issue
 if gum confirm "Do you want to create a new GitHub issue with this information?"; then
    # Ask if this should be a draft issue
    if gum confirm "Create as draft issue?"; then
        # Create a draft GitHub issue
        gh issue create --repo onsonr/sonr --title "($SCOPE) $TITLE" --body "$ISSUE_BODY"
    else
        # Create a regular GitHub issue
        gh issue create --repo onsonr/sonr --title "($SCOPE) $TITLE" --body "$ISSUE_BODY" -a @me
    fi
 else
    exit 1
 fi
@@ -0,0 +1,140 @@
 name: Perform Checks on PR
 on:
  pull_request:
  merge_group:
 jobs:
  tidy-pr:
    name: Tidy PR
    if: github.event_name == 'pull_request'
    permissions:
      contents: read # for TimonVS/pr-labeler-action to read config file
      pull-requests: write # for TimonVS/pr-labeler-action to add labels in PR
    runs-on: ubuntu-latest
    steps:
      - uses: TimonVS/pr-labeler-action@v5
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}
          configuration-path: .github/pr-labeler.yml # optional, .github/pr-labeler.yml is the default value
  test-builds:
    if: github.event_name == 'pull_request'
    runs-on: ubuntu-latest
    name: Run Build Tests
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          repository: onsonr/sonr
          fetch-depth: 0
          fetch-tags: true
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - name: Run Sonrd Build
        run: make build
      - name: Run Hway Build
        run: make build-hway
      - name: Run Motr Build
        run: make build-motr
  test-unit:
    if: github.event_name == 'pull_request'
    runs-on: ubuntu-latest
    name: Run Unit Tests
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          repository: onsonr/sonr
          fetch-depth: 0
          fetch-tags: true
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - run: make test-unit
  test-race:
    runs-on: ubuntu-latest
    if: github.event_name == 'merge_group'
    name: Run Race Tests
    continue-on-error: true
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          repository: onsonr/sonr
          fetch-depth: 0
          fetch-tags: true
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - run: make test-race
  test-cover:
    runs-on: ubuntu-latest
    if: github.event_name == 'merge_group'
    name: Run Coverage Tests
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          repository: onsonr/sonr
          fetch-depth: 0
          fetch-tags: true
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - run: make test-cover
  validate-release:
    if: github.event_name == 'merge_group'
    runs-on: ubuntu-latest
    name: Verify Release Config
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          repository: onsonr/sonr
          fetch-depth: 0
          fetch-tags: true
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - name: Commitizen Dry Run
        uses: commitizen-tools/commitizen-action@master
        with:
          push: false
          dry_run: true
          github_token: ${{ secrets.GITHUB_TOKEN }}
          branch: main
      - name: Check GoReleaser Config
        uses: goreleaser/goreleaser-action@v6
        with:
          distribution: goreleaser
          version: latest
          args: check
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      - name: GoReleaser Dry Run
        uses: goreleaser/goreleaser-action@v6
        with:
          distribution: goreleaser
          version: latest
          args: release --snapshot --clean --skip=publish
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -1,19 +0,0 @@
 name: PR Labeler
 on:
  pull_request:
    types: [opened]
 permissions:
  contents: read
 jobs:
  pr-labeler:
    permissions:
      contents: read # for TimonVS/pr-labeler-action to read config file
      pull-requests: write # for TimonVS/pr-labeler-action to add labels in PR
    runs-on: ubuntu-latest
    steps:
      - uses: TimonVS/pr-labeler-action@v5
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}
          configuration-path: .github/pr-labeler.yml # optional, .github/pr-labeler.yml is the default value
@@ -0,0 +1,28 @@
 name: Bump Version on Merge
 on:
  pull_request:
    types: [closed]
 permissions:
  contents: write
  issues: write
 jobs:
  bump-version:
    if: github.event.pull_request.merged == true
    runs-on: ubuntu-latest
    steps:
      - name: Check out
        uses: actions/checkout@v3
        with:
          fetch-depth: 0
          ssh-key: "${{ secrets.COMMIT_KEY }}"
      - name: Create bump and changelog
        uses: commitizen-tools/commitizen-action@master
        with:
          push: false
      - name: Push using ssh
        run: |
          git push origin main --tags
@@ -1,96 +0,0 @@
 name: Upload Public Assets
 on:
  push:
    branches:
      - develop
 permissions:
  contents: write
  issues: write
 jobs:
  buf_push_core:
    name: Publish to buf.build/onsonr/sonr
    runs-on: ubuntu-latest
    steps:
      # Run `git checkout`
      - uses: actions/checkout@v3
      # Install the `buf` CLI
      - uses: bufbuild/buf-setup-action@v1
      # Push only the Input in `proto` to the BSR
      - uses: bufbuild/buf-push-action@v1
        continue-on-error: true
        with:
          input: proto
          buf_token: ${{ secrets.BUF_TOKEN }}
  buf_push_thirdparty:
    name: Publish to buf.build/onsonr/thirdparty
    runs-on: ubuntu-latest
    steps:
      # Run `git checkout`
      - uses: actions/checkout@v3
      # Install the `buf` CLI
      - uses: bufbuild/buf-setup-action@v1
      # Push only the Input in `proto` to the BSR
      - uses: bufbuild/buf-push-action@v1
        continue-on-error: true
        with:
          input: third_party/proto
          buf_token: ${{ secrets.BUF_TOKEN }}
  upload_motr_dwn:
    runs-on: ubuntu-latest
    name: Publish to configs.sonr.id
    steps:
      - name: checkout
        uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - name: Setup go-task / task / taskfile
        uses: rnorton5432/setup-task@v1
      - name: Build DWN WASM
        run: task dwn:build
      - name: Upload WASM to R2
        continue-on-error: true
        uses: ryand56/r2-upload-action@latest
        with:
          r2-account-id: ${{ secrets.R2_ACCOUNT_ID }}
          r2-access-key-id: ${{ secrets.R2_ACCESS_KEY_ID }}
          r2-secret-access-key: ${{ secrets.R2_SECRET_ACCESS_KEY }}
          r2-bucket: nebula
          source-dir: ./build/app.wasm
          destination-dir: wasm
      - name: Upload SW JS to R2
        continue-on-error: true
        uses: ryand56/r2-upload-action@latest
        with:
          r2-account-id: ${{ secrets.R2_ACCOUNT_ID }}
          r2-access-key-id: ${{ secrets.R2_ACCESS_KEY_ID }}
          r2-secret-access-key: ${{ secrets.R2_SECRET_ACCESS_KEY }}
          r2-bucket: nebula
          source-dir: ./pkg/motr/static/sw.js
          destination-dir: js
  upload_nebula_cdn:
    runs-on: ubuntu-latest
    name: Publish to cdn.sonr.id
    steps:
      - name: checkout
        uses: actions/checkout@v4
      - name: Upload to R2
        uses: ryand56/r2-upload-action@latest
        with:
          r2-account-id: ${{ secrets.R2_ACCOUNT_ID }}
          r2-access-key-id: ${{ secrets.R2_ACCESS_KEY_ID }}
          r2-secret-access-key: ${{ secrets.R2_SECRET_ACCESS_KEY }}
          r2-bucket: nebula
          source-dir: pkg/nebula/assets
          destination-dir: .
@@ -0,0 +1,24 @@
 name: Publish Assets on Release
 on:
  release:
    types: [published]
 permissions:
  contents: write
  issues: write
 jobs:
  buf_push:
    name: Publish to buf.build/onsonr/sonr
    runs-on: ubuntu-latest
    steps:
      # Run `git checkout`
      - uses: actions/checkout@v4
      # Install the `buf` CLI
      - uses: bufbuild/buf-setup-action@v1
      # Push only the Input in `proto` to the BSR
      - uses: bufbuild/buf-push-action@v1
        continue-on-error: true
        with:
          input: proto
          buf_token: ${{ secrets.BUF_TOKEN }}
@@ -1,17 +1,21 @@
-name: Scheduled Release
+name: Versioned Release
 on:
-  workflow_dispatch:
+  pull_request:
    types: [closed]
  push:
    tags:
      - v*
    branches:
      - main
 permissions:
  contents: write
 jobs:
-  goreleaser:
+  new-release:
-    name: Release motr, sonrd, and DWN
+    name: Run GoReleaser on New Tag
    if: startsWith(github.ref, 'refs/tags/')
    permissions: write-all
    runs-on: ubuntu-latest
    steps:
@@ -36,12 +40,11 @@ jobs:
      - name: Release
        uses: goreleaser/goreleaser-action@v6
        with:
-          distribution: goreleaser-pro
+          distribution: goreleaser
          version: latest
          args: release --clean
        env:
          GITHUB_TOKEN: ${{ secrets.GH_RELEASER_TOKEN }}
          GORELEASER_KEY: ${{ secrets.GORELEASER_KEY }}
          GITHUB_PERSONAL_AUTH_TOKEN: ${{ secrets.GH_RELEASER_TOKEN }}
          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
@@ -1,60 +0,0 @@
 name: Run Tests
 on:
  push:
    branches:
      - feature/*
 jobs:
  test-unit:
    runs-on: ubuntu-latest
    name: Run Unit Tests
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          repository: onsonr/sonr
          fetch-depth: 0
          fetch-tags: true
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - run: make test-unit
  test-race:
    runs-on: ubuntu-latest
    name: Run Race Tests
    continue-on-error: true
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          repository: onsonr/sonr
          fetch-depth: 0
          fetch-tags: true
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - run: make test-race
  test-cover:
    runs-on: ubuntu-latest
    name: Run Coverage Tests
    continue-on-error: true
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          repository: onsonr/sonr
          fetch-depth: 0
          fetch-tags: true
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - run: make test-cover
@@ -1,39 +0,0 @@
 name: Update Version
 on:
  push:
    branches:
      - master
 permissions:
  contents: write
  pull-requests: write
 jobs:
  run-tests:
    name: "Run tests"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: "1.23"
          check-latest: true
      - name: Run tests
        run: make test
  bump-version:
    needs: [run-tests]
    runs-on: ubuntu-latest
    name: "Bump Version"
    if: ${{ !startsWith(github.event.head_commit.message, 'bump:') }}
    steps:
      - uses: actions/checkout@v4
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          fetch-depth: 0
      - name: Create bump and changelog
        uses: commitizen-tools/commitizen-action@master
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          increment: "PATCH"
@@ -1,4 +1,5 @@
 # Binaries
 no
 .data
 schemas
 *.db
@@ -41,6 +42,7 @@ go.work.sum
 # Environment files
 .env
 **/*.env
 **/sonr.log
 # Terraform
@@ -59,6 +61,7 @@ override.tf.json
 .terraformrc
 terraform.rc
 flake.lock
 # Misc
 .DS_Store
@@ -84,6 +87,7 @@ buildenv*
 node_modules
 cmd/gateway/node_modules
 pkg/nebula/node_modules
 configs/logs.json
 mprocs.yaml
 build
@@ -93,4 +97,11 @@ sonr.wiki
 !buf.lock
 .air.toml
 mprocs.yaml
 mprocs.log
 tools-stamp
 sonr.log
 deploy/conf
 interchaintest-downloader
 .haptic
@@ -3,25 +3,166 @@ version: 2
 project_name: sonr
 builds:
  - id: motr
    main: ./cmd/motr
    binary: app
    goos:
      - js
    goarch:
      - wasm
  - id: sonr
    goos: [linux, darwin]
    goarch: [amd64, arm64]
    main: ./cmd/sonrd
    binary: sonrd
-    builder: go
+    mod_timestamp: "{{ .CommitTimestamp }}"
-    gobinary: go
+    goos:
-    command: build
+      - linux
      - darwin
    goarch:
      - amd64
      - arm64
    goamd64:
      - v1
    flags:
      - -mod=readonly
      - -trimpath
    ldflags:
-      - -s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}}
+      - -X github.com/cosmos/cosmos-sdk/version.Name=sonr
      - -X github.com/cosmos/cosmos-sdk/version.AppName=sonrd
      - -X github.com/cosmos/cosmos-sdk/version.Version={{.Version}}
      - -X github.com/cosmos/cosmos-sdk/version.Commit={{.Commit}}
      - -X "github.com/cosmos/cosmos-sdk/version.BuildTags=netgo,ledger"
    tags:
      - netgo
      - ledger
  - id: hway
    main: ./cmd/hway
    binary: hway
    goos:
      - linux
      - darwin
    goarch:
      - amd64
      - arm64
    mod_timestamp: "{{ .CommitTimestamp }}"
    flags:
      - -mod=readonly
      - -trimpath
    goamd64:
      - v1
    tags:
      - netgo
    ldflags:
      - -X main.version={{.Version}}
      - -X main.commit={{.Commit}}
      - -X main.date={{.Date}}
 archives:
  - id: sonr
    builds: [sonr]
-    name_template: '{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}{{ with .Arm }}v{{ . }}{{ end }}{{ with .Mips }}_{{ . }}{{ end }}{{ if not (eq .Amd64 "v1") }}{{ .Amd64 }}{{ end }}'
+    name_template: >-
      sonr_{{ .Version }}_
      {{- title .Os }}_{{- if eq .Arch "amd64" }}x86_64
      {{- else if eq .Arch "386" }}i386
      {{- else }}{{ .Arch }}{{ end }}
    format: tar.gz
    files:
      - src: README*
-      - src: CHANGELOG*
+    wrap_in_directory: true
  - id: hway
    builds: [hway]
    name_template: >-
      hway_{{ .Version }}_
      {{- title .Os }}_{{- if eq .Arch "amd64" }}x86_64
      {{- else if eq .Arch "386" }}i386
      {{- else }}{{ .Arch }}{{ end }}
    format: tar.gz
    files:
      - src: README*
    wrap_in_directory: true
 nfpms:
  - id: hway
    package_name: hway
    file_name_template: "{{ .ConventionalFileName }}"
    builds: [hway]
    vendor: Sonr
    homepage: "https://onsonr.dev"
    maintainer: "Sonr <support@onsonr.dev>"
    description: "Sonr Highway is a decentralized, permissionless, and censorship-resistant identity network proxy."
    license: "Apache 2.0"
    formats:
      - rpm
      - deb
      - apk
    dependencies:
      - ipfs
    contents:
      - src: README*
        dst: /usr/share/doc/hway
    bindir: /usr/bin
    section: net
    priority: optional
    # Add these lines to match build config
  - id: sonr
    package_name: sonrd
    file_name_template: "{{ .ConventionalFileName }}"
    builds: [sonr]
    vendor: Sonr
    homepage: "https://onsonr.dev"
    maintainer: "Sonr <support@onsonr.dev>"
    description: "Sonr is a decentralized, permissionless, and censorship-resistant identity network."
    license: "Apache 2.0"
    formats:
      - rpm
      - deb
      - apk
    dependencies:
      - ipfs
    contents:
      - src: README*
        dst: /usr/share/doc/sonrd
    bindir: /usr/bin
    section: net
    priority: optional
    # Add these lines to match build config
 brews:
  - name: hway
    ids: [hway]
    commit_author:
      name: goreleaserbot
      email: bot@goreleaser.com
    directory: Formula
    caveats: "Run a local hway node and access it with the hway proxy"
    homepage: "https://onsonr.dev"
    description: "Sonr is a decentralized, permissionless, and censorship-resistant identity network."
    dependencies:
      - name: ipfs
    repository:
      owner: onsonr
      name: homebrew-tap
      branch: master
      token: "{{ .Env.GITHUB_PERSONAL_AUTH_TOKEN }}"
  - name: sonr
    ids: [sonr]
    commit_author:
      name: goreleaserbot
      email: bot@goreleaser.com
    directory: Formula
    caveats: "Run a local sonr node and access it with the hway proxy"
    homepage: "https://onsonr.dev"
    description: "Sonr is a decentralized, permissionless, and censorship-resistant identity network."
    dependencies:
      - name: ipfs
    repository:
      owner: onsonr
      name: homebrew-tap
      branch: master
      token: "{{ .Env.GITHUB_PERSONAL_AUTH_TOKEN }}"
 release:
  github:
@@ -32,27 +173,7 @@ release:
  replace_existing_draft: true
  replace_existing_artifacts: true
  extra_files:
    - glob: ./CHANGELOG*
    - glob: ./README*
    - glob: ./LICENSE*
 brews:
  - name: sonr
    ids: [sonr]
    commit_author:
      name: goreleaserbot
      email: bot@goreleaser.com
    directory: Formula
    caveats: "Run a local sonr node and access it with the hway proxy"
    homepage: "https://sonr.io/"
    description: "Sonr is a decentralized, permissionless, and censorship-resistant identity network."
    dependencies:
      - name: ipfs
    repository:
      owner: onsonr
      name: homebrew-tap
      branch: master
      token: "{{ .Env.GITHUB_PERSONAL_AUTH_TOKEN }}"
 announce:
  telegram:
@@ -0,0 +1,34 @@
 version: "3"
 vars:
  GOPATH:
    sh: go env GOPATH
  BIN_DIR: "{{.GOPATH}}/bin"
  BINARY: "{{.BIN_DIR}}/hway"
  OS:
    sh: uname -s
  ARCH:
    sh: uname -m
 tasks:
  build:
    desc: Build the hway binary
    silent: true
    cmds:
      - templ generate
      - sqlc generate -f internal/database/sqlc.yaml
      - gum spin --spinner dot --title "Build Hway Single Target ({{.OS}}/{{.ARCH}})..." -- goreleaser build --snapshot --clean --single-target --id hway -o {{.BIN_DIR}}/hway
  install:
    desc: Install the hway binary
    silent: true
    cmds:
      - templ generate
      - sqlc generate -f internal/database/sqlc.yaml
      - gum spin --spinner dot --title "Install Hway Single Target ({{.OS}}/{{.ARCH}})..." -- make install-hway
  start:
    desc: Start the hway daemon
    silent: true
    cmds:
      - "{{.BINARY}}"
@@ -0,0 +1,50 @@
 version: "3"
 vars:
  ROOT:
    sh: git rev-parse --show-toplevel
 tasks:
  init:
    desc: Setup ipfs with Cloudflare
    silent: true
    vars:
      PEERS: |
        '[
          {"ID": "QmcFf2FH3CEgTNHeMRGhN7HNHU1EXAxoEk6EFuSyXCsvRE", "Addrs": ["/dnsaddr/node-1.ingress.cloudflare-ipfs.com"]},
          {"ID": "QmcFmLd5ySfk2WZuJ1mfSWLDjdmHZq7rSAua4GoeSQfs1z", "Addrs": ["/dnsaddr/node-2.ingress.cloudflare-ipfs.com"]},
          {"ID": "QmcfFmzSDVbwexQ9Au2pt5YEXHK5xajwgaU6PpkbLWerMa", "Addrs": ["/dnsaddr/node-3.ingress.cloudflare-ipfs.com"]},
          {"ID": "QmcfJeB3Js1FG7T8YaZATEiaHqNKVdQfybYYkbT1knUswx", "Addrs": ["/dnsaddr/node-4.ingress.cloudflare-ipfs.com"]},
          {"ID": "QmcfVvzK4tMdFmpJjEKDUoqRgP4W9FnmJoziYX5GXJJ8eZ", "Addrs": ["/dnsaddr/node-5.ingress.cloudflare-ipfs.com"]},
          {"ID": "QmcfZD3VKrUxyP9BbyUnZDpbqDnT7cQ4WjPP8TRLXaoE7G", "Addrs": ["/dnsaddr/node-6.ingress.cloudflare-ipfs.com"]},
          {"ID": "QmcfZP2LuW4jxviTeG8fi28qjnZScACb8PEgHAc17ZEri3", "Addrs": ["/dnsaddr/node-7.ingress.cloudflare-ipfs.com"]},
          {"ID": "QmcfgsJsMtx6qJb74akCw1M24X1zFwgGo11h1cuhwQjtJP", "Addrs": ["/dnsaddr/node-8.ingress.cloudflare-ipfs.com"]},
          {"ID": "Qmcfr2FC7pFzJbTSDfYaSy1J8Uuy8ccGLeLyqJCKJvTHMi", "Addrs": ["/dnsaddr/node-9.ingress.cloudflare-ipfs.com"]},
          {"ID": "QmcfR3V5YAtHBzxVACWCzXTt26SyEkxdwhGJ6875A8BuWx", "Addrs": ["/dnsaddr/node-10.ingress.cloudflare-ipfs.com"]},
          {"ID": "Qmcfuo1TM9uUiJp6dTbm915Rf1aTqm3a3dnmCdDQLHgvL5", "Addrs": ["/dnsaddr/node-11.ingress.cloudflare-ipfs.com"]},
          {"ID": "QmcfV2sg9zaq7UUHVCGuSvT2M2rnLBAPsiE79vVyK3Cuev", "Addrs": ["/dnsaddr/node-12.ingress.cloudflare-ipfs.com"]}
        ]'
    cmds:
      - rm -rf ~/.ipfs
      - ipfs init
      - ipfs config --json Peering.Peers {{.PEERS}}
      - ipfs config --json API.HTTPHeaders.Access-Control-Allow-Origin '["*"]'
  mount:
    desc: Mount the ipfs,ipns directories
    silent: true
    platforms:
      - linux
    cmds:
      - ipfs config --json Mounts.FuseAllowOther true
  start:
    desc: Start the ipfs daemon
    silent: true
    cmds:
      - cmd: ipfs daemon --migrate
        platforms:
          - darwin
      - task: mount
      - cmd: ipfs daemon --mount
        platforms:
          - linux
@@ -0,0 +1,32 @@
 version: "3"
 vars:
  GOPATH:
    sh: go env GOPATH
  BIN_DIR: "{{.GOPATH}}/bin"
  OS:
    sh: uname -s
  ARCH:
    sh: uname -m
 tasks:
  init:
    desc: Initialize postgresql
    silent: true
    dir: deploy/apps/chainindex
    cmds:
      - cmd: sudo -u postgres psql -f seed.sql
        platforms:
          - linux
      - cmd: sudo -u postgres psql -d chainindex -f schema.sql
        platforms:
          - linux
  reset:
    desc: Reset postgresql
    silent: true
    dir: deploy/apps/chainindex
    cmds:
      - cmd: sudo -u postgres psql -d chainindex -f reset.sql
        platforms:
          - linux
@@ -0,0 +1,44 @@
 version: "3"
 vars:
  BINARY: sonrd
  BUILD_FLAGS: -mod=readonly -trimpath
  BUILD_TAGS: netgo,ledger
  COMMIT:
    sh: git rev-parse HEAD
  VERSION:
    sh: git describe --tags --always
 tasks:
  build:
    desc: Build the sonrd binary
    cmds:
      - >
        go build 
        {{.BUILD_FLAGS}}
        -tags "{{.BUILD_TAGS}}"
        -ldflags "
        -X github.com/cosmos/cosmos-sdk/version.Name=sonr
        -X github.com/cosmos/cosmos-sdk/version.AppName=sonrd
        -X github.com/cosmos/cosmos-sdk/version.Version={{.VERSION}}
        -X github.com/cosmos/cosmos-sdk/version.Commit={{.COMMIT}}
        -X github.com/cosmos/cosmos-sdk/version.BuildTags={{.BUILD_TAGS}}
        "
        -o ./build/{{.BINARY}}
        ./cmd/sonrd
    env:
      CGO_ENABLED: 1
      GOARCH:
        sh: go env GOARCH
      GOOS:
        sh: go env GOOS
  install:
    desc: Install sonrd
    silent: true
    cmds:
      - gum spin --spinner dot --title "Installing sonr daemon..." -- make install
  start:
    desc: Start the sonr node
    cmds:
      - sh scripts/test_dop_node.sh
@@ -0,0 +1,23 @@
 version: "3"
 vars:
  ROOT:
    sh: git rev-parse --show-toplevel
 tasks:
  init:
    desc: Configure synapse homeserver with PKL
    silent: true
    cmds: 
      - pkl eval pkl/matrix.net/Homeserver.pkl -f yaml -o deploy/conf/synapse/homeserver.yaml
    env:
      MATRIX_CLIENT_NAME: sonr.id
      MATRIX_SERVER_NAME: sonr.id
      MATRIX_SERVER_URL: http://localhost:8008
      MATRIX_SLIDING_SYNC_PROXY: http://localhost:8008
      MATRIX_PSQL_CONN: postgresql://matrixhs_user:matrixhs_password123@localhost:5432/sonr
      MATRIX_REGISTRATION_SHARED_SECRET: secret
      MATRIX_ENABLE_RECATCHA: false
      MATRIX_RECATCHA_PUBLIC_KEY: ""
      MATRIX_RECATCHA_PRIVATE_KEY: ""
      MATRIX_RECATCHA_BYPASS_SECRET: ""
@@ -0,0 +1,12 @@
 version: "3"
 vars:
  ROOT:
    sh: git rev-parse --show-toplevel
 tasks:
  init:
    desc: Configure tigerbeetle database
    silent: true
    cmds: 
      - pkl eval pkl/matrix.net/Homeserver.pkl -f yaml -o deploy/conf/synapse/homeserver.yaml
@@ -1,3 +1,161 @@
 ## v0.6.0 (2024-12-24)
 ### Feat
 - Add option to create draft issues from the new-issue script
 ### Refactor
 - rename DID, DWN, and SVC modules to core-dids, core-dwns, and core-svcs respectively
 - rename MsgInitialize to MsgSpawn for clarity
 - rename scopes in .github/scopes.json for better clarity
 ## v0.5.28 (2024-12-22)
 ### Fix
 - Sink
 ### Refactor
 - update testnet configuration
 - optimize GitHub Actions workflow triggers (#1204)
 - Move embed
 ## v0.5.27 (2024-12-16)
 ## v0.5.26 (2024-12-13)
 ## v0.5.25 (2024-12-11)
 ### Feat
 - enable GoReleaser releases on tags and snapshots
 - automate release on tag and workflow dispatch
 ### Fix
 - Correct regular expression for version tags in release workflow
 ## v0.5.24 (2024-12-11)
 ### Feat
 - prevent duplicate releases
 ## v0.5.23 (2024-12-11)
 ### Refactor
 - rename scheduled release workflow to versioned release
 - remove changelog from release artifacts
 ## v0.5.22 (2024-12-11)
 ### Feat
 - Implement passkey-based authentication and registration flow
 - allow manual triggering of deployment workflow
 - add start-tui command for interactive mode
 - add coin selection and update passkey input in registration form
 - add hway command for Sonr DID gateway
 - Conditionally install process-compose only if binary not found
 - Add process-compose support with custom start and down commands
 - implement passkey registration flow
 - Improve createProfile form layout with wider max-width and enhanced spacing
 - improve index page UI with new navigation buttons and remove redundant settings buttons
 - Make input rows responsive with grid layout for mobile and desktop
 - enhance index page with additional settings buttons and style adjustments
 - implement passkey-based authentication
 - add support for Cloudsmith releases
 - add go dependency and enhance devbox environment variables
 - update create profile form placeholders and handle
 - add DID-based authentication middleware
 - Add validation for human verification slider sum in CreateProfile form
 - implement passkey registration flow
 - Update WebAuthn credential handling with modern browser standards
 - Streamline passkey registration with automatic form submission
 - Add credential parsing and logging in register finish handler
 - Add credential details row with icon after passkey creation
 - Add form validation for passkey credential input
 - implement passkey registration flow
 - Add hidden input to store passkey credential data for form submission
 - add CI workflow for deploying network
 - add hway binary support and Homebrew formula
 - remove username from passkey creation
 - implement passkey registration flow
 - add passkey creation functionality
 - add CNAME for onsonr.dev domain
 ### Fix
 - use Unix domain sockets for devnet processes
 - correct workflow name and improve devnet deployment process
 - correct title of profile creation page
 - rename devbox start script to up and remove stop script
 - Consolidate archive configuration and add LICENSE file
 - Improve cross-browser passkey credential handling and encoding
 - Remove commented-out code in passkey registration script
 - remove line-clamp from tailwind config
 - remove unnecessary background and restart settings from process-compose.yaml
 - suppress process-compose server output and log to file
 ### Refactor
 - remove unnecessary git fetch step in deploy workflow
 - remove obsolete interchain test dependencies
 - update index views to use new nebula components
 - move Wasm related code to pkg/common/wasm
 - migrate config package to pkg directory
 - migrate to new configuration system and model definitions
 - move session package to pkg directory
 - Refactor registration forms to use UI components
 - move gateway config to vault package
 - improve command line flag descriptions and variable names
 - refactor hway command to use echo framework for server
 - Update root command to load EnvImpl from cobra flags
 - Modify command flags and environment loading logic in cmds.go
 - improve build process and move process-compose.yaml
 - remove unused devbox.json and related configurations
 - Improve mobile layout responsiveness for Rows and Columns components
 - Remove max-w-fit from Rows component
 - replace session package with context package
 - rename database initialization function
 - move session management to dedicated database module
 - remove unused UI components related to wallet and index pages
 - consolidate handlers into single files
 - move gateway and vault packages to internal directory
 - Move registration form components to dedicated directory
 - remove unused devbox package
 - remove devbox configuration
 - move vault package to app directory
 - improve code structure within gateway package
 - move gateway package to app directory
 - move vault package internal components to root
 - migrate layout imports to common styles package
 - Move form templates and styles to common directory
 - consolidate authentication and DID handling logic
 - Improve WebAuthn credential handling and validation in register finish route
 - remove profile card component
 - Simplify passkey registration UI and move profile component inline
 - Update credential logging with transport and ID type
 - Update register handler to use protocol.CredentialDescriptor struct
 - Update credential handling to use protocol.CredentialDescriptor
 - improve profile card styling and functionality
 - Simplify session management and browser information extraction
 - Update PeerInfo to extract and store comprehensive device information
 - improve address display in property details
 - remove unused documentation generation script
 - replace sonr/pkg/styles/layout with nebula/ui/layout
 - migrate UI components to nebula module
 - improve scopes.json structure and update scripts for better usability
 ## v0.5.20 (2024-12-07)
 ### Refactor
 - simplify CI workflow by removing redundant asset publishing steps
 ## v0.5.19 (2024-12-06)
 ### Feat
@@ -59,7 +217,6 @@
 - update file paths in error messages
 - update intro video modal script
 - include assets generation in wasm build
 ### Refactor
@@ -73,6 +230,10 @@
 ## v0.5.16 (2024-10-21)
 ### Fix
 - include assets generation in wasm build
 ## v0.5.15 (2024-10-21)
 ## v0.5.14 (2024-10-21)
@@ -206,7 +367,6 @@
 - update issue templates for better clarity
 - add issue templates for tracking and task issues
 - add issue templates for bug report and tracking
 - introduce docker-compose based setup
 ### Refactor
@@ -217,6 +377,7 @@
 ### Feat
 - introduce docker-compose based setup
 - add hway and sonr processes to dev environment
 ## v0.5.5 (2024-10-03)
@@ -265,14 +426,6 @@
 ## v0.4.5 (2024-10-02)
 ### Fix
 - use correct secret for docker login
 ## v0.4.4 (2024-10-02)
 ## v0.4.3 (2024-10-02)
 ### Feat
 - **release**: add docker images for sonrd and motr
@@ -284,6 +437,7 @@
 ### Fix
 - use correct secret for docker login
 - **layout**: add missing favicon
 - **hero**: Use hx-swap for primary button to prevent flicker
@@ -312,9 +466,6 @@
 - add DWN resolver field
 - add stats section to homepage
 - implement hero section using Pkl
 - add PKL schema for message formats
 - add Homebrew tap for sonr
 - update release workflow to use latest tag
 ### Fix
@@ -324,7 +475,7 @@
 - **cta**: Fix typo in CTA title
 - change bento section title to reflect security focus
 - adjust hero image dimensions
- **Input**: Change type from to
+- **Input**: Change  type from  to
 - update hero image height in config.pkl
 ### Refactor
@@ -333,13 +484,14 @@
 - rename motrd to motr
 - update hero image dimensions
 - move nebula configuration to static file
 - rename buf-publish.yml to publish-assets.yml
 - remove unused field from
 ## v0.4.0 (2024-09-30)
 ### Feat
 - add PKL schema for message formats
 - add Homebrew tap for sonr
 - update release workflow to use latest tag
 - **dwn**: add wasm build for dwn
 - add macaroon and oracle genesis states
 - add scheduled binary release workflow
@@ -354,6 +506,8 @@
 ### Refactor
 - remove old changelog entries
 - rename buf-publish.yml to publish-assets.yml
 - remove unused  field from
 - remove unnecessary checkout in scheduled-release workflow
 - rename build ID to sonr
 - remove unnecessary release existence check
@@ -472,7 +626,7 @@
 - extract root command creation to separate file
 - move ipfs setup to function
 - remove unnecessary proxy config
- rename script to
+- rename  script to
 - move DWN proxy server logic to separate file
 - use htmx instead of dwn for vault client
 - remove unused environment variables
@@ -480,7 +634,7 @@
 - use staking keeper in DID keeper
 - remove unused dependencies
 - remove unused image building workflow
- add field to
+- add  field to
 - Update KeyKind Enum to have proper naming conventions
 - Update `DIDNamespace` to have proper naming convention
 - expose ports directly in docker-compose
@@ -1,40 +1,3 @@
 FROM jetpackio/devbox:latest AS sonrvm
 # Installing your devbox project
 WORKDIR /code
 USER root:root
 RUN mkdir -p /code && chown ${DEVBOX_USER}:${DEVBOX_USER} /code
 USER ${DEVBOX_USER}:${DEVBOX_USER}
 COPY --chown=${DEVBOX_USER}:${DEVBOX_USER} devbox.json devbox.json
 COPY --chown=${DEVBOX_USER}:${DEVBOX_USER} process-compose.yaml process-compose.yaml
 RUN devbox run -- echo "Installed Packages."
 ENTRYPOINT ["devbox", "run"]
 # --------------------------------------------------------
 FROM jetpackio/devbox:latest AS sonr-runner
 WORKDIR /code
 USER root:root
 RUN mkdir -p /code && chown ${DEVBOX_USER}:${DEVBOX_USER} /code
 USER ${DEVBOX_USER}:${DEVBOX_USER}
 COPY --chown=${DEVBOX_USER}:${DEVBOX_USER} devbox.json devbox.json
 COPY --chown=${DEVBOX_USER}:${DEVBOX_USER} process-compose.yaml process-compose.yaml
 COPY --chown=${DEVBOX_USER}:${DEVBOX_USER} . .
 RUN devbox run -- echo "Installed Packages."
 RUN git config --global --add safe.directory /code
 ENTRYPOINT ["devbox", "run", "testnet"]
 # --------------------------------------------------------
 FROM golang:1.22-alpine AS go-builder
 SHELL ["/bin/sh", "-ecuxo", "pipefail"]
@@ -8,9 +8,14 @@ SDK_PACK := $(shell go list -m github.com/cosmos/cosmos-sdk | sed  's/ /\@/g')
 BINDIR ?= $(GOPATH)/bin
 SIMAPP = ./app
 PC_PORT_NUM=42069
 PC_LOG_FILE=./sonr.log
 PC_SOCKET_PATH=/tmp/sonr-net.sock
 # for dockerized protobuf tools
 DOCKER := $(shell which docker)
 HTTPS_GIT := github.com/onsonr/sonr.git
 PROCESS_COMPOSE := $(shell which process-compose)
 export GO111MODULE = on
@@ -70,8 +75,6 @@ ldflags := $(strip $(ldflags))
 BUILD_FLAGS := -tags "$(build_tags_comma_sep)" -ldflags '$(ldflags)' -trimpath
 # The below include contains the tools and runsim targets.
 include contrib/devtools/Makefile
 all: install lint test
 build: go.sum
@@ -82,6 +85,12 @@ else
 	go build -mod=readonly $(BUILD_FLAGS) -o build/sonrd ./cmd/sonrd
 endif
 build-motr: go.sum
 	GOOS=js GOARCH=wasm go build -o static/wasm/app.wasm ./cmd/motr/main.go
 build-hway: go.sum
 	go build -o build/hway ./cmd/hway
 build-windows-client: go.sum
 	GOOS=windows GOARCH=amd64 go build -mod=readonly $(BUILD_FLAGS) -o build/sonrd.exe ./cmd/sonrd
@@ -95,6 +104,9 @@ endif
 install: go.sum
 	go install -mod=readonly $(BUILD_FLAGS) ./cmd/sonrd
 install-hway: go.sum
 	go install -mod=readonly ./cmd/hway
 ########################################
 ### Tools & dependencies
@@ -115,13 +127,17 @@ clean:
 	rm -rf .aider*
 	rm -rf static
 	rm -rf .out
 	rm -rf build
 	rm -rf hway.db
 	rm -rf snapcraft-local.yaml build/
 	rm -rf build
 distclean: clean
 	rm -rf vendor/
 init-env:
 	@echo "Installing process-compose"
 	sh scripts/init_env.sh
 ########################################
 ### Testing
@@ -175,7 +191,6 @@ format: format-tools
 mod-tidy:
 	go mod tidy
 	cd interchaintest && go mod tidy
 .PHONY: format-tools lint format mod-tidy
@@ -293,55 +308,11 @@ testnet-basic: setup-testnet
 sh-testnet: mod-tidy
 	CHAIN_ID="sonr-testnet-1" BLOCK_TIME="1000ms" CLEAN=true sh scripts/test_node.sh
-.PHONY: setup-testnet set-testnet-configs testnet testnet-basic sh-testnet
+.PHONY: setup-testnet set-testnet-configs testnet testnet-basic sh-testnet dop-testnet
 ###############################################################################
 ###                                generation                               ###
 ###############################################################################
 .PHONY: pkl-gen tailwind-gen templ-gen
 pkl-gen:
 	go install github.com/apple/pkl-go/cmd/pkl-gen-go@latest
 	pkl-gen-go pkl/sonr.motr/ATN.pkl
 	pkl-gen-go pkl/sonr.hway/Env.pkl
 	pkl-gen-go pkl/sonr.motr/DWN.pkl
 	pkl-gen-go pkl/sonr.hway/ORM.pkl
 templ-gen:
 	@go install github.com/a-h/templ/cmd/templ@latest
 	templ generate
 ###############################################################################
 ###                             custom builds                               ###
 ###############################################################################
 .PHONY: motr-build hway-build hway-serve
 motr-build:
 	GOOS=js GOARCH=wasm go build -o static/wasm/app.wasm ./cmd/motr/main.go
 hway-build: templ-gen
 	go build -o build/hway ./cmd/hway/main.go
 hway-serve: hway-build
 	./build/hway
 ###############################################################################
 ###                                     help                                ###
 ###############################################################################
 .PHONY: deploy-buf deploy-pkl
 deploy-buf:
 	cd ./proto && bunx buf dep update && bunx buf build && bunx buf push
 deploy-pkl: 
 	sh ./.github/scripts/upload_cdn.sh
 ###############################################################################
 ###                                     help                                ###
 ###############################################################################
 help:
 	@echo "Usage: make <target>"
@@ -354,7 +325,5 @@ help:
 	@echo "  sh-testnet          : Shell local devnet"
 	@echo "  ictest-basic        : Basic end-to-end test"
 	@echo "  ictest-ibc          : IBC end-to-end test"
 	@echo "  templ               : Generate templ files"
 	@echo "  vault               : Build vault.wasm"
 .PHONY: help
@@ -37,4 +37,3 @@ Sonr would not have been possible without the direct and indirect support of the
 - [Forum](https://github.com/onsonr/sonr/discussions)
 - [Issues](https://github.com/onsonr/sonr/issues)
 - [Twitter](https://sonr.io/twitter)
 - [Dev Chat](https://sonr.io/discord)
@@ -0,0 +1,144 @@
 version: "3"
 vars:
  VERSION:
    sh: git describe --tags --abbrev=0
  COMMIT:
    sh: git rev-parse --short HEAD
  ROOT:
    sh: git rev-parse --show-toplevel
  OS:
    sh: uname -s
  TASKS:
    sh: task -l
  DOPPLER_TOKEN:
    sh: skate get DOPPLER_NETWORK
 includes:
  hway:
    taskfile: .taskfiles/Hway.yml
  ipfs:
    taskfile: .taskfiles/IPFS.yml
  postgres:
    taskfile: .taskfiles/Postgres.yml
  sonrd:
    taskfile: .taskfiles/Sonrd.yml
  synapse:
    taskfile: .taskfiles/Synapse.yml
  tigerbeetle:
    taskfile: .taskfiles/TigerBeetle.yml
 tasks:
  default:
    cmds:
      - gh run ls -L 3
      - gum format -- "# Sonr ({{.OS}}-{{.VERSION}})" " - ({{.COMMIT}}) {{.ROOT}}"
      - task -l -j | jq -r '.tasks[].name' | fzf --height=16 | xargs task
    silent: true
  deps:
    desc: Install go dependencies
    silent: true
    vars:
      DEPS:
        [
          "github.com/apple/pkl-go/cmd/pkl-gen-go@latest",
          "github.com/sqlc-dev/sqlc/cmd/sqlc@latest",
          "github.com/goreleaser/goreleaser/v2@latest",
          "github.com/a-h/templ/cmd/templ@latest",
        ]
    cmds:
      - for: { var: DEPS }
        cmd: gum spin --spinner dot --title "Installing go dependencies..." -- go install {{.ITEM}}
  new-issue:
    desc: Create a new issue
    silent: true
    dir: .github/scripts
    cmds:
      - sh new_issue.sh
  pkl-gen:
    desc: Generate PKL files
    silent: true
    dir: "pkl/sonr.net"
    vars:
      FILES: ["Hway.pkl", "Motr.pkl", "UCAN.pkl"]
    cmds:
      - for: { var: FILES }
        cmd: gum spin --spinner dot --title "Generating PKL in Go..." -- pkl-gen-go {{.ITEM}}
  proto-gen:
    desc: Generate proto files
    silent: true
    cmd: gum spin --spinner dot --title "Generating Protobufs..." -- make proto-gen
  sqlc-gen:
    desc: Generate SQLC files
    silent: true
    cmds:
      - gum spin --spinner dot --title "Generating SQLC..." -- sqlc generate -f internal/database/sqlc.yaml
  templ-gen:
    desc: Generate templ files
    silent: true
    cmd: gum spin --spinner dot --title "Generating Templ..." -- templ generate
  start:
    desc: Start the Network
    silent: true
    cmds:
      - task: postgres:reset
      - task: ipfs:init
      - task: ipfs:mount
      - task: sonrd:install
      - task: hway:build
      - task: procs-up
  status:
    desc: Check the status of the Network
    silent: true
    cmds:
      - task: procs-attach
  stop:
    desc: Stop the Network
    silent: true
    cmds:
      - task: procs-down
  procs-up:
    internal: true
    dir: "deploy"
    cmds:
      - cmd: process-compose up
        platforms:
          - darwin
      - cmd: process-compose up --use-uds --unix-socket /tmp/sonr-network.sock -D
        platforms:
          - linux
  procs-down:
    internal: true
    dir: "deploy"
    cmds:
      - cmd: process-compose down
        platforms:
          - darwin
      - cmd: process-compose down --use-uds --unix-socket /tmp/sonr-network.sock
        platforms:
          - linux
  procs-attach:
    internal: true
    dir: "deploy"
    cmds:
      - cmd: process-compose attach --use-uds --unix-socket /tmp/sonr-network.sock
        platforms:
          - linux
      - cmd: process-compose attach
        platforms:
          - darwin
@@ -20,9 +20,7 @@ const _ = grpc.SupportPackageIsVersion9
 const (
 	Query_Params_FullMethodName   = "/dwn.v1.Query/Params"
 	Query_Schema_FullMethodName   = "/dwn.v1.Query/Schema"
 	Query_Allocate_FullMethodName = "/dwn.v1.Query/Allocate"
 	Query_Sync_FullMethodName     = "/dwn.v1.Query/Sync"
 )
 // QueryClient is the client API for Query service.
@@ -33,15 +31,9 @@ const (
 type QueryClient interface {
 	// Params queries all parameters of the module.
 	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
 	// Schema queries the DID document by its id. And returns the required PKL
 	// information
 	Schema(ctx context.Context, in *QuerySchemaRequest, opts ...grpc.CallOption) (*QuerySchemaResponse, error)
 	// Allocate initializes a Target Vault available for claims with a compatible
 	// Authentication mechanism. The default authentication mechanism is WebAuthn.
 	Allocate(ctx context.Context, in *QueryAllocateRequest, opts ...grpc.CallOption) (*QueryAllocateResponse, error)
 	// Sync queries the DID document by its id. And returns the required PKL
 	// information
 	Sync(ctx context.Context, in *QuerySyncRequest, opts ...grpc.CallOption) (*QuerySyncResponse, error)
 }
 type queryClient struct {
@@ -62,16 +54,6 @@ func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts .
 	return out, nil
 }
 func (c *queryClient) Schema(ctx context.Context, in *QuerySchemaRequest, opts ...grpc.CallOption) (*QuerySchemaResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(QuerySchemaResponse)
 	err := c.cc.Invoke(ctx, Query_Schema_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *queryClient) Allocate(ctx context.Context, in *QueryAllocateRequest, opts ...grpc.CallOption) (*QueryAllocateResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(QueryAllocateResponse)
@@ -82,16 +64,6 @@ func (c *queryClient) Allocate(ctx context.Context, in *QueryAllocateRequest, op
 	return out, nil
 }
 func (c *queryClient) Sync(ctx context.Context, in *QuerySyncRequest, opts ...grpc.CallOption) (*QuerySyncResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(QuerySyncResponse)
 	err := c.cc.Invoke(ctx, Query_Sync_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 // QueryServer is the server API for Query service.
 // All implementations must embed UnimplementedQueryServer
 // for forward compatibility.
@@ -100,15 +72,9 @@ func (c *queryClient) Sync(ctx context.Context, in *QuerySyncRequest, opts ...gr
 type QueryServer interface {
 	// Params queries all parameters of the module.
 	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
 	// Schema queries the DID document by its id. And returns the required PKL
 	// information
 	Schema(context.Context, *QuerySchemaRequest) (*QuerySchemaResponse, error)
 	// Allocate initializes a Target Vault available for claims with a compatible
 	// Authentication mechanism. The default authentication mechanism is WebAuthn.
 	Allocate(context.Context, *QueryAllocateRequest) (*QueryAllocateResponse, error)
 	// Sync queries the DID document by its id. And returns the required PKL
 	// information
 	Sync(context.Context, *QuerySyncRequest) (*QuerySyncResponse, error)
 	mustEmbedUnimplementedQueryServer()
 }
@@ -122,15 +88,9 @@ type UnimplementedQueryServer struct{}
 func (UnimplementedQueryServer) Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
 }
 func (UnimplementedQueryServer) Schema(context.Context, *QuerySchemaRequest) (*QuerySchemaResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Schema not implemented")
 }
 func (UnimplementedQueryServer) Allocate(context.Context, *QueryAllocateRequest) (*QueryAllocateResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Allocate not implemented")
 }
 func (UnimplementedQueryServer) Sync(context.Context, *QuerySyncRequest) (*QuerySyncResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Sync not implemented")
 }
 func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}
 func (UnimplementedQueryServer) testEmbeddedByValue()               {}
@@ -170,24 +130,6 @@ func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interf
 	return interceptor(ctx, in, info, handler)
 }
 func _Query_Schema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QuerySchemaRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(QueryServer).Schema(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: Query_Schema_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(QueryServer).Schema(ctx, req.(*QuerySchemaRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _Query_Allocate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryAllocateRequest)
 	if err := dec(in); err != nil {
@@ -206,24 +148,6 @@ func _Query_Allocate_Handler(srv interface{}, ctx context.Context, dec func(inte
 	return interceptor(ctx, in, info, handler)
 }
 func _Query_Sync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QuerySyncRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(QueryServer).Sync(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: Query_Sync_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(QueryServer).Sync(ctx, req.(*QuerySyncRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 // Query_ServiceDesc is the grpc.ServiceDesc for Query service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -235,18 +159,10 @@ var Query_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Params",
 			Handler:    _Query_Params_Handler,
 		},
 		{
 			MethodName: "Schema",
 			Handler:    _Query_Schema_Handler,
 		},
 		{
 			MethodName: "Allocate",
 			Handler:    _Query_Allocate_Handler,
 		},
 		{
 			MethodName: "Sync",
 			Handler:    _Query_Sync_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "dwn/v1/query.proto",
@@ -1818,7 +1818,7 @@ func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
 	return file_dwn_v1_tx_proto_rawDescGZIP(), []int{1}
 }
-// MsgInitialize spawns a New Vault with Unclaimed State. This is a one-time
+// MsgSpawn spawns a New Vault with Unclaimed State. This is a one-time
 // operation that must be performed interacting with the Vault.
 //
 // Since: cosmos-sdk 0.47
@@ -1869,8 +1869,8 @@ func (x *MsgInitialize) GetParams() *Params {
 	return nil
 }
-// MsgInitializeResponse defines the response structure for executing a
+// MsgSpawnResponse defines the response structure for executing a
-// MsgInitialize message.
+// MsgSpawn message.
 //
 // Since: cosmos-sdk 0.47
 type MsgInitializeResponse struct {
@@ -33,7 +33,7 @@ type MsgClient interface {
 	//
 	// Since: cosmos-sdk 0.47
 	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
-	// Initialize spawns a new Vault
+	// Spawn spawns a new Vault
 	Initialize(ctx context.Context, in *MsgInitialize, opts ...grpc.CallOption) (*MsgInitializeResponse, error)
 }
@@ -75,7 +75,7 @@ type MsgServer interface {
 	//
 	// Since: cosmos-sdk 0.47
 	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
-	// Initialize spawns a new Vault
+	// Spawn spawns a new Vault
 	Initialize(context.Context, *MsgInitialize) (*MsgInitializeResponse, error)
 	mustEmbedUnimplementedMsgServer()
 }
@@ -19,7 +19,9 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 const (
-	Query_Params_FullMethodName = "/svc.v1.Query/Params"
+	Query_Params_FullMethodName        = "/svc.v1.Query/Params"
 	Query_OriginExists_FullMethodName  = "/svc.v1.Query/OriginExists"
 	Query_ResolveOrigin_FullMethodName = "/svc.v1.Query/ResolveOrigin"
 )
 // QueryClient is the client API for Query service.
@@ -30,6 +32,10 @@ const (
 type QueryClient interface {
 	// Params queries all parameters of the module.
 	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
 	// OriginExists queries if a given origin exists.
 	OriginExists(ctx context.Context, in *QueryOriginExistsRequest, opts ...grpc.CallOption) (*QueryOriginExistsResponse, error)
 	// ResolveOrigin queries the domain of a given service and returns its record with capabilities.
 	ResolveOrigin(ctx context.Context, in *QueryResolveOriginRequest, opts ...grpc.CallOption) (*QueryResolveOriginResponse, error)
 }
 type queryClient struct {
@@ -50,6 +56,26 @@ func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts .
 	return out, nil
 }
 func (c *queryClient) OriginExists(ctx context.Context, in *QueryOriginExistsRequest, opts ...grpc.CallOption) (*QueryOriginExistsResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(QueryOriginExistsResponse)
 	err := c.cc.Invoke(ctx, Query_OriginExists_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *queryClient) ResolveOrigin(ctx context.Context, in *QueryResolveOriginRequest, opts ...grpc.CallOption) (*QueryResolveOriginResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(QueryResolveOriginResponse)
 	err := c.cc.Invoke(ctx, Query_ResolveOrigin_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 // QueryServer is the server API for Query service.
 // All implementations must embed UnimplementedQueryServer
 // for forward compatibility.
@@ -58,6 +84,10 @@ func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts .
 type QueryServer interface {
 	// Params queries all parameters of the module.
 	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
 	// OriginExists queries if a given origin exists.
 	OriginExists(context.Context, *QueryOriginExistsRequest) (*QueryOriginExistsResponse, error)
 	// ResolveOrigin queries the domain of a given service and returns its record with capabilities.
 	ResolveOrigin(context.Context, *QueryResolveOriginRequest) (*QueryResolveOriginResponse, error)
 	mustEmbedUnimplementedQueryServer()
 }
@@ -71,6 +101,12 @@ type UnimplementedQueryServer struct{}
 func (UnimplementedQueryServer) Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
 }
 func (UnimplementedQueryServer) OriginExists(context.Context, *QueryOriginExistsRequest) (*QueryOriginExistsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method OriginExists not implemented")
 }
 func (UnimplementedQueryServer) ResolveOrigin(context.Context, *QueryResolveOriginRequest) (*QueryResolveOriginResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ResolveOrigin not implemented")
 }
 func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}
 func (UnimplementedQueryServer) testEmbeddedByValue()               {}
@@ -110,6 +146,42 @@ func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interf
 	return interceptor(ctx, in, info, handler)
 }
 func _Query_OriginExists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryOriginExistsRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(QueryServer).OriginExists(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: Query_OriginExists_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(QueryServer).OriginExists(ctx, req.(*QueryOriginExistsRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _Query_ResolveOrigin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryResolveOriginRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(QueryServer).ResolveOrigin(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: Query_ResolveOrigin_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(QueryServer).ResolveOrigin(ctx, req.(*QueryResolveOriginRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 // Query_ServiceDesc is the grpc.ServiceDesc for Query service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -121,6 +193,14 @@ var Query_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Params",
 			Handler:    _Query_Params_Handler,
 		},
 		{
 			MethodName: "OriginExists",
 			Handler:    _Query_OriginExists_Handler,
 		},
 		{
 			MethodName: "ResolveOrigin",
 			Handler:    _Query_ResolveOrigin_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "svc/v1/query.proto",
@@ -0,0 +1,19 @@
 package context
 import (
 	"github.com/go-webauthn/webauthn/protocol"
 )
 func (c *GatewayContext) NewChallenge() string {
 	chal, _ := protocol.CreateChallenge()
 	chalStr := chal.String()
 	return chalStr
 }
 func (cc *GatewayContext) ListCredentials(handle string) ([]*CredentialDescriptor, error) {
 	creds, err := cc.GetCredentialsByHandle(bgCtx(), handle)
 	if err != nil {
 		return nil, err
 	}
 	return CredentialArrayToDescriptors(creds), nil
 }
@@ -0,0 +1,64 @@
 package context
 import (
 	gocontext "context"
 	"net/http"
 	"github.com/labstack/echo/v4"
 	"github.com/medama-io/go-useragent"
 	"github.com/onsonr/sonr/internal/crypto/mpc"
 	"github.com/onsonr/sonr/internal/common"
 	"github.com/onsonr/sonr/internal/config/hway"
 	hwayorm "github.com/onsonr/sonr/internal/database/hwayorm"
 )
 type GatewayContext struct {
 	echo.Context
 	hwayorm.Querier
 	id               string
 	ipfsClient       common.IPFS
 	agent            useragent.UserAgent
 	tokenStore       common.IPFSTokenStore
 	stagedEnclaves   map[string]mpc.Enclave
 	grpcAddr         string
 	turnstileSiteKey string
 }
 func GetGateway(c echo.Context) (*GatewayContext, error) {
 	cc, ok := c.(*GatewayContext)
 	if !ok {
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "Gateway Context not found")
 	}
 	return cc, nil
 }
 func UseGateway(env hway.Hway, ipc common.IPFS, db *hwayorm.Queries) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			ua := useragent.NewParser()
 			ctx := &GatewayContext{
 				Context:          c,
 				Querier:          db,
 				ipfsClient:       ipc,
 				agent:            ua.Parse(c.Request().UserAgent()),
 				grpcAddr:         env.GetSonrGrpcUrl(),
 				tokenStore:       common.NewUCANStore(ipc),
 				turnstileSiteKey: env.GetTurnstileSiteKey(),
 			}
 			return next(ctx)
 		}
 	}
 }
 func BG() gocontext.Context {
 	ctx := gocontext.Background()
 	return ctx
 }
 func (cc *GatewayContext) ReadCookie(k common.CookieKey) string {
 	return common.ReadCookieUnsafe(cc.Context, k)
 }
 func (cc *GatewayContext) WriteCookie(k common.CookieKey, v string) {
 	common.WriteCookie(cc.Context, k, v)
 }
@@ -0,0 +1,53 @@
 package context
 import (
 	"net/http"
 	"github.com/labstack/echo/v4"
 	hwayorm "github.com/onsonr/sonr/internal/database/hwayorm"
 )
 func UpdateProfile(c echo.Context) (*hwayorm.Profile, error) {
 	ctx, ok := c.(*GatewayContext)
 	if !ok {
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "Profile Context not found")
 	}
 	address := c.FormValue("address")
 	handle := c.FormValue("handle")
 	name := c.FormValue("name")
 	profile, err := ctx.UpdateProfile(bgCtx(), hwayorm.UpdateProfileParams{
 		Address: address,
 		Handle:  handle,
 		Name:    name,
 	})
 	if err != nil {
 		return nil, err
 	}
 	return profile, nil
 }
 func ReadProfile(c echo.Context) (*hwayorm.Profile, error) {
 	ctx, ok := c.(*GatewayContext)
 	if !ok {
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "Profile Context not found")
 	}
 	handle := c.Param("handle")
 	profile, err := ctx.GetProfileByHandle(bgCtx(), handle)
 	if err != nil {
 		return nil, err
 	}
 	return profile, nil
 }
 func DeleteProfile(c echo.Context) error {
 	ctx, ok := c.(*GatewayContext)
 	if !ok {
 		return echo.NewHTTPError(http.StatusInternalServerError, "Profile Context not found")
 	}
 	address := c.Param("address")
 	err := ctx.SoftDeleteProfile(bgCtx(), address)
 	if err != nil {
 		return err
 	}
 	return nil
 }
@@ -0,0 +1,42 @@
 package context
 import (
 	"bytes"
 	"github.com/a-h/templ"
 	"github.com/labstack/echo/v4"
 	"github.com/onsonr/sonr/app/gateway/views"
 )
 func Render(c echo.Context, cmp templ.Component) error {
 	// Create a buffer to store the rendered HTML
 	buf := &bytes.Buffer{}
 	// Render the component to the buffer
 	err := cmp.Render(c.Request().Context(), buf)
 	if err != nil {
 		return err
 	}
 	// Set the content type
 	c.Response().Header().Set(echo.HeaderContentType, echo.MIMETextHTML)
 	// Write the buffered content to the response
 	_, err = c.Response().Write(buf.Bytes())
 	if err != nil {
 		return err
 	}
 	c.Response().WriteHeader(200)
 	return nil
 }
 func RenderError(c echo.Context, err error) error {
 	return Render(c, views.ErrorView(err.Error()))
 }
 func RenderInitial(c echo.Context) error {
 	return Render(c, views.InitialView())
 }
 func RenderLoading(c echo.Context) error {
 	return Render(c, views.LoadingView())
 }
@@ -0,0 +1,105 @@
 package context
 import (
 	"fmt"
 	"github.com/onsonr/sonr/internal/common"
 )
 // ParamsBank returns the bank params
 func (cc *GatewayContext) ParamsBank() (*common.BankParamsResponse, error) {
 	cl, err := common.NewBankClient(cc.grpcAddr)
 	if err != nil {
 		return nil, err
 	}
 	resp, err := cl.Params(bgCtx(), &common.BankParamsRequest{})
 	if err != nil {
 		return nil, err
 	}
 	return resp, nil
 }
 // ParamsDID returns the DID params
 func (cc *GatewayContext) ParamsDID() (*common.DIDParamsResponse, error) {
 	cl, err := common.NewDIDClient(cc.grpcAddr)
 	if err != nil {
 		return nil, err
 	}
 	resp, err := cl.Params(bgCtx(), &common.DIDParamsRequest{})
 	if err != nil {
 		return nil, err
 	}
 	return resp, nil
 }
 // ParamsDWN returns the DWN params
 func (cc *GatewayContext) ParamsDWN() (*common.DWNParamsResponse, error) {
 	cl, err := common.NewDWNClient(cc.grpcAddr)
 	if err != nil {
 		return nil, err
 	}
 	resp, err := cl.Params(bgCtx(), &common.DWNParamsRequest{})
 	if err != nil {
 		return nil, err
 	}
 	return resp, nil
 }
 // ParamsSVC returns the SVC params
 func (cc *GatewayContext) ParamsSVC() (*common.SVCParamsResponse, error) {
 	cl, err := common.NewSVCClient(cc.grpcAddr)
 	if err != nil {
 		return nil, err
 	}
 	resp, err := cl.Params(bgCtx(), &common.SVCParamsRequest{})
 	if err != nil {
 		return nil, err
 	}
 	return resp, nil
 }
 // StatusBlock returns the current block
 func (cc *GatewayContext) StatusBlock() string {
 	qc, err := common.NewNodeClient(cc.grpcAddr)
 	if err != nil {
 		return "-1"
 	}
 	resp, err := qc.Status(bgCtx(), &common.StatusRequest{})
 	if err != nil {
 		return "-1"
 	}
 	return fmt.Sprintf("%d", resp.GetHeight())
 }
 // StatusNode returns the node status
 func (cc *GatewayContext) StatusNode() (*common.StatusResponse, error) {
 	cl, err := common.NewNodeClient(cc.grpcAddr)
 	if err != nil {
 		return nil, err
 	}
 	resp, err := cl.Status(bgCtx(), &common.StatusRequest{})
 	if err != nil {
 		return nil, err
 	}
 	return resp, nil
 }
 // TxBroadcast broadcasts a transaction to the network
 func (cc *GatewayContext) TxBroadcast() error {
 	return nil
 }
 // TxEncode encodes a transaction
 func (cc *GatewayContext) TxEncode() error {
 	return nil
 }
 // TxDecode decodes a transaction
 func (cc *GatewayContext) TxDecode() error {
 	return nil
 }
 // TxSimulate simulates a transaction on the network
 func (cc *GatewayContext) TxSimulate() error {
 	return nil
 }
@@ -0,0 +1,148 @@
 package context
 import (
 	gocontext "context"
 	"github.com/labstack/echo/v4"
 	"github.com/onsonr/sonr/internal/common"
 	"github.com/segmentio/ksuid"
 	"lukechampine.com/blake3"
 )
 func NewSession(c echo.Context) error {
 	cc, ok := c.(*GatewayContext)
 	if !ok {
 		return nil
 	}
 	baseSessionCreateParams := BaseSessionCreateParams(cc)
 	cc.id = baseSessionCreateParams.ID
 	if _, err := cc.CreateSession(bgCtx(), baseSessionCreateParams); err != nil {
 		return err
 	}
 	// Set Cookie
 	if err := common.WriteCookie(c, common.SessionID, cc.id); err != nil {
 		return err
 	}
 	return nil
 }
 // Uses blake3 to hash the sessionID to generate a nonce of length 12 bytes
 func GetNonce(sessionID string) ([]byte, error) {
 	hash := blake3.New(32, nil)
 	_, err := hash.Write([]byte(sessionID))
 	if err != nil {
 		return nil, err
 	}
 	// Read the hash into a byte slice
 	nonce := make([]byte, 12)
 	_, err = hash.Write(nonce)
 	if err != nil {
 		return nil, err
 	}
 	return nonce, nil
 }
 // ForbiddenDevice returns true if the device is unavailable
 func ForbiddenDevice(c echo.Context) bool {
 	cc, ok := c.(*GatewayContext)
 	if !ok {
 		return true
 	}
 	return cc.agent.IsBot() || cc.agent.IsTV()
 }
 func GetOrigin(c echo.Context) string {
 	return c.Request().Host
 }
 func GetSessionID(c echo.Context) string {
 	// Check from context
 	cc, ok := c.(*GatewayContext)
 	if !ok {
 		return ""
 	}
 	// check from cookie
 	if cc.id == "" {
 		if ok := common.CookieExists(c, common.SessionID); !ok {
 			return ""
 		}
 		cc.id = common.ReadCookieUnsafe(c, common.SessionID)
 	}
 	return cc.id
 }
 func GetAuthChallenge(c echo.Context) string {
 	cc, ok := c.(*GatewayContext)
 	if !ok {
 		return ""
 	}
 	s, err := cc.GetChallengeBySessionID(bgCtx(), cc.id)
 	if err != nil {
 		return ""
 	}
 	return s
 }
 func GetProfileHandle(c echo.Context) string {
 	// First check for the cookie
 	handle := common.ReadCookieUnsafe(c, common.UserHandle)
 	if handle != "" {
 		return handle
 	}
 	// Then check the session
 	cc, ok := c.(*GatewayContext)
 	if !ok {
 		return ""
 	}
 	s, err := cc.GetSessionByID(bgCtx(), cc.id)
 	if err != nil {
 		return ""
 	}
 	profile, err := cc.GetProfileByID(bgCtx(), s.ProfileID)
 	if err != nil {
 		return ""
 	}
 	return profile.Handle
 }
 //
 // func GetHumanVerificationNumbers(c echo.Context) (int64, int64) {
 // 	cc, ok := c.(*GatewayContext)
 // 	if !ok {
 // 		return 0, 0
 // 	}
 // 	s, err := cc.dbq.GetHumanVerificationNumbers(bgCtx(), cc.id)
 // 	if err != nil {
 // 		return 0, 0
 // 	}
 // 	return s.IsHumanFirst, s.IsHumanLast
 // }
 // utility function to get a context
 func bgCtx() gocontext.Context {
 	ctx := gocontext.Background()
 	return ctx
 }
 func getOrCreateSessionID(c echo.Context) string {
 	if ok := common.CookieExists(c, common.SessionID); !ok {
 		sessionID := ksuid.New().String()
 		common.WriteCookie(c, common.SessionID, sessionID)
 		return sessionID
 	}
 	sessionID, err := common.ReadCookie(c, common.SessionID)
 	if err != nil {
 		sessionID = ksuid.New().String()
 		common.WriteCookie(c, common.SessionID, sessionID)
 	}
 	return sessionID
 }
 func boolToInt64(b bool) int64 {
 	if b {
 		return 1
 	}
 	return 0
 }
@@ -0,0 +1,102 @@
 package context
 import (
 	"github.com/go-webauthn/webauthn/protocol"
 	"github.com/labstack/echo/v4"
 	"github.com/medama-io/go-useragent"
 	hwayorm "github.com/onsonr/sonr/internal/database/hwayorm"
 )
 // Define the credential structure matching our frontend data
 type CredentialDescriptor struct {
 	ID                      string            `json:"id"`
 	RawID                   string            `json:"rawId"`
 	Type                    string            `json:"type"`
 	AuthenticatorAttachment string            `json:"authenticatorAttachment"`
 	Transports              string            `json:"transports"`
 	ClientExtensionResults  map[string]string `json:"clientExtensionResults"`
 	Response                struct {
 		AttestationObject string `json:"attestationObject"`
 		ClientDataJSON    string `json:"clientDataJSON"`
 	} `json:"response"`
 }
 func (c *CredentialDescriptor) ToModel(handle, origin string) *hwayorm.Credential {
 	return &hwayorm.Credential{
 		Handle:                  handle,
 		Origin:                  origin,
 		CredentialID:            c.ID,
 		Type:                    c.Type,
 		Transports:              c.Transports,
 		AuthenticatorAttachment: c.AuthenticatorAttachment,
 	}
 }
 func CredentialArrayToDescriptors(credentials []*hwayorm.Credential) []*CredentialDescriptor {
 	var descriptors []*CredentialDescriptor
 	for _, cred := range credentials {
 		cd := &CredentialDescriptor{
 			ID:                      cred.CredentialID,
 			RawID:                   cred.CredentialID,
 			Type:                    cred.Type,
 			AuthenticatorAttachment: cred.AuthenticatorAttachment,
 			Transports:              cred.Transports,
 		}
 		descriptors = append(descriptors, cd)
 	}
 	return descriptors
 }
 func BaseSessionCreateParams(e echo.Context) hwayorm.CreateSessionParams {
 	// f := rand.Intn(5) + 1
 	// l := rand.Intn(4) + 1
 	challenge, _ := protocol.CreateChallenge()
 	id := getOrCreateSessionID(e)
 	ua := useragent.NewParser()
 	s := ua.Parse(e.Request().UserAgent())
 	return hwayorm.CreateSessionParams{
 		ID:             id,
 		BrowserName:    s.GetBrowser(),
 		BrowserVersion: s.GetMajorVersion(),
 		ClientIpaddr:   e.RealIP(),
 		Platform:       s.GetOS(),
 		IsMobile:       s.IsMobile(),
 		IsTablet:       s.IsTablet(),
 		IsDesktop:      s.IsDesktop(),
 		IsBot:          s.IsBot(),
 		IsTv:           s.IsTV(),
 		// IsHumanFirst:   int64(f),
 		// IsHumanLast:    int64(l),
 		Challenge: challenge.String(),
 	}
 }
 // ╭───────────────────────────────────────────────────────────╮
 // │            Create Passkey (/register/passkey)             │
 // ╰───────────────────────────────────────────────────────────╯
 // CreatePasskeyParams represents the parameters for creating a passkey
 type CreatePasskeyParams struct {
 	Address       string
 	Handle        string
 	Name          string
 	Challenge     string
 	CreationBlock string
 }
 // ╭───────────────────────────────────────────────────────────╮
 // │            Create Profile (/register/profile)             │
 // ╰───────────────────────────────────────────────────────────╯
 // CreateProfileParams represents the parameters for creating a profile
 type CreateProfileParams struct {
 	TurnstileSiteKey string
 	FirstNumber      int
 	LastNumber       int
 }
 // Sum returns the sum of the first and last number
 func (d CreateProfileParams) Sum() int {
 	return d.FirstNumber + d.LastNumber
 }
@@ -0,0 +1,45 @@
 package context
 import (
 	"github.com/onsonr/sonr/internal/crypto/mpc"
 	"github.com/onsonr/sonr/internal/common"
 	"lukechampine.com/blake3"
 )
 func (cc *GatewayContext) Spawn(handle, origin string) (*CreatePasskeyParams, error) {
 	challenge := GetAuthChallenge(cc)
 	sid := GetSessionID(cc)
 	nonce, err := calcNonce(sid)
 	if err != nil {
 		return nil, err
 	}
 	encl, err := mpc.GenEnclave(nonce)
 	if err != nil {
 		return nil, err
 	}
 	cc.stagedEnclaves[sid] = encl
 	common.WriteCookie(cc, common.SonrAddress, encl.Address())
 	return &CreatePasskeyParams{
 		Address:       encl.Address(),
 		Handle:        handle,
 		Name:          origin,
 		Challenge:     challenge,
 		CreationBlock: cc.StatusBlock(),
 	}, nil
 }
 // Uses blake3 to hash the sessionID to generate a nonce of length 12 bytes
 func calcNonce(sessionID string) ([]byte, error) {
 	hash := blake3.New(32, nil)
 	_, err := hash.Write([]byte(sessionID))
 	if err != nil {
 		return nil, err
 	}
 	// Read the hash into a byte slice
 	nonce := make([]byte, 12)
 	_, err = hash.Write(nonce)
 	if err != nil {
 		return nil, err
 	}
 	return nonce, nil
 }
@@ -0,0 +1,33 @@
 // Package gateway provides the default routes for the Sonr hway.
 package gateway
 import (
 	"github.com/labstack/echo-contrib/echoprometheus"
 	"github.com/labstack/echo/v4"
 	echomiddleware "github.com/labstack/echo/v4/middleware"
 	"github.com/onsonr/sonr/app/gateway/context"
 	"github.com/onsonr/sonr/app/gateway/handlers"
 	"github.com/onsonr/sonr/internal/common"
 	config "github.com/onsonr/sonr/internal/config/hway"
 	hwayorm "github.com/onsonr/sonr/internal/database/hwayorm"
 )
 type Gateway = *echo.Echo
 // New returns a new Gateway instance
 func New(env config.Hway, ipc common.IPFS, dbq *hwayorm.Queries) (Gateway, error) {
 	e := echo.New()
 	// Built-in middleware
 	e.Use(echomiddleware.Logger())
 	e.Use(echomiddleware.Recover())
 	e.IPExtractor = echo.ExtractIPDirect()
 	e.Use(echoprometheus.NewMiddleware("hway"))
 	e.Use(context.UseGateway(env, ipc, dbq))
 	// Register View Handlers
 	e.HTTPErrorHandler = handlers.ErrorHandler
 	e.GET("/", handlers.IndexHandler)
 	handlers.RegisterHandler(e.Group("/register"))
 	return e, nil
 }
@@ -0,0 +1,14 @@
 package handlers
 import (
 	"github.com/labstack/echo/v4"
 	"github.com/onsonr/sonr/app/gateway/context"
 )
 func ErrorHandler(err error, c echo.Context) {
 	if he, ok := err.(*echo.HTTPError); ok {
 		// Log the error if needed
 		c.Logger().Errorf("Error: %v", he.Message)
 		context.RenderError(c, he)
 	}
 }
@@ -0,0 +1,14 @@
 package handlers
 import (
 	"github.com/labstack/echo/v4"
 	"github.com/onsonr/sonr/app/gateway/context"
 )
 func IndexHandler(c echo.Context) error {
 	id := context.GetSessionID(c)
 	if id == "" {
 		context.NewSession(c)
 	}
 	return context.RenderInitial(c)
 }
@@ -0,0 +1,111 @@
 package handlers
 import (
 	"encoding/json"
 	"github.com/labstack/echo/v4"
 	"github.com/onsonr/sonr/app/gateway/context"
 	"github.com/onsonr/sonr/app/gateway/islands"
 	"github.com/onsonr/sonr/app/gateway/views"
 	"github.com/onsonr/sonr/internal/common"
 	hwayorm "github.com/onsonr/sonr/internal/database/hwayorm"
 )
 func RegisterHandler(g *echo.Group) {
 	g.GET("/start", renderProfileForm)
 	g.POST("/profile", validateProfileForm)
 	g.GET("/passkey", renderPasskeyForm)
 	g.POST("/passkey", validatePasskeyForm)
 	g.GET("/vault", renderVaultStatus)
 }
 // ╭──────────────────────────────────────────────────────╮
 // │                  Registration Views                  │
 // ╰──────────────────────────────────────────────────────
 func renderProfileForm(c echo.Context) error {
 	params := context.CreateProfileParams{
 		FirstNumber: 6,
 		LastNumber:  3,
 	}
 	return context.Render(c, views.RegisterProfileView(params.FirstNumber, params.LastNumber))
 }
 func renderPasskeyForm(c echo.Context) error {
 	cc, err := context.GetGateway(c)
 	if err != nil {
 		return err
 	}
 	handle := c.FormValue("handle")
 	origin := c.FormValue("origin")
 	name := c.FormValue("name")
 	cc.InsertProfile(context.BG(), hwayorm.InsertProfileParams{
 		Handle: handle,
 		Origin: origin,
 		Name:   name,
 	})
 	params, err := cc.Spawn(handle, origin)
 	if err != nil {
 		return context.RenderError(c, err)
 	}
 	return context.Render(c, views.RegisterPasskeyView(params.Address, params.Handle, params.Name, params.Challenge, params.CreationBlock))
 }
 func renderVaultStatus(c echo.Context) error {
 	return context.Render(c, views.LoadingView())
 }
 // ╭─────────────────────────────────────────────────────────╮
 // │                  Validation Components                  │
 // ╰─────────────────────────────────────────────────────────╯
 func validateProfileForm(c echo.Context) error {
 	cc, err := context.GetGateway(c)
 	if err != nil {
 		return context.RenderError(c, err)
 	}
 	handle := c.FormValue("handle")
 	if handle == "" {
 		return context.Render(c, islands.InputHandleError(handle, "Please enter a 4-16 character handle"))
 	}
 	notok, err := cc.CheckHandleExists(context.BG(), handle)
 	if err != nil {
 		return err
 	}
 	if notok {
 		return context.Render(c, islands.InputHandleError(handle, "Handle is already taken"))
 	}
 	cc.WriteCookie(common.UserHandle, handle)
 	return context.Render(c, islands.InputHandleSuccess(handle))
 }
 func validatePasskeyForm(c echo.Context) error {
 	cc, err := context.GetGateway(c)
 	if err != nil {
 		return context.RenderError(c, err)
 	}
 	handle := context.GetProfileHandle(c)
 	origin := c.Request().Host
 	credentialJSON := c.FormValue("credential")
 	cred := &context.CredentialDescriptor{}
 	// Unmarshal the credential JSON
 	err = json.Unmarshal([]byte(credentialJSON), cred)
 	if err != nil {
 		return context.RenderError(c, err)
 	}
 	md := cred.ToModel(handle, origin)
 	_, err = cc.InsertCredential(context.BG(), hwayorm.InsertCredentialParams{
 		Handle:       md.Handle,
 		CredentialID: md.CredentialID,
 		Origin:       md.Origin,
 		Type:         md.Type,
 		Transports:   md.Transports,
 	})
 	if err != nil {
 		return context.RenderError(c, err)
 	}
 	return context.Render(c, views.LoadingView())
 }
@@ -0,0 +1,38 @@
 package islands
 templ CardAccount(addr, name, handle, creationBlock string) {
 	<div class="profile-card min-w-[320px]">
 		<div class="text-white max-w-xs my-auto mx-auto bg-gradient-to-r from-cyan-600 to-cyan-300 p-4 py-5 px-5 rounded-xl">
 			<div class="flex justify-between">
 				<div>
 					<h2>sonr-testnet-1</h2>
 					<p class="text-2xl font-bold">{ handle }</p>
 				</div>
 				<div class="flex items-center opacity-60">
 					<sl-icon style="font-size: 52px;" library="sonr" name="sonr-fill"></sl-icon>
 				</div>
 			</div>
 			<div class="mt-5 flex justify-between items-center w-52">
 				<span class="text-lg font-mono">{ shortenAddress(addr) }</span>
 			</div>
 			<div class="flex justify-between mt-5 w-48 ">
 				<div>
 					<h3 class="text-xs">Block Created </h3>
 					<p class="font-bold"><span>#</span>{ creationBlock }</p>
 				</div>
 				<div>
 					<h3 class="text-xs">Issued to</h3>
 					<p class="font-bold">{ name }</p>
 				</div>
 			</div>
 		</div>
 	</div>
 }
 // Helper function to shorten address
 func shortenAddress(address string) string {
 	if len(address) <= 20 {
 		return address
 	}
 	return address[:16] + "..." + address[len(address)-4:]
 }
@@ -0,0 +1,100 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package islands
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 func CardAccount(addr, name, handle, creationBlock string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"profile-card min-w-[320px]\"><div class=\"text-white max-w-xs my-auto mx-auto bg-gradient-to-r from-cyan-600 to-cyan-300 p-4 py-5 px-5 rounded-xl\"><div class=\"flex justify-between\"><div><h2>sonr-testnet-1</h2><p class=\"text-2xl font-bold\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(handle)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/card_account.templ`, Line: 9, Col: 43}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</p></div><div class=\"flex items-center opacity-60\"><sl-icon style=\"font-size: 52px;\" library=\"sonr\" name=\"sonr-fill\"></sl-icon></div></div><div class=\"mt-5 flex justify-between items-center w-52\"><span class=\"text-lg font-mono\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var3 string
 		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(shortenAddress(addr))
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/card_account.templ`, Line: 16, Col: 58}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div><div class=\"flex justify-between mt-5 w-48 \"><div><h3 class=\"text-xs\">Block Created </h3><p class=\"font-bold\"><span>#</span>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var4 string
 		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(creationBlock)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/card_account.templ`, Line: 21, Col: 55}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</p></div><div><h3 class=\"text-xs\">Issued to</h3><p class=\"font-bold\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var5 string
 		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(name)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/card_account.templ`, Line: 25, Col: 32}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</p></div></div></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // Helper function to shorten address
 func shortenAddress(address string) string {
 	if len(address) <= 20 {
 		return address
 	}
 	return address[:16] + "..." + address[len(address)-4:]
 }
 var _ = templruntime.GeneratedTemplate
@@ -0,0 +1,70 @@
 package islands
 type Coin struct {
 	Ticker    string
 	Name      string
 	IsDefault bool
 }
 var defaultCoins = []Coin{
 	{Ticker: "SNR", Name: "Sonr", IsDefault: true},
 	{Ticker: "BTC", Name: "Bitcoin", IsDefault: true},
 	{Ticker: "ETH", Name: "Ethereum", IsDefault: true},
 	{Ticker: "SOL", Name: "Solana", IsDefault: false},
 	{Ticker: "LTC", Name: "Litecoin", IsDefault: false},
 	{Ticker: "DOGE", Name: "Dogecoin", IsDefault: false},
 	{Ticker: "XRP", Name: "Ripple", IsDefault: false},
 	{Ticker: "OSMO", Name: "Osmosis", IsDefault: false},
 	{Ticker: "ATOM", Name: "Cosmos", IsDefault: false},
 	{Ticker: "STARZ", Name: "Stargaze", IsDefault: false},
 	{Ticker: "AKT", Name: "Akash", IsDefault: false},
 	{Ticker: "EVMOS", Name: "Evmos", IsDefault: false},
 	{Ticker: "FIL", Name: "Filecoin", IsDefault: false},
 	{Ticker: "AXL", Name: "Axelar", IsDefault: false},
 }
 templ CoinSelect() {
 	<sl-select
 		label="Accounts"
 		name="selected_assets"
 		value="SNR BTC ETH"
 		help-text="Select Blockchains to connect with your Vault"
 		multiple
 		class="custom-tag py-2"
 	>
 		for _, a := range defaultCoins {
 			@CoinOption(a)
 		}
 	</sl-select>
 	<script>
 	  const select = document.querySelector('.custom-tag');
      select.getTag = (option, index) => {
      // Use the same icon used in the <sl-option>
      const name = option.querySelector('sl-icon[slot="prefix"]').name;
      // You can return a string, a Lit Template, or an HTMLElement here
      return `
        <sl-tag removable>
          <sl-icon name="${name}" library="crypto" style="padding-inline-end: .5rem;"></sl-icon>
          ${option.getTextLabel()}
        </sl-tag>
      `;
    };
 	</script>
 }
 templ CoinOption(a Coin) {
 	if a.IsDefault {
 		<sl-option value={ a.Ticker } selected disabled>
 			<sl-icon slot="prefix" name={ a.Ticker } library="crypto"></sl-icon>
 			{ a.Name }
 		</sl-option>
 		<sl-divider></sl-divider>
 	} else {
 		<sl-option value={ a.Ticker }>
 			<sl-icon slot="prefix" name={ a.Ticker } library="crypto"></sl-icon>
 			{ a.Name }
 		</sl-option>
 		<sl-divider></sl-divider>
 	}
 }
@@ -0,0 +1,187 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package islands
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 type Coin struct {
 	Ticker    string
 	Name      string
 	IsDefault bool
 }
 var defaultCoins = []Coin{
 	{Ticker: "SNR", Name: "Sonr", IsDefault: true},
 	{Ticker: "BTC", Name: "Bitcoin", IsDefault: true},
 	{Ticker: "ETH", Name: "Ethereum", IsDefault: true},
 	{Ticker: "SOL", Name: "Solana", IsDefault: false},
 	{Ticker: "LTC", Name: "Litecoin", IsDefault: false},
 	{Ticker: "DOGE", Name: "Dogecoin", IsDefault: false},
 	{Ticker: "XRP", Name: "Ripple", IsDefault: false},
 	{Ticker: "OSMO", Name: "Osmosis", IsDefault: false},
 	{Ticker: "ATOM", Name: "Cosmos", IsDefault: false},
 	{Ticker: "STARZ", Name: "Stargaze", IsDefault: false},
 	{Ticker: "AKT", Name: "Akash", IsDefault: false},
 	{Ticker: "EVMOS", Name: "Evmos", IsDefault: false},
 	{Ticker: "FIL", Name: "Filecoin", IsDefault: false},
 	{Ticker: "AXL", Name: "Axelar", IsDefault: false},
 }
 func CoinSelect() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-select label=\"Accounts\" name=\"selected_assets\" value=\"SNR BTC ETH\" help-text=\"Select Blockchains to connect with your Vault\" multiple class=\"custom-tag py-2\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		for _, a := range defaultCoins {
 			templ_7745c5c3_Err = CoinOption(a).Render(ctx, templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</sl-select><script>\n\t  const select = document.querySelector('.custom-tag');\n      select.getTag = (option, index) => {\n      // Use the same icon used in the <sl-option>\n      const name = option.querySelector('sl-icon[slot=\"prefix\"]').name;\n\n      // You can return a string, a Lit Template, or an HTMLElement here\n      return `\n        <sl-tag removable>\n          <sl-icon name=\"${name}\" library=\"crypto\" style=\"padding-inline-end: .5rem;\"></sl-icon>\n          ${option.getTextLabel()}\n        </sl-tag>\n      `;\n    };\n\t</script>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func CoinOption(a Coin) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var2 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var2 == nil {
 			templ_7745c5c3_Var2 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		if a.IsDefault {
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-option value=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var3 string
 			templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(a.Ticker)
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/coin_select.templ`, Line: 58, Col: 29}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" selected disabled><sl-icon slot=\"prefix\" name=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var4 string
 			templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(a.Ticker)
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/coin_select.templ`, Line: 59, Col: 41}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" library=\"crypto\"></sl-icon> ")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var5 string
 			templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(a.Name)
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/coin_select.templ`, Line: 60, Col: 11}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</sl-option> <sl-divider></sl-divider>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 		} else {
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-option value=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var6 string
 			templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(a.Ticker)
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/coin_select.templ`, Line: 64, Col: 29}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><sl-icon slot=\"prefix\" name=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var7 string
 			templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(a.Ticker)
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/coin_select.templ`, Line: 65, Col: 41}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" library=\"crypto\"></sl-icon> ")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var8 string
 			templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(a.Name)
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/coin_select.templ`, Line: 66, Col: 11}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</sl-option> <sl-divider></sl-divider>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 		}
 		return templ_7745c5c3_Err
 	})
 }
 var _ = templruntime.GeneratedTemplate
@@ -0,0 +1,25 @@
 package islands
 import "fmt"
 templ HumanSlider(firstNumber int, lastNumber int) {
 	<div hx-target="this" hx-swap="outerHTML">
 		<sl-range name="is_human" label={ humanLabel(firstNumber, lastNumber) } help-text="Prove you are a human." min="0" max="9" step="1" hx-post="/register/profile/is_human"></sl-range>
 	</div>
 }
 templ HumanSliderError(firstNumber int, lastNumber int) {
 	<sl-range name="is_human" label={ humanLabel(firstNumber, lastNumber) } help-text="Prove you are a human." min="0" max="9" step="1"></sl-range>
 	<div slot="help-text">
 		<sl-icon name="x-lg" library="sonr"></sl-icon>
 		Invalid Human Sum
 	</div>
 }
 templ HumanSliderSuccess() {
 	<sl-range name="is_human" label="Success! Welcome Human." help-text="Prove you are a human." min="0" max="9" step="1" value="9" disabled></sl-range>
 }
 func humanLabel(firstNumber int, lastNumber int) string {
 	return fmt.Sprintf("What is %d + %d?", firstNumber, lastNumber)
 }
@@ -0,0 +1,130 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package islands
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 import "fmt"
 func HumanSlider(firstNumber int, lastNumber int) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div hx-target=\"this\" hx-swap=\"outerHTML\"><sl-range name=\"is_human\" label=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(humanLabel(firstNumber, lastNumber))
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/human_slider.templ`, Line: 7, Col: 71}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" help-text=\"Prove you are a human.\" min=\"0\" max=\"9\" step=\"1\" hx-post=\"/register/profile/is_human\"></sl-range></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func HumanSliderError(firstNumber int, lastNumber int) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var3 == nil {
 			templ_7745c5c3_Var3 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-range name=\"is_human\" label=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var4 string
 		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(humanLabel(firstNumber, lastNumber))
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/human_slider.templ`, Line: 12, Col: 70}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" help-text=\"Prove you are a human.\" min=\"0\" max=\"9\" step=\"1\"></sl-range><div slot=\"help-text\"><sl-icon name=\"x-lg\" library=\"sonr\"></sl-icon> Invalid Human Sum</div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func HumanSliderSuccess() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var5 == nil {
 			templ_7745c5c3_Var5 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-range name=\"is_human\" label=\"Success! Welcome Human.\" help-text=\"Prove you are a human.\" min=\"0\" max=\"9\" step=\"1\" value=\"9\" disabled></sl-range>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func humanLabel(firstNumber int, lastNumber int) string {
 	return fmt.Sprintf("What is %d + %d?", firstNumber, lastNumber)
 }
 var _ = templruntime.GeneratedTemplate
@@ -0,0 +1,45 @@
 package islands
 type HandleState string
 const (
 	HandleStateInitial HandleState = "inital"
 	HandleStateValid   HandleState = "valid"
 	HandleStateInvalid HandleState = "invalid"
 )
 func (s HandleState) string() string {
 	return string(s)
 }
 templ InputHandle() {
 	<div hx-target="this" hx-swap="outerHTML">
 		<sl-input name="handle" placeholder="digitalgold" type="text" label="Handle" minlength="4" maxlength="12" required hx-post="/register/profile" hx-indicator="#handle-indicator" autofocus>
 			<div slot="prefix">
 				<sl-icon name="at-sign" library="sonr"></sl-icon>
 			</div>
 		</sl-input>
 	</div>
 	<br/>
 }
 templ InputHandleError(value string, helpText string) {
 	<sl-input name="handle" placeholder="digitalgold" type="text" label="Handle" minlength="4" maxlength="12" required class="border-red-500" value={ value } help-text={ helpText }>
 		<div slot="prefix">
 			<sl-icon name="at-sign" library="sonr"></sl-icon>
 		</div>
 		<div slot="suffix" style="color: #B54549;">
 			<sl-icon name="x"></sl-icon>
 		</div>
 	</sl-input>
 	<br/>
 }
 templ InputHandleSuccess(value string) {
 	<sl-input name="handle" placeholder="digitalgold" type="text" label="Handle" minlength="4" maxlength="12" required class="border-green-500" value={ value } disabled>
 		<div slot="prefix" style="color: #46A758;">
 			<sl-icon name="at-sign" library="sonr"></sl-icon>
 		</div>
 	</sl-input>
 	<br/>
 }
@@ -0,0 +1,149 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package islands
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 type HandleState string
 const (
 	HandleStateInitial HandleState = "inital"
 	HandleStateValid   HandleState = "valid"
 	HandleStateInvalid HandleState = "invalid"
 )
 func (s HandleState) string() string {
 	return string(s)
 }
 func InputHandle() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div hx-target=\"this\" hx-swap=\"outerHTML\"><sl-input name=\"handle\" placeholder=\"digitalgold\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required hx-post=\"/register/profile\" hx-indicator=\"#handle-indicator\" autofocus><div slot=\"prefix\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div></sl-input></div><br>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func InputHandleError(value string, helpText string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var2 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var2 == nil {
 			templ_7745c5c3_Var2 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-input name=\"handle\" placeholder=\"digitalgold\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required class=\"border-red-500\" value=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var3 string
 		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(value)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/input_handle.templ`, Line: 27, Col: 152}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" help-text=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var4 string
 		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(helpText)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/input_handle.templ`, Line: 27, Col: 175}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><div slot=\"prefix\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div><div slot=\"suffix\" style=\"color: #B54549;\"><sl-icon name=\"x\"></sl-icon></div></sl-input><br>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func InputHandleSuccess(value string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var5 == nil {
 			templ_7745c5c3_Var5 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-input name=\"handle\" placeholder=\"digitalgold\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required class=\"border-green-500\" value=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var6 string
 		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(value)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/islands/input_handle.templ`, Line: 39, Col: 154}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" disabled><div slot=\"prefix\" style=\"color: #46A758;\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div></sl-input><br>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 var _ = templruntime.GeneratedTemplate
@@ -0,0 +1,97 @@
 package islands
 templ InputPasskey(addr string, userHandle string, challenge string) {
 	<sl-button style="width: 100%;" onclick={ navigatorCredentialsCreate(addr, userHandle, challenge) }>
 		<sl-icon slot="prefix" name="passkey" library="sonr" style="font-size: 24px;" class="text-neutral-500"></sl-icon>
 		Register Passkey
 	</sl-button>
 }
 script navigatorCredentialsCreate(userId string, userHandle string, challenge string) {
  const publicKey = {
    challenge: Uint8Array.from(challenge, (c) => c.charCodeAt(0)),
    rp: {
      name: "Sonr.ID",
    },
    user: {
      // Assuming that userId is ASCII-only
      id: Uint8Array.from(userId, (c) => c.charCodeAt(0)),
      name: userId,
      displayName: userHandle,
    },
    pubKeyCredParams: [
      {
        type: "public-key",
        alg: -7, // "ES256"
      },
      {
        type: "public-key",
        alg: -257, // "RS256"
      },
    ],
    authenticatorSelection: {
      userVerification: "required",
      residentKey: "required",
      authenticatorAttachment: "platform",
    },
    timeout: 60000, // 1 minute
    extensions: {
      payment: {
        isPayment: true,
      },
      largeBlob: {
        supported: "preferred",
      },
    },
  };
  // Helper function to convert ArrayBuffer to Base64URL string
  function arrayBufferToBase64URL(buffer) {
    const bytes = new Uint8Array(buffer);
    let str = '';
    bytes.forEach(byte => { str += String.fromCharCode(byte) });
    return btoa(str)
      .replace(/\+/g, '-')
      .replace(/\//g, '_')
      .replace(/=/g, '');
  }
 navigator.credentials
  .create({ publicKey })
  .then((newCredentialInfo) => {
    if (!(newCredentialInfo instanceof PublicKeyCredential)) {
      throw new Error('Received credential is not a PublicKeyCredential');
    }
    const response = newCredentialInfo.response;
    if (!(response instanceof AuthenticatorAttestationResponse)) {
      throw new Error('Response is not an AuthenticatorAttestationResponse');
    }
    // Convert the credential data to a cross-platform compatible format
    const credentialJSON = {
      id: newCredentialInfo.id,
      rawId: arrayBufferToBase64URL(newCredentialInfo.rawId),
      type: newCredentialInfo.type,
      authenticatorAttachment: newCredentialInfo.authenticatorAttachment || null,
      transports: Array.isArray(response.getTransports) ? response.getTransports() : [],
      clientExtensionResults: newCredentialInfo.getClientExtensionResults(),
      response: {
        attestationObject: arrayBufferToBase64URL(response.attestationObject),
        clientDataJSON: arrayBufferToBase64URL(response.clientDataJSON)
      }
    };
    // Set the form value with the stringified credential data
    const credential = document.getElementById('credential-data');
    credential.value = JSON.stringify(credentialJSON);
    // Submit the form
    const form = document.getElementById('passkey-form');
    form.submit();
  })
  .catch((err) => {
    console.error('Passkey creation failed:', err);
    alert(`Failed to create passkey: ${err.message || 'Unknown error'}`);
  });
 }
@@ -0,0 +1,148 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package islands
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 func InputPasskey(addr string, userHandle string, challenge string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Err = templ.RenderScriptItems(ctx, templ_7745c5c3_Buffer, navigatorCredentialsCreate(addr, userHandle, challenge))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-button style=\"width: 100%;\" onclick=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 templ.ComponentScript = navigatorCredentialsCreate(addr, userHandle, challenge)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var2.Call)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><sl-icon slot=\"prefix\" name=\"passkey\" library=\"sonr\" style=\"font-size: 24px;\" class=\"text-neutral-500\"></sl-icon> Register Passkey</sl-button>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func navigatorCredentialsCreate(userId string, userHandle string, challenge string) templ.ComponentScript {
 	return templ.ComponentScript{
 		Name: `__templ_navigatorCredentialsCreate_63c0`,
 		Function: `function __templ_navigatorCredentialsCreate_63c0(userId, userHandle, challenge){const publicKey = {
    challenge: Uint8Array.from(challenge, (c) => c.charCodeAt(0)),
    rp: {
      name: "Sonr.ID",
    },
    user: {
      // Assuming that userId is ASCII-only
      id: Uint8Array.from(userId, (c) => c.charCodeAt(0)),
      name: userId,
      displayName: userHandle,
    },
    pubKeyCredParams: [
      {
        type: "public-key",
        alg: -7, // "ES256"
      },
      {
        type: "public-key",
        alg: -257, // "RS256"
      },
    ],
    authenticatorSelection: {
      userVerification: "required",
      residentKey: "required",
      authenticatorAttachment: "platform",
    },
    timeout: 60000, // 1 minute
    extensions: {
      payment: {
        isPayment: true,
      },
      largeBlob: {
        supported: "preferred",
      },
    },
  };
  // Helper function to convert ArrayBuffer to Base64URL string
  function arrayBufferToBase64URL(buffer) {
    const bytes = new Uint8Array(buffer);
    let str = '';
    bytes.forEach(byte => { str += String.fromCharCode(byte) });
    return btoa(str)
      .replace(/\+/g, '-')
      .replace(/\//g, '_')
      .replace(/=/g, '');
  }
 navigator.credentials
  .create({ publicKey })
  .then((newCredentialInfo) => {
    if (!(newCredentialInfo instanceof PublicKeyCredential)) {
      throw new Error('Received credential is not a PublicKeyCredential');
    }
    const response = newCredentialInfo.response;
    if (!(response instanceof AuthenticatorAttestationResponse)) {
      throw new Error('Response is not an AuthenticatorAttestationResponse');
    }
    // Convert the credential data to a cross-platform compatible format
    const credentialJSON = {
      id: newCredentialInfo.id,
      rawId: arrayBufferToBase64URL(newCredentialInfo.rawId),
      type: newCredentialInfo.type,
      authenticatorAttachment: newCredentialInfo.authenticatorAttachment || null,
      transports: Array.isArray(response.getTransports) ? response.getTransports() : [],
      clientExtensionResults: newCredentialInfo.getClientExtensionResults(),
      response: {
        attestationObject: arrayBufferToBase64URL(response.attestationObject),
        clientDataJSON: arrayBufferToBase64URL(response.clientDataJSON)
      }
    };
    // Set the form value with the stringified credential data
    const credential = document.getElementById('credential-data');
    credential.value = JSON.stringify(credentialJSON);
    // Submit the form
    const form = document.getElementById('passkey-form');
    form.submit();
  })
  .catch((err) => {
    console.error('Passkey creation failed:', err);
    alert(` + "`" + `Failed to create passkey: ${err.message || 'Unknown error'}` + "`" + `);
  });
 }`,
 		Call:       templ.SafeScript(`__templ_navigatorCredentialsCreate_63c0`, userId, userHandle, challenge),
 		CallInline: templ.SafeScriptInline(`__templ_navigatorCredentialsCreate_63c0`, userId, userHandle, challenge),
 	}
 }
 var _ = templruntime.GeneratedTemplate
@@ -0,0 +1,58 @@
 package views
 templ Form(action, id string) {
 	<form method="GET" action={ templ.SafeURL(action) } id={ id } hx-post={ action } hx-target="#{ id }" hx-swap="outerHTML">
 		{ children... }
 	</form>
 }
 templ FormHeader() {
 	<div slot="header">
 		<div class="w-full py-2">
 			{ children... }
 		</div>
 	</div>
 }
 templ FormBody() {
 	<sl-card class="card-form max-w-lg mx-auto">
 		{ children... }
 		<style>
 		.card-form {
 				space-y: 1rem;
 		}
  	.card-form [slot='header'] {
    	display: flex;
    	align-items: center;
  	  justify-content: space-between;
 	  }
 	  .card-form [slot='footer'] {
   	 	display: flex;
    	justify-content: space-between;
    	align-items: center;
  	}
 		</style>
 	</sl-card>
 }
 templ FormFooter() {
 	<div slot="footer">
 		{ children... }
 	</div>
 }
 templ FormCancel() {
 	<sl-button href="/" outline>
 		<sl-icon slot="prefix" name="x-lg"></sl-icon>
 		Cancel
 	</sl-button>
 }
 templ FormSubmit(text string) {
 	<sl-button type="submit">
 		{ text }
 		<sl-icon slot="suffix" name="arrow-right" library="sonr"></sl-icon>
 	</sl-button>
 }
@@ -1,17 +1,14 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
-package form
+package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
-import "github.com/onsonr/sonr/pkg/styles/layout"
+func Form(action, id string) templ.Component {
 // Form is a standard form styled like a card
 func Form(action string, method string, submit templ.Component, progress string, enableCancel bool) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -32,7 +29,7 @@ func Form(action string, method string, submit templ.Component, progress string,
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<form action=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<form method=\"GET\" action=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -41,33 +38,33 @@ func Form(action string, method string, submit templ.Component, progress string,
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" method=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" id=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var3 string
-		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(method)
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(id)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/form/form.templ`, Line: 7, Col: 55}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_form.templ`, Line: 4, Col: 60}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><sl-card class=\"card-form gap-4 max-w-lg\"><div slot=\"header\"><div class=\"w-full py-1\"><sl-progress-bar value=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" hx-post=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var4 string
-		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(progress)
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(action)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/form/form.templ`, Line: 11, Col: 38}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_form.templ`, Line: 4, Col: 79}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></sl-progress-bar></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" hx-target=\"#{ id }\" hx-swap=\"outerHTML\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -75,21 +72,7 @@ func Form(action string, method string, submit templ.Component, progress string,
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div slot=\"footer\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</form>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		if enableCancel {
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-button href=\"/\" outline><sl-icon slot=\"prefix\" name=\"arrow-left\" library=\"sonr\"></sl-icon> Cancel</sl-button>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 		}
 		templ_7745c5c3_Err = submit.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><style>\n  \t\t.card-form [slot='footer'] {\n    \t\tdisplay: flex;\n    \t\tjustify-content: space-between;\n    \t\talign-items: center;\n  \t\t}\n\t\t</style></sl-card></form>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -97,7 +80,7 @@ func Form(action string, method string, submit templ.Component, progress string,
 	})
 }
-func NameInput() templ.Component {
+func FormHeader() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -118,25 +101,15 @@ func NameInput() templ.Component {
 			templ_7745c5c3_Var5 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var6 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div slot=\"header\"><div class=\"w-full py-2\">")
-			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_Err != nil {
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-input name=\"first_name\" placeholder=\"Steve\" type=\"text\" label=\"First Name\" required autofocus></sl-input> <sl-input name=\"last_name\" placeholder=\"J\" maxlength=\"1\" type=\"text\" label=\"Last Initial\"></sl-input>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
-		})
+		}
-		templ_7745c5c3_Err = layout.Rows().Render(templ.WithChildren(ctx, templ_7745c5c3_Var6), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = templ_7745c5c3_Var5.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -144,7 +117,44 @@ func NameInput() templ.Component {
 	})
 }
-func HandleInput() templ.Component {
+func FormBody() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var6 == nil {
 			templ_7745c5c3_Var6 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-card class=\"card-form max-w-lg mx-auto\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var6.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<style>\n\t\t.card-form {\n\t\t\t\tspace-y: 1rem;\n\t\t}\n\n  \t.card-form [slot='header'] {\n    \tdisplay: flex;\n    \talign-items: center;\n  \t  justify-content: space-between;\n\t  }\n\n\t  .card-form [slot='footer'] {\n   \t \tdisplay: flex;\n    \tjustify-content: space-between;\n    \talign-items: center;\n  \t}\n\t\t</style></sl-card>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func FormFooter() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -165,7 +175,15 @@ func HandleInput() templ.Component {
 			templ_7745c5c3_Var7 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-input name=\"handle\" placeholder=\"thoughtdiff\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required><div slot=\"prefix\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div></sl-input>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div slot=\"footer\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var7.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -173,7 +191,7 @@ func HandleInput() templ.Component {
 	})
 }
-func CodeInput(id string) templ.Component {
+func FormCancel() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -194,20 +212,7 @@ func CodeInput(id string) templ.Component {
 			templ_7745c5c3_Var8 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-input id=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-button href=\"/\" outline><sl-icon slot=\"prefix\" name=\"x-lg\"></sl-icon> Cancel</sl-button>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var9 string
 		templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(id)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/form/form.templ`, Line: 51, Col: 18}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" placeholder=\"●\" type=\"text\" maxlength=\"1\" pill class=\"w-min\"></sl-input>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -215,8 +220,7 @@ func CodeInput(id string) templ.Component {
 	})
 }
-// Hidden input and button which calls a javascript function to generate a passkey
+func FormSubmit(text string) templ.Component {
 func PasskeyInput(id string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -232,98 +236,21 @@ func PasskeyInput(id string) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var10 := templ.GetChildren(ctx)
+		templ_7745c5c3_Var9 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var10 == nil {
+		if templ_7745c5c3_Var9 == nil {
-			templ_7745c5c3_Var10 = templ.NopComponent
+			templ_7745c5c3_Var9 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Err = CredentialsScripts().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-button type=\"submit\" pill style=\"width: 100%;\"><sl-icon slot=\"prefix\" name=\"passkey\" library=\"sonr\" style=\"font-size: 20px;\"></sl-icon> Create PassKey <sl-icon slot=\"suffix\" name=\"arrow-right\" library=\"sonr\" style=\"font-size: 20px;\"></sl-icon></sl-button>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func TurnstileWidget(sitekey string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var11 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var11 == nil {
 			templ_7745c5c3_Var11 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		if sitekey != "" {
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<br><div class=\"cf-turnstile\" data-sitekey=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var12 string
 			templ_7745c5c3_Var12, templ_7745c5c3_Err = templ.JoinStringErrs(sitekey)
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/form/form.templ`, Line: 67, Col: 50}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var12))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></div>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func Submit(text string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var13 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var13 == nil {
 			templ_7745c5c3_Var13 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-button type=\"submit\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var14 string
+		var templ_7745c5c3_Var10 string
-		templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(text)
+		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(text)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/form/form.templ`, Line: 73, Col: 8}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_form.templ`, Line: 55, Col: 8}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -1,4 +1,4 @@
-package layout
+package views
 import "fmt"
@@ -11,6 +11,56 @@ var (
 	turnstileHandle = templ.NewOnceHandle()
 )
 templ Head(title string, nebulaVersion string) {
 	<head>
 		@Turnstile()
 		@Tailwind()
 		@Alpine()
 		@Htmx()
 		@Dexie()
 		@Nebula(nebulaVersion)
 		<meta charset="UTF-8"/>
 		<meta http-equiv="X-UA-Compatible" content="IE=edge"/>
 		<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
 		<title>{ title }</title>
 		<!-- Sets the status bar style to transparent -->
 		<meta name="apple-mobile-web-app-capable" content="yes"/>
 		<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent"/>
 		<link rel="icon" type="image/png" href="https://cdn.sonr.id/favicon.png"/>
 		<style>
   		@keyframes fade-in {
     		from { opacity: 0; }
   		}
   		@keyframes fade-out {
     		to { opacity: 0; }
   		}
   		@keyframes slide-from-right {
     		from { transform: translateX(90px); }
   		}
   		@keyframes slide-to-left {
     		to { transform: translateX(-90px); }
   		}
   		.slide-it {
     		view-transition-name: slide-it;
   		}
   		::view-transition-old(slide-it) {
     		animation: 180ms cubic-bezier(0.4, 0, 1, 1) both fade-out,
     		600ms cubic-bezier(0.4, 0, 0.2, 1) both slide-to-left;
   		}
   		::view-transition-new(slide-it) {
     		animation: 420ms cubic-bezier(0, 0, 0.2, 1) 90ms both fade-in,
     		600ms cubic-bezier(0.4, 0, 0.2, 1) both slide-from-right;
   		}
 		</style>
 		{ children... }
 	</head>
 }
 // ╭──────────────────────────────────────────────────────────╮
 // │                   3rd Party Libraries                    │
 // ╰──────────────────────────────────────────────────────────╯
@@ -18,7 +68,7 @@ var (
 // Tailwind css dependencies
 templ Tailwind() {
 	@tailwindHandle.Once() {
-		<script src="https://cdn.tailwindcss.com?plugins=typography,aspect-ratio,line-clamp,container-queries"></script>
+		<script src="https://cdn.tailwindcss.com?plugins=typography,aspect-ratio,container-queries"></script>
 		<script src="https://kit.fontawesome.com/9909219bb5.js" crossorigin="anonymous"></script>
 	}
 }
@@ -53,6 +103,8 @@ templ Htmx() {
 		<script src={ jsDelivrURL("htmx-ext-include-vals", "2.0.0", "include-vals.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-path-params", "2.0.0", "path-params.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-alpine-morph", "2.0.0", "alpine-morph.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-sse", "2.2.2", "sse.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-ws", "2.0.2", "ws.min.js") }></script>
 	}
 }
@@ -0,0 +1,573 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 import "fmt"
 var (
 	nebulaHandle    = templ.NewOnceHandle()
 	tailwindHandle  = templ.NewOnceHandle()
 	alpineHandle    = templ.NewOnceHandle()
 	dexieHandle     = templ.NewOnceHandle()
 	htmxHandle      = templ.NewOnceHandle()
 	turnstileHandle = templ.NewOnceHandle()
 )
 func Head(title string, nebulaVersion string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Turnstile().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Tailwind().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Alpine().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Htmx().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Dexie().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Nebula(nebulaVersion).Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<meta charset=\"UTF-8\"><meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"><title>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(title)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 25, Col: 16}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><!-- Sets the status bar style to transparent --><meta name=\"apple-mobile-web-app-capable\" content=\"yes\"><meta name=\"apple-mobile-web-app-status-bar-style\" content=\"black-translucent\"><link rel=\"icon\" type=\"image/png\" href=\"https://cdn.sonr.id/favicon.png\"><style>\n   \t\t@keyframes fade-in {\n     \t\tfrom { opacity: 0; }\n   \t\t}\n\n   \t\t@keyframes fade-out {\n     \t\tto { opacity: 0; }\n   \t\t}\n\n   \t\t@keyframes slide-from-right {\n     \t\tfrom { transform: translateX(90px); }\n   \t\t}\n\n   \t\t@keyframes slide-to-left {\n     \t\tto { transform: translateX(-90px); }\n   \t\t}\n\n   \t\t.slide-it {\n     \t\tview-transition-name: slide-it;\n   \t\t}\n\n   \t\t::view-transition-old(slide-it) {\n     \t\tanimation: 180ms cubic-bezier(0.4, 0, 1, 1) both fade-out,\n     \t\t600ms cubic-bezier(0.4, 0, 0.2, 1) both slide-to-left;\n   \t\t}\n   \t\t::view-transition-new(slide-it) {\n     \t\tanimation: 420ms cubic-bezier(0, 0, 0.2, 1) 90ms both fade-in,\n     \t\t600ms cubic-bezier(0.4, 0, 0.2, 1) both slide-from-right;\n   \t\t}\n\t\t</style>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var1.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</head>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // ╭──────────────────────────────────────────────────────────╮
 // │                   3rd Party Libraries                    │
 // ╰──────────────────────────────────────────────────────────╯
 // Tailwind css dependencies
 func Tailwind() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var3 == nil {
 			templ_7745c5c3_Var3 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var4 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script src=\"https://cdn.tailwindcss.com?plugins=typography,aspect-ratio,container-queries\"></script> <script src=\"https://kit.fontawesome.com/9909219bb5.js\" crossorigin=\"anonymous\"></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = tailwindHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var4), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // Turnstile is used for cloudflare challenges
 func Turnstile() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var5 == nil {
 			templ_7745c5c3_Var5 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var6 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script src=\"https://challenges.cloudflare.com/turnstile/v0/api.js\" async defer></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = turnstileHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var6), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // Alpine is a component that renders the Alpine.js library
 func Alpine() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var7 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var7 == nil {
 			templ_7745c5c3_Var7 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var8 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var9 string
 			templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("alpinejs", "3.14.6", "dist/cdn.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 86, Col: 68}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var10 string
 			templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@alpinejs/focus", "3.14.6", "dist/cdn.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 87, Col: 75}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = alpineHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var8), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // Dexie is a component that renders the Dexie.js library
 func Dexie() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var11 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var11 == nil {
 			templ_7745c5c3_Var11 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var12 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var13 string
 			templ_7745c5c3_Var13, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("dexie", "4.0.10", "dist/dexie.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 94, Col: 67}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var13))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var14 string
 			templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("dexie-export-import", "4.1.4", "dist/dexie-export-import.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 95, Col: 94}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = dexieHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var12), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // Htmx is a component that renders the Htmx.js library
 func Htmx() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var15 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var15 == nil {
 			templ_7745c5c3_Var15 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var16 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var17 string
 			templ_7745c5c3_Var17, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx.org", "1.9.12", "dist/htmx.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 102, Col: 69}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var17))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var18 string
 			templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-include-vals", "2.0.0", "include-vals.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 103, Col: 84}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var19 string
 			templ_7745c5c3_Var19, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-path-params", "2.0.0", "path-params.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 104, Col: 82}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var19))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var20 string
 			templ_7745c5c3_Var20, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-alpine-morph", "2.0.0", "alpine-morph.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 105, Col: 84}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var20))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var21 string
 			templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-sse", "2.2.2", "sse.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 106, Col: 66}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var22 string
 			templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-ws", "2.0.2", "ws.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 107, Col: 64}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = htmxHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var16), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // Nebula is a component that renders the Nebula.js library
 func Nebula(version string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var23 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var23 == nil {
 			templ_7745c5c3_Var23 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<link rel=\"stylesheet\" media=\"(prefers-color-scheme:light)\" href=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var24 string
 		templ_7745c5c3_Var24, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/light.css"))
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 116, Col: 71}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var24))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><link rel=\"stylesheet\" media=\"(prefers-color-scheme:dark)\" href=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var25 string
 		templ_7745c5c3_Var25, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/dark.css"))
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 121, Col: 70}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var25))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" onload=\"document.documentElement.classList.add(&#39;sl-theme-dark&#39;);\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Var26 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script type=\"module\" src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var27 string
 			templ_7745c5c3_Var27, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/shoelace-autoloader.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_head.templ`, Line: 125, Col: 98}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var27))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = nebulaHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var26), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // ╭───────────────────────────────────────────────────────────╮
 // │                      Helper Functions                     │
 // ╰───────────────────────────────────────────────────────────╯
 func jsDelivrURL(pkg string, version string, path string) string {
 	return fmt.Sprintf("https://cdn.jsdelivr.net/npm/%s@%s/%s", pkg, version, path)
 }
 var _ = templruntime.GeneratedTemplate
@@ -0,0 +1,36 @@
 package views
 templ HeroTitle(title string, subtitle string) {
 	<div class="flex flex-col items-center justify-center h-full w-full gap-2.5">
 		<h1 class="text-2xl md:text-3xl lg:text-4xl font-bold">
 			{ title }
 		</h1>
 		<p class="text-md md:text-lg lg:text-xl font-medium text-gray-500">
 			{ subtitle }
 		</p>
 	</div>
 }
 templ HeroStart() {
 	<div class="pt-1.5 mb-3 flex flex-col items-center justify-center h-full">
 		<sl-button size="large" hx-target="#container" hx-get="/register" hx-push-url="/register/start" type="button">
 			<sl-icon slot="prefix" library="sonr" name="sonr"></sl-icon>
 			Create Vault
 			<sl-icon slot="suffix" library="sonr" name="arrow-right"></sl-icon>
 		</sl-button>
 	</div>
 }
 templ HeroSocials() {
 	<div class="pt-1.5 flex flex-row items-center justify-center h-full gap-3">
 		<sl-button circle outline href="https://sonr.io">
 			<sl-icon name="home" library="sonr" label="Home"></sl-icon>
 		</sl-button>
 		<sl-button circle outline href="https://onsonr.dev">
 			<sl-icon name="docs" library="sonr" label="Docs"></sl-icon>
 		</sl-button>
 		<sl-button circle outline href="https://github.com/onsonr/sonr">
 			<sl-icon name="social-github" library="sonr" label="Open Source"></sl-icon>
 		</sl-button>
 	</div>
 }
@@ -0,0 +1,124 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 func HeroTitle(title string, subtitle string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center justify-center h-full w-full gap-2.5\"><h1 class=\"text-2xl md:text-3xl lg:text-4xl font-bold\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(title)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_hero.templ`, Line: 6, Col: 10}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</h1><p class=\"text-md md:text-lg lg:text-xl font-medium text-gray-500\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var3 string
 		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(subtitle)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_hero.templ`, Line: 9, Col: 13}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</p></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func HeroStart() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var4 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var4 == nil {
 			templ_7745c5c3_Var4 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"pt-1.5 mb-3 flex flex-col items-center justify-center h-full\"><sl-button size=\"large\" hx-target=\"#container\" hx-get=\"/register\" hx-push-url=\"/register/start\" type=\"button\"><sl-icon slot=\"prefix\" library=\"sonr\" name=\"sonr\"></sl-icon> Create Vault <sl-icon slot=\"suffix\" library=\"sonr\" name=\"arrow-right\"></sl-icon></sl-button></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func HeroSocials() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var5 == nil {
 			templ_7745c5c3_Var5 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"pt-1.5 flex flex-row items-center justify-center h-full gap-3\"><sl-button circle outline href=\"https://sonr.io\"><sl-icon name=\"home\" library=\"sonr\" label=\"Home\"></sl-icon></sl-button> <sl-button circle outline href=\"https://onsonr.dev\"><sl-icon name=\"docs\" library=\"sonr\" label=\"Docs\"></sl-icon></sl-button> <sl-button circle outline href=\"https://github.com/onsonr/sonr\"><sl-icon name=\"social-github\" library=\"sonr\" label=\"Open Source\"></sl-icon></sl-button></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 var _ = templruntime.GeneratedTemplate
@@ -0,0 +1,59 @@
 package views
 templ LayoutContainer() {
 	<div id="container" class="flex fixed inset-0 z-[99] w-screen min-h-screen">
 		<div class="relative flex flex-wrap items-center w-full min-h-full px-4 py-6 sm:px-6 md:px-8">
 			<div class="relative w-full max-w-screen-lg mx-auto">
 				<div class="flex flex-col items-center justify-center min-h-full gap-4">
 					{ children... }
 				</div>
 			</div>
 		</div>
 	</div>
 }
 // Columns is a component that renders a responsive flex container that stacks on mobile
 templ LayoutColumns() {
 	<div class="flex flex-col h-full w-full gap-4 md:gap-6 md:flex-row md:flex-wrap">
 		{ children... }
 	</div>
 }
 // Rows is a component that renders a responsive flex container that wraps on mobile
 templ LayoutRows() {
 	<div class="flex flex-col w-full gap-3 sm:flex-row sm:flex-wrap sm:gap-4">
 		{ children... }
 	</div>
 }
 templ LayoutSeparator(text string) {
 	<div class="relative py-6">
 		<div class="absolute inset-0 flex items-center"><span class="w-full border-t"></span></div>
 		<div class="relative flex justify-center text-xs uppercase">
 			<span class="px-2 text-neutral-500">{ text }</span>
 		</div>
 	</div>
 }
 // Layout is a component that renders the general layout of the application
 templ LayoutView(title string) {
 	<!DOCTYPE html>
 	<html lang="en">
 		@Head(title, "0.0.11")
 		<body class="flex items-center justify-center h-full lg:p-24 md:16 p-4 no-scrollbar">
 			<main class="flex-row items-center justify-center mx-auto w-fit max-w-screen-lg gap-y-3">
 				{ children... }
 			</main>
 		</body>
 	</html>
 }
 func Clsx(attrs ...templ.Attributes) templ.Attributes {
 	merged := templ.Attributes{}
 	for _, attr := range attrs {
 		for k, v := range attr {
 			merged[k] = v
 		}
 	}
 	return merged
 }
@@ -1,38 +1,14 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
-package layout
+package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
-type (
+func LayoutContainer() templ.Component {
 	Alignment   templ.Attributes
 	ScreenWidth templ.Attributes
 )
 var (
 	AlignCenter = Alignment{
 		"class": "flex items-center justify-center",
 	}
 	AlignEnd = Alignment{
 		"class": "flex items-end justify-center",
 	}
 	MaxWidthSmall = ScreenWidth{
 		"class": "max-w-screen-sm",
 	}
 	MaxWidthMedium = ScreenWidth{
 		"class": "max-w-screen-md",
 	}
 	MaxWidthFull = ScreenWidth{
 		"class": "w-full",
 	}
 )
 // Layout is a component that renders the general layout of the application
 func Root(title string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -53,15 +29,7 @@ func Root(title string) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<!doctype html><html lang=\"en\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div id=\"container\" class=\"flex fixed inset-0 z-[99] w-screen min-h-screen\"><div class=\"relative flex flex-wrap items-center w-full min-h-full px-4 py-6 sm:px-6 md:px-8\"><div class=\"relative w-full max-w-screen-lg mx-auto\"><div class=\"flex flex-col items-center justify-center min-h-full gap-4\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Head(title, "0.0.7").Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<body class=\"flex items-center justify-center h-full lg:p-24 md:16 p-4 no-scrollbar\"><main class=\"flex-row items-center justify-center mx-auto w-fit max-w-screen-sm gap-y-3\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -69,7 +37,7 @@ func Root(title string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</main></body></html>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -77,7 +45,8 @@ func Root(title string) templ.Component {
 	})
 }
-func Head(title string, nebulaVersion string) templ.Component {
+// Columns is a component that renders a responsive flex container that stacks on mobile
 func LayoutColumns() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -98,48 +67,7 @@ func Head(title string, nebulaVersion string) templ.Component {
 			templ_7745c5c3_Var2 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col h-full w-full gap-4 md:gap-6 md:flex-row md:flex-wrap\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Turnstile().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Tailwind().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Alpine().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Htmx().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Dexie().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Nebula(nebulaVersion).Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<meta charset=\"UTF-8\"><meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"><title>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var3 string
 		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(title)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/layout.templ`, Line: 50, Col: 16}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><!-- Sets the status bar style to transparent --><meta name=\"apple-mobile-web-app-capable\" content=\"yes\"><meta name=\"apple-mobile-web-app-status-bar-style\" content=\"black-translucent\"><link rel=\"icon\" type=\"image/png\" href=\"https://cdn.sonr.id/favicon.png\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -147,7 +75,7 @@ func Head(title string, nebulaVersion string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</head>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -155,7 +83,45 @@ func Head(title string, nebulaVersion string) templ.Component {
 	})
 }
-func Body(align Alignment, screenWidth ScreenWidth) templ.Component {
+// Rows is a component that renders a responsive flex container that wraps on mobile
 func LayoutRows() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var3 == nil {
 			templ_7745c5c3_Var3 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col w-full gap-3 sm:flex-row sm:flex-wrap sm:gap-4\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var3.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func LayoutSeparator(text string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -176,15 +142,66 @@ func Body(align Alignment, screenWidth ScreenWidth) templ.Component {
 			templ_7745c5c3_Var4 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<body class=\"flex items-center justify-center h-full lg:p-24 md:16 p-4 no-scrollbar\"><main class=\"flex-row items-center justify-center mx-auto w-fit max-w-screen-sm gap-y-3\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"relative py-6\"><div class=\"absolute inset-0 flex items-center\"><span class=\"w-full border-t\"></span></div><div class=\"relative flex justify-center text-xs uppercase\"><span class=\"px-2 text-neutral-500\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templ_7745c5c3_Var4.Render(ctx, templ_7745c5c3_Buffer)
+		var templ_7745c5c3_Var5 string
 		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(text)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/base_layout.templ`, Line: 33, Col: 45}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</main></body>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // Layout is a component that renders the general layout of the application
 func LayoutView(title string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var6 == nil {
 			templ_7745c5c3_Var6 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<!doctype html><html lang=\"en\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Head(title, "0.0.11").Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<body class=\"flex items-center justify-center h-full lg:p-24 md:16 p-4 no-scrollbar\"><main class=\"flex-row items-center justify-center mx-auto w-fit max-w-screen-lg gap-y-3\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var6.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</main></body></html>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -0,0 +1,14 @@
 package views
 templ ErrorView(err string) {
 	@LayoutView("Error | Sonr.ID") {
 		@LayoutContainer() {
 			@HeroTitle("Uh oh!", "Something went wrong.")
 			<div class="pt-3 flex flex-col items-center justify-center h-full">
 				<p class="text-red-500">
 					{ err }
 				</p>
 			</div>
 		}
 	}
 }
@@ -0,0 +1,93 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 func ErrorView(err string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			templ_7745c5c3_Var3 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 				if !templ_7745c5c3_IsBuffer {
 					defer func() {
 						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err == nil {
 							templ_7745c5c3_Err = templ_7745c5c3_BufErr
 						}
 					}()
 				}
 				ctx = templ.InitializeContext(ctx)
 				templ_7745c5c3_Err = HeroTitle("Uh oh!", "Something went wrong.").Render(ctx, templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" <div class=\"pt-3 flex flex-col items-center justify-center h-full\"><p class=\"text-red-500\">")
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				var templ_7745c5c3_Var4 string
 				templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(err)
 				if templ_7745c5c3_Err != nil {
 					return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/gateway/views/view_errors.templ`, Line: 9, Col: 10}
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</p></div>")
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				return templ_7745c5c3_Err
 			})
 			templ_7745c5c3_Err = LayoutContainer().Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = LayoutView("Error | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 var _ = templruntime.GeneratedTemplate
@@ -0,0 +1,26 @@
 package views
 templ InitialView() {
 	@LayoutView("Sonr.ID") {
 		@LayoutContainer() {
 			@HeroTitle("Sonr.ID", "The decentralized identity layer for the web.")
 			@HeroStart()
 			@HeroSocials()
 		}
 	}
 }
 templ ReturningView() {
 	@LayoutView("Login | Sonr.ID") {
 		@LayoutContainer() {
 			@HeroTitle("Welcome Back!", "Continue with your existing Sonr.ID.")
 			<div class="pt-3 flex flex-col items-center justify-center h-full">
 				<sl-button hx-target="#container" hx-get="/register" type="button">
 					<sl-icon slot="prefix" library="sonr" name="sonr"></sl-icon>
 					Log back in
 					<sl-icon slot="suffix" library="sonr" name="arrow-right"></sl-icon>
 				</sl-button>
 			</div>
 		}
 	}
 }
@@ -1,18 +1,13 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
-package index
+package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 import (
 	"github.com/onsonr/sonr/pkg/styles/layout"
 	"github.com/onsonr/sonr/pkg/styles/text"
 )
 func InitialView() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
@@ -58,23 +53,35 @@ func InitialView() templ.Component {
 					}()
 				}
 				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Err = text.Header("Sonr.ID", "The decentralized identity layer for the web.").Render(ctx, templ_7745c5c3_Buffer)
+				templ_7745c5c3_Err = HeroTitle("Sonr.ID", "The decentralized identity layer for the web.").Render(ctx, templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" <div class=\"pt-3 flex flex-col items-center justify-center h-full\"><sl-button hx-target=\"#container\" hx-get=\"/register\" type=\"button\"><sl-icon slot=\"prefix\" library=\"sonr\" name=\"sonr\"></sl-icon> Get Started <sl-icon slot=\"suffix\" library=\"sonr\" name=\"arrow-right\"></sl-icon></sl-button></div>")
+				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				templ_7745c5c3_Err = HeroStart().Render(ctx, templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				templ_7745c5c3_Err = HeroSocials().Render(ctx, templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				return templ_7745c5c3_Err
 			})
-			templ_7745c5c3_Err = layout.Container().Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
+			templ_7745c5c3_Err = LayoutContainer().Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = layout.Root("Welcome | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = LayoutView("Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -127,7 +134,7 @@ func ReturningView() templ.Component {
 					}()
 				}
 				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Err = text.Header("Welcome Back!", "Continue with your existing Sonr.ID.").Render(ctx, templ_7745c5c3_Buffer)
+				templ_7745c5c3_Err = HeroTitle("Welcome Back!", "Continue with your existing Sonr.ID.").Render(ctx, templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
@@ -137,13 +144,13 @@ func ReturningView() templ.Component {
 				}
 				return templ_7745c5c3_Err
 			})
-			templ_7745c5c3_Err = layout.Container().Render(templ.WithChildren(ctx, templ_7745c5c3_Var6), templ_7745c5c3_Buffer)
+			templ_7745c5c3_Err = LayoutContainer().Render(templ.WithChildren(ctx, templ_7745c5c3_Var6), templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = layout.Root("Login | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var5), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = LayoutView("Login | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var5), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -0,0 +1,9 @@
 package views
 templ LoadingView() {
 	@LayoutView("Loading... | Sonr.ID") {
 		@LayoutContainer() {
 			@HeroTitle("Loading Vault", "This will be used to login to your vault.")
 		}
 	}
 }
@@ -1,16 +1,14 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
-package index
+package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
-import "github.com/onsonr/sonr/pkg/styles/layout"
+func LoadingView() templ.Component {
 func NoWebauthnErrorView() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -43,13 +41,31 @@ func NoWebauthnErrorView() templ.Component {
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex fixed inset-0 z-[99] w-screen h-screen bg-white\"><div class=\"relative flex flex-wrap items-center w-full h-full px-8\"><div class=\"relative w-full max-w-sm mx-auto lg:mb-0\"><div class=\"flex flex-col items-center justify-center h-full\"><div class=\"flex flex-col items-center justify-center h-full\"><h1 class=\"text-3xl font-bold text-zinc-900 mb-4\">No WebAuthn Devices</h1><p class=\"text-lg text-zinc-500\">You don't have any WebAuthn devices connected to your computer.</p></div><div class=\"flex flex-col items-center justify-center h-full\"><button class=\"btn btn-sm text-zinc-100 bg-zinc-900 hover:bg-zinc-800 w-full shadow\">Get Started</button></div></div></div></div></div>")
+			templ_7745c5c3_Var3 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 				if !templ_7745c5c3_IsBuffer {
 					defer func() {
 						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err == nil {
 							templ_7745c5c3_Err = templ_7745c5c3_BufErr
 						}
 					}()
 				}
 				ctx = templ.InitializeContext(ctx)
 				templ_7745c5c3_Err = HeroTitle("Loading Vault", "This will be used to login to your vault.").Render(ctx, templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				return templ_7745c5c3_Err
 			})
 			templ_7745c5c3_Err = LayoutContainer().Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = layout.Root("Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = LayoutView("Loading... | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -0,0 +1,47 @@
 package views
 import "github.com/onsonr/sonr/app/gateway/islands"
 templ RegisterProfileView(firstNumber int, lastNumber int) {
 	@LayoutView("New Profile | Sonr.ID") {
 		@LayoutContainer() {
 			@HeroTitle("Basic Info", "Tell us a little about yourself.")
 			@Form("/register/passkey", "create-profile") {
 				@FormBody() {
 					@FormHeader() {
 						<div class="w-full py-2">
 							<sl-avatar shape="circle" size="large" src="https://avatars.githubusercontent.com/u/101929?v=4"></sl-avatar>
 						</div>
 					}
 					@islands.InputHandle()
 					@islands.HumanSlider(firstNumber, lastNumber)
 					@FormFooter() {
 						@FormCancel()
 						@FormSubmit("Next")
 					}
 				}
 			}
 		}
 	}
 }
 templ RegisterPasskeyView(address string, handle string, name string, challenge string, creationBlock string) {
 	@LayoutView("Register | Sonr.ID") {
 		@LayoutContainer() {
 			@HeroTitle("Link a PassKey", "This will be used to login to your vault.")
 			@Form("/register/finish", "passkey-form") {
 				<input type="hidden" name="credential" id="credential-data" required/>
 				@FormBody() {
 					@FormHeader() {
 						@islands.CardAccount(address, name, handle, creationBlock)
 					}
 					@islands.CoinSelect()
 					@FormFooter() {
 						@islands.InputPasskey(address, handle, challenge)
 						@FormCancel()
 					}
 				}
 			}
 		}
 	}
 }
@@ -0,0 +1,363 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 import "github.com/onsonr/sonr/app/gateway/islands"
 func RegisterProfileView(firstNumber int, lastNumber int) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			templ_7745c5c3_Var3 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 				if !templ_7745c5c3_IsBuffer {
 					defer func() {
 						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err == nil {
 							templ_7745c5c3_Err = templ_7745c5c3_BufErr
 						}
 					}()
 				}
 				ctx = templ.InitializeContext(ctx)
 				templ_7745c5c3_Err = HeroTitle("Basic Info", "Tell us a little about yourself.").Render(ctx, templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				templ_7745c5c3_Var4 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 					templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 					templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 					if !templ_7745c5c3_IsBuffer {
 						defer func() {
 							templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 							if templ_7745c5c3_Err == nil {
 								templ_7745c5c3_Err = templ_7745c5c3_BufErr
 							}
 						}()
 					}
 					ctx = templ.InitializeContext(ctx)
 					templ_7745c5c3_Var5 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 						templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 						templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 						if !templ_7745c5c3_IsBuffer {
 							defer func() {
 								templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 								if templ_7745c5c3_Err == nil {
 									templ_7745c5c3_Err = templ_7745c5c3_BufErr
 								}
 							}()
 						}
 						ctx = templ.InitializeContext(ctx)
 						templ_7745c5c3_Var6 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 							templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 							templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 							if !templ_7745c5c3_IsBuffer {
 								defer func() {
 									templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 									if templ_7745c5c3_Err == nil {
 										templ_7745c5c3_Err = templ_7745c5c3_BufErr
 									}
 								}()
 							}
 							ctx = templ.InitializeContext(ctx)
 							_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-full py-2\"><sl-avatar shape=\"circle\" size=\"large\" src=\"https://avatars.githubusercontent.com/u/101929?v=4\"></sl-avatar></div>")
 							if templ_7745c5c3_Err != nil {
 								return templ_7745c5c3_Err
 							}
 							return templ_7745c5c3_Err
 						})
 						templ_7745c5c3_Err = FormHeader().Render(templ.WithChildren(ctx, templ_7745c5c3_Var6), templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						templ_7745c5c3_Err = islands.InputHandle().Render(ctx, templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						templ_7745c5c3_Err = islands.HumanSlider(firstNumber, lastNumber).Render(ctx, templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						templ_7745c5c3_Var7 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 							templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 							templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 							if !templ_7745c5c3_IsBuffer {
 								defer func() {
 									templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 									if templ_7745c5c3_Err == nil {
 										templ_7745c5c3_Err = templ_7745c5c3_BufErr
 									}
 								}()
 							}
 							ctx = templ.InitializeContext(ctx)
 							templ_7745c5c3_Err = FormCancel().Render(ctx, templ_7745c5c3_Buffer)
 							if templ_7745c5c3_Err != nil {
 								return templ_7745c5c3_Err
 							}
 							_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 							if templ_7745c5c3_Err != nil {
 								return templ_7745c5c3_Err
 							}
 							templ_7745c5c3_Err = FormSubmit("Next").Render(ctx, templ_7745c5c3_Buffer)
 							if templ_7745c5c3_Err != nil {
 								return templ_7745c5c3_Err
 							}
 							return templ_7745c5c3_Err
 						})
 						templ_7745c5c3_Err = FormFooter().Render(templ.WithChildren(ctx, templ_7745c5c3_Var7), templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						return templ_7745c5c3_Err
 					})
 					templ_7745c5c3_Err = FormBody().Render(templ.WithChildren(ctx, templ_7745c5c3_Var5), templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err != nil {
 						return templ_7745c5c3_Err
 					}
 					return templ_7745c5c3_Err
 				})
 				templ_7745c5c3_Err = Form("/register/passkey", "create-profile").Render(templ.WithChildren(ctx, templ_7745c5c3_Var4), templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				return templ_7745c5c3_Err
 			})
 			templ_7745c5c3_Err = LayoutContainer().Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = LayoutView("New Profile | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func RegisterPasskeyView(address string, handle string, name string, challenge string, creationBlock string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var8 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var8 == nil {
 			templ_7745c5c3_Var8 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var9 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			templ_7745c5c3_Var10 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 				if !templ_7745c5c3_IsBuffer {
 					defer func() {
 						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err == nil {
 							templ_7745c5c3_Err = templ_7745c5c3_BufErr
 						}
 					}()
 				}
 				ctx = templ.InitializeContext(ctx)
 				templ_7745c5c3_Err = HeroTitle("Link a PassKey", "This will be used to login to your vault.").Render(ctx, templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				templ_7745c5c3_Var11 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 					templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 					templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 					if !templ_7745c5c3_IsBuffer {
 						defer func() {
 							templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 							if templ_7745c5c3_Err == nil {
 								templ_7745c5c3_Err = templ_7745c5c3_BufErr
 							}
 						}()
 					}
 					ctx = templ.InitializeContext(ctx)
 					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<input type=\"hidden\" name=\"credential\" id=\"credential-data\" required>")
 					if templ_7745c5c3_Err != nil {
 						return templ_7745c5c3_Err
 					}
 					templ_7745c5c3_Var12 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 						templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 						templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 						if !templ_7745c5c3_IsBuffer {
 							defer func() {
 								templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 								if templ_7745c5c3_Err == nil {
 									templ_7745c5c3_Err = templ_7745c5c3_BufErr
 								}
 							}()
 						}
 						ctx = templ.InitializeContext(ctx)
 						templ_7745c5c3_Var13 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 							templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 							templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 							if !templ_7745c5c3_IsBuffer {
 								defer func() {
 									templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 									if templ_7745c5c3_Err == nil {
 										templ_7745c5c3_Err = templ_7745c5c3_BufErr
 									}
 								}()
 							}
 							ctx = templ.InitializeContext(ctx)
 							templ_7745c5c3_Err = islands.CardAccount(address, name, handle, creationBlock).Render(ctx, templ_7745c5c3_Buffer)
 							if templ_7745c5c3_Err != nil {
 								return templ_7745c5c3_Err
 							}
 							return templ_7745c5c3_Err
 						})
 						templ_7745c5c3_Err = FormHeader().Render(templ.WithChildren(ctx, templ_7745c5c3_Var13), templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						templ_7745c5c3_Err = islands.CoinSelect().Render(ctx, templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						templ_7745c5c3_Var14 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 							templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 							templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 							if !templ_7745c5c3_IsBuffer {
 								defer func() {
 									templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 									if templ_7745c5c3_Err == nil {
 										templ_7745c5c3_Err = templ_7745c5c3_BufErr
 									}
 								}()
 							}
 							ctx = templ.InitializeContext(ctx)
 							templ_7745c5c3_Err = islands.InputPasskey(address, handle, challenge).Render(ctx, templ_7745c5c3_Buffer)
 							if templ_7745c5c3_Err != nil {
 								return templ_7745c5c3_Err
 							}
 							_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
 							if templ_7745c5c3_Err != nil {
 								return templ_7745c5c3_Err
 							}
 							templ_7745c5c3_Err = FormCancel().Render(ctx, templ_7745c5c3_Buffer)
 							if templ_7745c5c3_Err != nil {
 								return templ_7745c5c3_Err
 							}
 							return templ_7745c5c3_Err
 						})
 						templ_7745c5c3_Err = FormFooter().Render(templ.WithChildren(ctx, templ_7745c5c3_Var14), templ_7745c5c3_Buffer)
 						if templ_7745c5c3_Err != nil {
 							return templ_7745c5c3_Err
 						}
 						return templ_7745c5c3_Err
 					})
 					templ_7745c5c3_Err = FormBody().Render(templ.WithChildren(ctx, templ_7745c5c3_Var12), templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err != nil {
 						return templ_7745c5c3_Err
 					}
 					return templ_7745c5c3_Err
 				})
 				templ_7745c5c3_Err = Form("/register/finish", "passkey-form").Render(templ.WithChildren(ctx, templ_7745c5c3_Var11), templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
 				}
 				return templ_7745c5c3_Err
 			})
 			templ_7745c5c3_Err = LayoutContainer().Render(templ.WithChildren(ctx, templ_7745c5c3_Var10), templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = LayoutView("Register | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var9), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 var _ = templruntime.GeneratedTemplate
@@ -1,7 +1,7 @@
 //go:build js && wasm
 // +build js,wasm
-package internal
+package context
 import (
 	"encoding/base64"
@@ -10,7 +10,7 @@ import (
 	"github.com/labstack/echo/v4"
 )
-func WasmContextMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
+func WASMMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 	return func(c echo.Context) error {
 		// Extract WASM context from headers
 		if wasmCtx := c.Request().Header.Get("X-Wasm-Context"); wasmCtx != "" {
@@ -6,6 +6,6 @@ import (
 	"github.com/labstack/echo/v4"
 )
-func HandleDash(c echo.Context) error {
+func RenderIndex(c echo.Context) error {
 	return c.Render(http.StatusOK, "index.templ", nil)
 }
@@ -0,0 +1 @@
 package handlers
@@ -0,0 +1 @@
 package handlers
@@ -0,0 +1,41 @@
 //go:build js && wasm
 package vault
 import (
 	"github.com/labstack/echo/v4"
 	echomiddleware "github.com/labstack/echo/v4/middleware"
 	"github.com/onsonr/sonr/app/vault/context"
 	"github.com/onsonr/sonr/internal/config/motr"
 	"github.com/onsonr/sonr/internal/database/motrorm"
 )
 type Vault = *echo.Echo
 // New returns a new Vault instance
 func New(config *motr.Config, dbq *motrorm.Queries) (Vault, error) {
 	e := echo.New()
 	// Override default behaviors
 	e.IPExtractor = echo.ExtractIPDirect()
 	e.HTTPErrorHandler = handleError()
 	// Built-in middleware
 	e.Use(echomiddleware.Logger())
 	e.Use(echomiddleware.Recover())
 	e.Use(context.WASMMiddleware)
 	registerRoutes(e)
 	return e, nil
 }
 func handleError() echo.HTTPErrorHandler {
 	return func(err error, c echo.Context) {
 		if he, ok := err.(*echo.HTTPError); ok {
 			// Log the error if needed
 			c.Logger().Errorf("Error: %v", he.Message)
 		}
 	}
 }
 // RegisterRoutes registers the Decentralized Web Node API routes.
 func registerRoutes(e *echo.Echo) {
 }
@@ -0,0 +1,58 @@
 package views
 templ Form(action, id string) {
 	<form hx-post={ action } hx-target="#{ id }" hx-swap="outerHTML">
 		{ children... }
 	</form>
 }
 templ FormHeader() {
 	<div slot="header">
 		<div class="w-full py-2">
 			{ children... }
 		</div>
 	</div>
 }
 templ FormBody() {
 	<sl-card class="card-form max-w-lg mx-auto">
 		{ children... }
 		<style>
 		.card-form {
 				space-y: 1rem;
 		}
  	.card-form [slot='header'] {
    	display: flex;
    	align-items: center;
  	  justify-content: space-between;
 	  }
 	  .card-form [slot='footer'] {
   	 	display: flex;
    	justify-content: space-between;
    	align-items: center;
  	}
 		</style>
 	</sl-card>
 }
 templ FormFooter() {
 	<div slot="footer">
 		{ children... }
 	</div>
 }
 templ FormCancel() {
 	<sl-button href="/" outline>
 		<sl-icon slot="prefix" name="x-lg"></sl-icon>
 		Cancel
 	</sl-button>
 }
 templ FormSubmit(text string) {
 	<sl-button type="submit">
 		{ text }
 		<sl-icon slot="suffix" name="arrow-right" library="sonr"></sl-icon>
 	</sl-button>
 }
@@ -0,0 +1,243 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
 package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 func Form(action, id string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var1 == nil {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<form hx-post=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(action)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_form.templ`, Line: 4, Col: 23}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" hx-target=\"#{ id }\" hx-swap=\"outerHTML\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var1.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</form>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func FormHeader() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var3 == nil {
 			templ_7745c5c3_Var3 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div slot=\"header\"><div class=\"w-full py-2\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var3.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func FormBody() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var4 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var4 == nil {
 			templ_7745c5c3_Var4 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-card class=\"card-form max-w-lg mx-auto\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var4.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<style>\n\t\t.card-form {\n\t\t\t\tspace-y: 1rem;\n\t\t}\n\n  \t.card-form [slot='header'] {\n    \tdisplay: flex;\n    \talign-items: center;\n  \t  justify-content: space-between;\n\t  }\n\n\t  .card-form [slot='footer'] {\n   \t \tdisplay: flex;\n    \tjustify-content: space-between;\n    \talign-items: center;\n  \t}\n\t\t</style></sl-card>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func FormFooter() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var5 == nil {
 			templ_7745c5c3_Var5 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div slot=\"footer\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var5.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func FormCancel() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var6 == nil {
 			templ_7745c5c3_Var6 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-button href=\"/\" outline><sl-icon slot=\"prefix\" name=\"x-lg\"></sl-icon> Cancel</sl-button>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 func FormSubmit(text string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var7 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var7 == nil {
 			templ_7745c5c3_Var7 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-button type=\"submit\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var8 string
 		templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(text)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_form.templ`, Line: 55, Col: 8}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" <sl-icon slot=\"suffix\" name=\"arrow-right\" library=\"sonr\"></sl-icon></sl-button>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 var _ = templruntime.GeneratedTemplate
@@ -0,0 +1,135 @@
 package views
 import "fmt"
 var (
 	nebulaHandle    = templ.NewOnceHandle()
 	tailwindHandle  = templ.NewOnceHandle()
 	alpineHandle    = templ.NewOnceHandle()
 	dexieHandle     = templ.NewOnceHandle()
 	htmxHandle      = templ.NewOnceHandle()
 	turnstileHandle = templ.NewOnceHandle()
 )
 templ Head(title string, nebulaVersion string) {
 	<head>
 		@Turnstile()
 		@Tailwind()
 		@Alpine()
 		@Htmx()
 		@Dexie()
 		@Nebula(nebulaVersion)
 		<meta charset="UTF-8"/>
 		<meta http-equiv="X-UA-Compatible" content="IE=edge"/>
 		<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
 		<title>{ title }</title>
 		<!-- Sets the status bar style to transparent -->
 		<meta name="apple-mobile-web-app-capable" content="yes"/>
 		<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent"/>
 		<link rel="icon" type="image/png" href="https://cdn.sonr.id/favicon.png"/>
 		<style>
   		@keyframes fade-in {
     		from { opacity: 0; }
   		}
   		@keyframes fade-out {
     		to { opacity: 0; }
   		}
   		@keyframes slide-from-right {
     		from { transform: translateX(90px); }
   		}
   		@keyframes slide-to-left {
     		to { transform: translateX(-90px); }
   		}
   		.slide-it {
     		view-transition-name: slide-it;
   		}
   		::view-transition-old(slide-it) {
     		animation: 180ms cubic-bezier(0.4, 0, 1, 1) both fade-out,
     		600ms cubic-bezier(0.4, 0, 0.2, 1) both slide-to-left;
   		}
   		::view-transition-new(slide-it) {
     		animation: 420ms cubic-bezier(0, 0, 0.2, 1) 90ms both fade-in,
     		600ms cubic-bezier(0.4, 0, 0.2, 1) both slide-from-right;
   		}
 		</style>
 		{ children... }
 	</head>
 }
 // ╭──────────────────────────────────────────────────────────╮
 // │                   3rd Party Libraries                    │
 // ╰──────────────────────────────────────────────────────────╯
 // Tailwind css dependencies
 templ Tailwind() {
 	@tailwindHandle.Once() {
 		<script src="https://cdn.tailwindcss.com?plugins=typography,aspect-ratio,container-queries"></script>
 		<script src="https://kit.fontawesome.com/9909219bb5.js" crossorigin="anonymous"></script>
 	}
 }
 // Turnstile is used for cloudflare challenges
 templ Turnstile() {
 	@turnstileHandle.Once() {
 		<script src="https://challenges.cloudflare.com/turnstile/v0/api.js" async defer></script>
 	}
 }
 // Alpine is a component that renders the Alpine.js library
 templ Alpine() {
 	@alpineHandle.Once() {
 		<script src={ jsDelivrURL("alpinejs", "3.14.6", "dist/cdn.min.js") }></script>
 		<script src={ jsDelivrURL("@alpinejs/focus", "3.14.6", "dist/cdn.min.js") }></script>
 	}
 }
 // Dexie is a component that renders the Dexie.js library
 templ Dexie() {
 	@dexieHandle.Once() {
 		<script src={ jsDelivrURL("dexie", "4.0.10", "dist/dexie.min.js") }></script>
 		<script src={ jsDelivrURL("dexie-export-import", "4.1.4", "dist/dexie-export-import.min.js") }></script>
 	}
 }
 // Htmx is a component that renders the Htmx.js library
 templ Htmx() {
 	@htmxHandle.Once() {
 		<script src={ jsDelivrURL("htmx.org", "1.9.12", "dist/htmx.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-include-vals", "2.0.0", "include-vals.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-path-params", "2.0.0", "path-params.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-alpine-morph", "2.0.0", "alpine-morph.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-sse", "2.2.2", "sse.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-ws", "2.0.2", "ws.min.js") }></script>
 	}
 }
 // Nebula is a component that renders the Nebula.js library
 templ Nebula(version string) {
 	<link
 		rel="stylesheet"
 		media="(prefers-color-scheme:light)"
 		href={ jsDelivrURL("@onsonr/nebula", version, "cdn/themes/light.css") }
 	/>
 	<link
 		rel="stylesheet"
 		media="(prefers-color-scheme:dark)"
 		href={ jsDelivrURL("@onsonr/nebula", version, "cdn/themes/dark.css") }
 		onload="document.documentElement.classList.add('sl-theme-dark');"
 	/>
 	@nebulaHandle.Once() {
 		<script type="module" src={ jsDelivrURL("@onsonr/nebula", version, "cdn/shoelace-autoloader.js") }></script>
 	}
 }
 // ╭───────────────────────────────────────────────────────────╮
 // │                      Helper Functions                     │
 // ╰───────────────────────────────────────────────────────────╯
 func jsDelivrURL(pkg string, version string, path string) string {
 	return fmt.Sprintf("https://cdn.jsdelivr.net/npm/%s@%s/%s", pkg, version, path)
 }
@@ -1,7 +1,7 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
-package layout
+package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
@@ -19,12 +19,7 @@ var (
 	turnstileHandle = templ.NewOnceHandle()
 )
-// ╭──────────────────────────────────────────────────────────╮
+func Head(title string, nebulaVersion string) templ.Component {
 // │                   3rd Party Libraries                    │
 // ╰──────────────────────────────────────────────────────────╯
 // Tailwind css dependencies
 func Tailwind() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -45,25 +40,56 @@ func Tailwind() templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head>")
-			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_Err != nil {
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script src=\"https://cdn.tailwindcss.com?plugins=typography,aspect-ratio,line-clamp,container-queries\"></script> <script src=\"https://kit.fontawesome.com/9909219bb5.js\" crossorigin=\"anonymous\"></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
-		})
+		}
-		templ_7745c5c3_Err = tailwindHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = Turnstile().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Tailwind().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Alpine().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Htmx().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Dexie().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = Nebula(nebulaVersion).Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<meta charset=\"UTF-8\"><meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"><title>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(title)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 25, Col: 16}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><!-- Sets the status bar style to transparent --><meta name=\"apple-mobile-web-app-capable\" content=\"yes\"><meta name=\"apple-mobile-web-app-status-bar-style\" content=\"black-translucent\"><link rel=\"icon\" type=\"image/png\" href=\"https://cdn.sonr.id/favicon.png\"><style>\n   \t\t@keyframes fade-in {\n     \t\tfrom { opacity: 0; }\n   \t\t}\n\n   \t\t@keyframes fade-out {\n     \t\tto { opacity: 0; }\n   \t\t}\n\n   \t\t@keyframes slide-from-right {\n     \t\tfrom { transform: translateX(90px); }\n   \t\t}\n\n   \t\t@keyframes slide-to-left {\n     \t\tto { transform: translateX(-90px); }\n   \t\t}\n\n   \t\t.slide-it {\n     \t\tview-transition-name: slide-it;\n   \t\t}\n\n   \t\t::view-transition-old(slide-it) {\n     \t\tanimation: 180ms cubic-bezier(0.4, 0, 1, 1) both fade-out,\n     \t\t600ms cubic-bezier(0.4, 0, 0.2, 1) both slide-to-left;\n   \t\t}\n   \t\t::view-transition-new(slide-it) {\n     \t\tanimation: 420ms cubic-bezier(0, 0, 0.2, 1) 90ms both fade-in,\n     \t\t600ms cubic-bezier(0.4, 0, 0.2, 1) both slide-from-right;\n   \t\t}\n\t\t</style>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		templ_7745c5c3_Err = templ_7745c5c3_Var1.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</head>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -71,8 +97,12 @@ func Tailwind() templ.Component {
 	})
 }
-// Turnstile is used for cloudflare challenges
+// ╭──────────────────────────────────────────────────────────╮
-func Turnstile() templ.Component {
+// │                   3rd Party Libraries                    │
 // ╰──────────────────────────────────────────────────────────╯
 // Tailwind css dependencies
 func Tailwind() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -105,13 +135,13 @@ func Turnstile() templ.Component {
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script src=\"https://challenges.cloudflare.com/turnstile/v0/api.js\" async defer></script>")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script src=\"https://cdn.tailwindcss.com?plugins=typography,aspect-ratio,container-queries\"></script> <script src=\"https://kit.fontawesome.com/9909219bb5.js\" crossorigin=\"anonymous\"></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = turnstileHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var4), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = tailwindHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var4), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -119,8 +149,8 @@ func Turnstile() templ.Component {
 	})
 }
-// Alpine is a component that renders the Alpine.js library
+// Turnstile is used for cloudflare challenges
-func Alpine() templ.Component {
+func Turnstile() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -142,6 +172,54 @@ func Alpine() templ.Component {
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var6 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
 				defer func() {
 					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 					if templ_7745c5c3_Err == nil {
 						templ_7745c5c3_Err = templ_7745c5c3_BufErr
 					}
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script src=\"https://challenges.cloudflare.com/turnstile/v0/api.js\" async defer></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
 		templ_7745c5c3_Err = turnstileHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var6), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
 // Alpine is a component that renders the Alpine.js library
 func Alpine() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
 			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var7 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var7 == nil {
 			templ_7745c5c3_Var7 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		templ_7745c5c3_Var8 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
@@ -157,12 +235,12 @@ func Alpine() templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			var templ_7745c5c3_Var7 string
+			var templ_7745c5c3_Var9 string
-			templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("alpinejs", "3.14.6", "dist/cdn.min.js"))
+			templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("alpinejs", "3.14.6", "dist/cdn.min.js"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 36, Col: 68}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 86, Col: 68}
 			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -170,12 +248,12 @@ func Alpine() templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			var templ_7745c5c3_Var8 string
+			var templ_7745c5c3_Var10 string
-			templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@alpinejs/focus", "3.14.6", "dist/cdn.min.js"))
+			templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@alpinejs/focus", "3.14.6", "dist/cdn.min.js"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 37, Col: 75}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 87, Col: 75}
 			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -185,7 +263,7 @@ func Alpine() templ.Component {
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = alpineHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var6), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = alpineHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var8), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -210,12 +288,12 @@ func Dexie() templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var9 := templ.GetChildren(ctx)
+		templ_7745c5c3_Var11 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var9 == nil {
+		if templ_7745c5c3_Var11 == nil {
-			templ_7745c5c3_Var9 = templ.NopComponent
+			templ_7745c5c3_Var11 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var10 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Var12 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
@@ -231,12 +309,12 @@ func Dexie() templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			var templ_7745c5c3_Var11 string
+			var templ_7745c5c3_Var13 string
-			templ_7745c5c3_Var11, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("dexie", "4.0.10", "dist/dexie.min.js"))
+			templ_7745c5c3_Var13, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("dexie", "4.0.10", "dist/dexie.min.js"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 44, Col: 67}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 94, Col: 67}
 			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var11))
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var13))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -244,12 +322,12 @@ func Dexie() templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			var templ_7745c5c3_Var12 string
+			var templ_7745c5c3_Var14 string
-			templ_7745c5c3_Var12, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("dexie-export-import", "4.1.4", "dist/dexie-export-import.min.js"))
+			templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("dexie-export-import", "4.1.4", "dist/dexie-export-import.min.js"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 45, Col: 94}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 95, Col: 94}
 			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var12))
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -259,7 +337,7 @@ func Dexie() templ.Component {
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = dexieHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var10), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = dexieHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var12), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -284,12 +362,12 @@ func Htmx() templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var13 := templ.GetChildren(ctx)
+		templ_7745c5c3_Var15 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var13 == nil {
+		if templ_7745c5c3_Var15 == nil {
-			templ_7745c5c3_Var13 = templ.NopComponent
+			templ_7745c5c3_Var15 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var14 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Var16 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
@@ -305,36 +383,10 @@ func Htmx() templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var15 string
 			templ_7745c5c3_Var15, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx.org", "1.9.12", "dist/htmx.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 52, Col: 69}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var15))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var16 string
 			templ_7745c5c3_Var16, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-include-vals", "2.0.0", "include-vals.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 53, Col: 84}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var16))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var17 string
-			templ_7745c5c3_Var17, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-path-params", "2.0.0", "path-params.min.js"))
+			templ_7745c5c3_Var17, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx.org", "1.9.12", "dist/htmx.min.js"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 54, Col: 82}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 102, Col: 69}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var17))
 			if templ_7745c5c3_Err != nil {
@@ -345,21 +397,73 @@ func Htmx() templ.Component {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var18 string
-			templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-alpine-morph", "2.0.0", "alpine-morph.min.js"))
+			templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-include-vals", "2.0.0", "include-vals.min.js"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 55, Col: 84}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 103, Col: 84}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var19 string
 			templ_7745c5c3_Var19, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-path-params", "2.0.0", "path-params.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 104, Col: 82}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var19))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var20 string
 			templ_7745c5c3_Var20, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-alpine-morph", "2.0.0", "alpine-morph.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 105, Col: 84}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var20))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var21 string
 			templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-sse", "2.2.2", "sse.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 106, Col: 66}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var22 string
 			templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-ws", "2.0.2", "ws.min.js"))
 			if templ_7745c5c3_Err != nil {
 				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 107, Col: 64}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = htmxHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var14), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = htmxHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var16), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -384,21 +488,21 @@ func Nebula(version string) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var19 := templ.GetChildren(ctx)
+		templ_7745c5c3_Var23 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var19 == nil {
+		if templ_7745c5c3_Var23 == nil {
-			templ_7745c5c3_Var19 = templ.NopComponent
+			templ_7745c5c3_Var23 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<link rel=\"stylesheet\" media=\"(prefers-color-scheme:light)\" href=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var20 string
+		var templ_7745c5c3_Var24 string
-		templ_7745c5c3_Var20, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/light.css"))
+		templ_7745c5c3_Var24, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/light.css"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 64, Col: 71}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 116, Col: 71}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var20))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var24))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -406,12 +510,12 @@ func Nebula(version string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var21 string
+		var templ_7745c5c3_Var25 string
-		templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/dark.css"))
+		templ_7745c5c3_Var25, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/dark.css"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 69, Col: 70}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 121, Col: 70}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var25))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -419,7 +523,7 @@ func Nebula(version string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Var22 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Var26 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
@@ -435,12 +539,12 @@ func Nebula(version string) templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			var templ_7745c5c3_Var23 string
+			var templ_7745c5c3_Var27 string
-			templ_7745c5c3_Var23, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/shoelace-autoloader.js"))
+			templ_7745c5c3_Var27, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/shoelace-autoloader.js"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/layout/scripts.templ`, Line: 73, Col: 98}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_head.templ`, Line: 125, Col: 98}
 			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var23))
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var27))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -450,7 +554,7 @@ func Nebula(version string) templ.Component {
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = nebulaHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var22), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = nebulaHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var26), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -0,0 +1,36 @@
 package views
 templ HeroTitle(title string, subtitle string) {
 	<div class="flex flex-col items-center justify-center h-full w-full gap-2.5">
 		<h1 class="text-2xl md:text-3xl lg:text-4xl font-bold">
 			{ title }
 		</h1>
 		<p class="text-md md:text-lg lg:text-xl font-medium text-gray-500">
 			{ subtitle }
 		</p>
 	</div>
 }
 templ HeroStart() {
 	<div class="pt-1.5 mb-3 flex flex-col items-center justify-center h-full">
 		<sl-button size="large" hx-target="#container" hx-get="/register" hx-push-url="/register" type="button">
 			<sl-icon slot="prefix" library="sonr" name="sonr"></sl-icon>
 			Create Vault
 			<sl-icon slot="suffix" library="sonr" name="arrow-right"></sl-icon>
 		</sl-button>
 	</div>
 }
 templ HeroSocials() {
 	<div class="pt-1.5 flex flex-row items-center justify-center h-full gap-3">
 		<sl-button circle outline href="https://sonr.io">
 			<sl-icon name="home" library="sonr" label="Home"></sl-icon>
 		</sl-button>
 		<sl-button circle outline href="https://onsonr.dev">
 			<sl-icon name="docs" library="sonr" label="Docs"></sl-icon>
 		</sl-button>
 		<sl-button circle outline href="https://github.com/onsonr/sonr">
 			<sl-icon name="social-github" library="sonr" label="Open Source"></sl-icon>
 		</sl-button>
 	</div>
 }
@@ -1,14 +1,14 @@
 // Code generated by templ - DO NOT EDIT.
 // templ: version: v0.2.793
-package button
+package views
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
-func Primary(href string, text string) templ.Component {
+func HeroTitle(title string, subtitle string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -29,33 +29,33 @@ func Primary(href string, text string) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div><div class=\"btn cursor-pointer text-zinc-100 bg-zinc-900 hover:bg-zinc-800 w-full shadow\" hx-swap=\"afterend\" hx-get=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center justify-center h-full w-full gap-2.5\"><h1 class=\"text-2xl md:text-3xl lg:text-4xl font-bold\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(href)
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(title)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/button/default.templ`, Line: 5, Col: 124}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_hero.templ`, Line: 6, Col: 10}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</h1><p class=\"text-md md:text-lg lg:text-xl font-medium text-gray-500\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var3 string
-		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(text)
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(subtitle)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/button/default.templ`, Line: 6, Col: 9}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `app/vault/views/base_hero.templ`, Line: 9, Col: 13}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</p></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -63,7 +63,7 @@ func Primary(href string, text string) templ.Component {
 	})
 }
-func Secondary(href string, text string) templ.Component {
+func HeroStart() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -84,20 +84,36 @@ func Secondary(href string, text string) templ.Component {
 			templ_7745c5c3_Var4 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div><div x-on:click=\"toast(&#39;Default Toast Notification&#39;, &#39;default&#39;, &#39;&#39;, &#39;top-center&#39;)\" class=\"btn cursor-pointer text-zinc-600 bg-white hover:text-zinc-900 w-full shadow\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"pt-1.5 mb-3 flex flex-col items-center justify-center h-full\"><sl-button size=\"large\" hx-target=\"#container\" hx-get=\"/register\" hx-push-url=\"/register\" type=\"button\"><sl-icon slot=\"prefix\" library=\"sonr\" name=\"sonr\"></sl-icon> Create Vault <sl-icon slot=\"suffix\" library=\"sonr\" name=\"arrow-right\"></sl-icon></sl-button></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var5 string
+		return templ_7745c5c3_Err
-		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(text)
+	})
-		if templ_7745c5c3_Err != nil {
+}
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `pkg/styles/button/default.templ`, Line: 13, Col: 175}
+
 func HeroSocials() templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
 			return templ_7745c5c3_CtxErr
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if templ_7745c5c3_Err != nil {
+		if !templ_7745c5c3_IsBuffer {
-			return templ_7745c5c3_Err
+			defer func() {
 				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err == nil {
 					templ_7745c5c3_Err = templ_7745c5c3_BufErr
 				}
 			}()
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
+		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
 		if templ_7745c5c3_Var5 == nil {
 			templ_7745c5c3_Var5 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"pt-1.5 flex flex-row items-center justify-center h-full gap-3\"><sl-button circle outline href=\"https://sonr.io\"><sl-icon name=\"home\" library=\"sonr\" label=\"Home\"></sl-icon></sl-button> <sl-button circle outline href=\"https://onsonr.dev\"><sl-icon name=\"docs\" library=\"sonr\" label=\"Docs\"></sl-icon></sl-button> <sl-button circle outline href=\"https://github.com/onsonr/sonr\"><sl-icon name=\"social-github\" library=\"sonr\" label=\"Open Source\"></sl-icon></sl-button></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
--- a/Show More
+++ b/Show More