mirror of
https://github.com/sonr-io/sonr.git
synced 2026-08-02 17:31:39 +00:00
Prad Nukala
@@ -0,0 +1,16 @@
|
||||
[tool.commitizen]
|
||||
name = "cz_customize"
|
||||
tag_format = "pkg-es/v$version"
|
||||
ignored_tag_formats = ["*/v${version}", "v${version}"]
|
||||
version_scheme = "semver"
|
||||
version_provider = "npm"
|
||||
update_changelog_on_bump = true
|
||||
major_version_zero = true
|
||||
pre_bump_hooks = ["bash ../../scripts/hook-bump-pre.sh"]
|
||||
post_bump_hooks = ["pnpm --filter '@sonr.io/es' publish --no-git-checks"]
|
||||
|
||||
[tool.commitizen.customize]
|
||||
bump_pattern = "^(feat|fix|refactor|perf|BREAKING CHANGE)"
|
||||
bump_map = { "BREAKING CHANGE" = "MAJOR", "feat" = "MINOR", "fix" = "PATCH", "refactor" = "PATCH", "perf" = "PATCH" }
|
||||
default_bump = "PATCH"
|
||||
changelog_pattern = "^(feat|fix|refactor|docs|build)\\(pkg-es\\)(!)?:"
|
||||
@@ -0,0 +1,41 @@
|
||||
# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
|
||||
|
||||
# dependencies
|
||||
node_modules
|
||||
.pnp
|
||||
.pnp.js
|
||||
|
||||
# testing
|
||||
coverage
|
||||
|
||||
# build
|
||||
dist/
|
||||
|
||||
# production
|
||||
build
|
||||
|
||||
# misc
|
||||
.DS_Store
|
||||
*.pem
|
||||
.vscode
|
||||
.tmp
|
||||
|
||||
# debug
|
||||
npm-debug.log*
|
||||
yarn-debug.log*
|
||||
yarn-error.log*
|
||||
.pnpm-debug.log*
|
||||
|
||||
# local env files
|
||||
.env
|
||||
.env*.local
|
||||
|
||||
# vercel
|
||||
.vercel
|
||||
|
||||
# typescript
|
||||
*.tsbuildinfo
|
||||
|
||||
# turbo
|
||||
.turbo
|
||||
.aider*
|
||||
@@ -0,0 +1,692 @@
|
||||
# `@sonr.io/es`
|
||||
|
||||
A tree-shakeable, framework agnostic, [pure ESM](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c) alternative of [CosmJS](https://github.com/cosmos/cosmjs) and [Cosmos Kit](https://cosmoskit.com) (**generate bundles up to 10x smaller than Cosmos Kit**).
|
||||
|
||||
- [Features](#features)
|
||||
- [Installing](#installing)
|
||||
- [Using with TypeScript](#using-with-typescript)
|
||||
- [Using with Vite](#using-with-vite)
|
||||
- [Using Station wallet](#using-station-wallet)
|
||||
- [Examples](#examples)
|
||||
- [Modules](#modules)
|
||||
- [`@sonr.io/es/client`](#@sonr.io/esclient)
|
||||
- [`@sonr.io/es/codec`](#@sonr.io/escodec)
|
||||
- [`@sonr.io/es/protobufs`](#@sonr.io/esprotobufs)
|
||||
- [`@sonr.io/es/registry`](#@sonr.io/esregistry)
|
||||
- [`@sonr.io/es/wallet`](#@sonr.io/eswallet)
|
||||
- [`@sonr.io/es/ipfs`](#ipfs-integration)
|
||||
- [Benchmarks](#benchmarks)
|
||||
- [Results](#results)
|
||||
- [See More](#see-more)
|
||||
|
||||
## Features
|
||||
|
||||
- **Fully tree-shakeable**: import and bundle only the modules you need
|
||||
- **Framework agnostic**: integrate with any web framework (React, Vue, Svelte, Solid, etc.)
|
||||
- **Lightweight and minimal**: 153 KB gzipped to connect a React app to Keplr via browser extension or WalletConnect, 10x smaller than Cosmos Kit V2 (see [benchmarks](#benchmarks))
|
||||
- **Uses modern web APIs**: no dependencies on Node.js and minimal dependencies on third-party libraries where possible
|
||||
- **Supports modern bundlers**: works with Vite, SWC, Rollup, etc.
|
||||
- **Fully typed**: written in TypeScript and ships with type definitions
|
||||
|
||||
## Installing
|
||||
|
||||
For Cosmos SDK v0.47 and below:
|
||||
|
||||
```sh
|
||||
npm install @sonr.io/es
|
||||
|
||||
pnpm add @sonr.io/es
|
||||
|
||||
yarn add @sonr.io/es
|
||||
```
|
||||
|
||||
For Cosmos SDK v0.50, install using the `sdk50` tag:
|
||||
|
||||
```sh
|
||||
npm install @sonr.io/es@sdk50
|
||||
|
||||
pnpm add @sonr.io/es@sdk50
|
||||
|
||||
yarn add @sonr.io/es@sdk50
|
||||
```
|
||||
|
||||
> [!IMPORTANT]
|
||||
> The bump from v0.47 to v0.50 introduces significant breaking changes and is not recommended to be used unless necessary. To reduce the impact on consumers, the `main` branch and the published package on npm with the `latest` tag will continue to target v0.47 until the majority of live chains have migrated to v0.50.
|
||||
>
|
||||
> The [`parallel/sdk50`](https://github.com/coinhall/@sonr.io/es/tree/parallel/sdk50) branch targetting v0.50 will be developed and maintained in parallel with the `main` branch, where the same patch version number should have feature parity (eg. `@sonr.io/es@0.0.69` should have the same features as `@sonr.io/es@0.0.69-sdk50.0`).
|
||||
|
||||
### Using with TypeScript
|
||||
|
||||
This library only exports ES modules. To ensure imports from this library work correctly, the following configuration is required in `tsconfig.json`:
|
||||
|
||||
```ts
|
||||
{
|
||||
"compilerOptions": {
|
||||
"moduleResolution": "bundler", // recommended if using modern bundlers
|
||||
// or "node16"
|
||||
// or "nodenext"
|
||||
// but NOT "node"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Using with Vite
|
||||
|
||||
If you are using Vite, the following configuration is required in `vite.config.ts`:
|
||||
|
||||
```ts
|
||||
export default defineConfig({
|
||||
define: {
|
||||
global: "window",
|
||||
},
|
||||
});
|
||||
```
|
||||
|
||||
> This can be removed once support for WalletConnect v1 is no longer required.
|
||||
|
||||
### Using Station wallet
|
||||
|
||||
The Station wallet currently relies on WalletConnect v1. If you want to import and use `StationController`, a polyfill for `Buffer` is required:
|
||||
|
||||
```ts
|
||||
// First, install the buffer package
|
||||
npm install buffer
|
||||
|
||||
// Then, create a new file 'polyfill.ts'
|
||||
import { Buffer } from "buffer";
|
||||
(window as any).Buffer = Buffer;
|
||||
|
||||
// Finally, import the above file in your entry file
|
||||
import "./polyfill";
|
||||
```
|
||||
|
||||
See [`examples/solid-vite`](./examples/solid-vite) for a working example.
|
||||
|
||||
> This can be removed once support for WalletConnect v1 is no longer required.
|
||||
|
||||
## Examples
|
||||
|
||||
### Using the ESM Autoloader (Browser/CDN)
|
||||
|
||||
The library includes an autoloader that automatically initializes all modules and makes them available globally via `window.Sonr`. This is perfect for quick prototyping or when you want to use the library without a build system.
|
||||
|
||||
#### Method 1: Load from CDN
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Sonr ES Example</title>
|
||||
</head>
|
||||
<body>
|
||||
<!-- Load the autoloader from CDN -->
|
||||
<script type="module" src="https://unpkg.com/@sonr.io/es@latest/dist/autoloader.js"></script>
|
||||
|
||||
<script type="module">
|
||||
// Wait for the library to be ready
|
||||
window.addEventListener('sonr:ready', async (event) => {
|
||||
const Sonr = event.detail;
|
||||
console.log('Sonr is ready!', Sonr);
|
||||
|
||||
// Check WebAuthn availability
|
||||
if (await Sonr.webauthn.isAvailable()) {
|
||||
console.log('WebAuthn is available');
|
||||
|
||||
// Register with passkey
|
||||
const registration = await Sonr.webauthn.register({
|
||||
username: 'alice',
|
||||
displayName: 'Alice',
|
||||
rpId: window.location.hostname,
|
||||
rpName: 'My App'
|
||||
});
|
||||
console.log('Registration successful:', registration);
|
||||
}
|
||||
|
||||
// Access other modules
|
||||
console.log('Available modules:', {
|
||||
auth: Sonr.auth,
|
||||
client: Sonr.client,
|
||||
codec: Sonr.codec,
|
||||
wallet: Sonr.wallet,
|
||||
plugins: Sonr.plugins
|
||||
});
|
||||
});
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
#### Method 2: Import as ES Module
|
||||
|
||||
```html
|
||||
<script type="module">
|
||||
// Import the autoloader
|
||||
import Sonr from 'https://unpkg.com/@sonr.io/es@latest/dist/autoloader.js';
|
||||
|
||||
// Initialize with custom configuration
|
||||
await Sonr.init({
|
||||
enableMotor: true, // Enable Motor WASM plugin
|
||||
enableVault: true, // Enable Vault client
|
||||
motor: {
|
||||
wasmUrl: '/motor.wasm' // Custom WASM URL
|
||||
},
|
||||
vault: {
|
||||
endpoint: 'https://vault.example.com'
|
||||
}
|
||||
});
|
||||
|
||||
// Use the library
|
||||
console.log('Environment:', Sonr.getEnvironment());
|
||||
|
||||
// WebAuthn operations
|
||||
if (await Sonr.webauthn.isAvailable()) {
|
||||
// Login with passkey
|
||||
const login = await Sonr.webauthn.login({
|
||||
rpId: window.location.hostname
|
||||
});
|
||||
console.log('Login successful:', login);
|
||||
}
|
||||
</script>
|
||||
```
|
||||
|
||||
#### Method 3: Using in Node.js/Build Systems
|
||||
|
||||
```javascript
|
||||
// Import specific modules (tree-shakeable)
|
||||
import { registerWithPasskey, loginWithPasskey } from '@sonr.io/es/client/auth';
|
||||
import { createMotorPlugin } from '@sonr.io/es/plugins';
|
||||
import { bech32 } from '@sonr.io/es/codec';
|
||||
|
||||
// Or import the entire autoloader
|
||||
import Sonr from '@sonr.io/es/autoloader';
|
||||
|
||||
// Initialize and use
|
||||
async function main() {
|
||||
// Initialize Sonr
|
||||
await Sonr.init({
|
||||
enableMotor: true,
|
||||
enableVault: false
|
||||
});
|
||||
|
||||
// Use WebAuthn
|
||||
if (await Sonr.webauthn.isAvailable()) {
|
||||
const result = await Sonr.webauthn.register({
|
||||
username: 'bob',
|
||||
displayName: 'Bob Smith',
|
||||
rpId: 'example.com',
|
||||
rpName: 'Example App'
|
||||
});
|
||||
console.log('Registered:', result);
|
||||
}
|
||||
|
||||
// Access plugins
|
||||
const motor = await Sonr.createMotorPlugin();
|
||||
console.log('Motor plugin ready:', motor);
|
||||
|
||||
// Use codec utilities
|
||||
const address = Sonr.codec.bech32.encode('sonr', [1, 2, 3, 4]);
|
||||
console.log('Encoded address:', address);
|
||||
}
|
||||
|
||||
main();
|
||||
```
|
||||
|
||||
#### Autoloader API Reference
|
||||
|
||||
The autoloader exposes the following on `window.Sonr`:
|
||||
|
||||
```javascript
|
||||
window.Sonr = {
|
||||
// Core modules
|
||||
auth: {...}, // Authentication utilities
|
||||
client: {...}, // Blockchain client
|
||||
codec: {...}, // Encoding/decoding utilities
|
||||
wallet: {...}, // Wallet management
|
||||
registry: {...}, // Chain registry
|
||||
plugins: {...}, // WASM plugins (motor, vault)
|
||||
|
||||
// WebAuthn shortcuts
|
||||
webauthn: {
|
||||
register: registerWithPasskey,
|
||||
login: loginWithPasskey,
|
||||
isSupported: isWebAuthnSupported,
|
||||
isAvailable: isWebAuthnAvailable,
|
||||
isConditionalAvailable: isConditionalMediationAvailable,
|
||||
bufferToBase64url: bufferToBase64url,
|
||||
base64urlToBuffer: base64urlToBuffer
|
||||
},
|
||||
|
||||
// Plugin shortcuts
|
||||
motor: {...}, // Motor plugin namespace
|
||||
vault: {...}, // Vault plugin namespace
|
||||
|
||||
// Factory functions
|
||||
createMotorPlugin: Function,
|
||||
createVaultClient: Function,
|
||||
|
||||
// Utilities
|
||||
init: async (config) => {...}, // Initialize with config
|
||||
getEnvironment: () => {...}, // Get environment info
|
||||
isBrowser: Boolean, // Check if running in browser
|
||||
isNode: Boolean, // Check if running in Node.js
|
||||
version: String // Library version
|
||||
}
|
||||
```
|
||||
|
||||
#### Events
|
||||
|
||||
The autoloader dispatches the following events:
|
||||
|
||||
- `sonr:ready` - Fired when the library is fully loaded and initialized
|
||||
```javascript
|
||||
window.addEventListener('sonr:ready', (event) => {
|
||||
const Sonr = event.detail;
|
||||
console.log('Sonr is ready!', Sonr);
|
||||
});
|
||||
```
|
||||
|
||||
### Other Examples
|
||||
|
||||
See the [`examples`](./examples) folder for more detailed examples:
|
||||
|
||||
1. [How do I connect to third party wallets via browser extension or WalletConnect? How do I create, sign, and broadcast transactions?](./examples/solid-vite)
|
||||
2. [How do I programmatically sign and broadcast transactions without relying on a third party wallet?](./examples/mnemonic-wallet)
|
||||
3. [How do I verify signatures signed using the `signArbitrary` function?](./examples/verify-signatures)
|
||||
4. [How do I batch queries to the blockchain?](./examples/batch-query)
|
||||
5. [How do I use the ESM autoloader in a browser?](./examples/autoloader.html)
|
||||
|
||||
## Modules
|
||||
|
||||
This package is split into multiple subdirectories, with each subdirectory having their own set of functionalities. The root directory does not contain any exports, and all exports are exported from the subdirectories. Thus, imports must be done by referencing the subdirectories (ie. `import { ... } from "@sonr.io/es/client"`).
|
||||
|
||||
### `@sonr.io/es/client`
|
||||
|
||||
This directory contains models and helper functions to interact with Cosmos SDK via the [CometBFT RPC](https://docs.cosmos.network/v0.50/core/grpc_rest#cometbft-rpc).
|
||||
|
||||
### `@sonr.io/es/codec`
|
||||
|
||||
This directory contains various encoding and decoding functions that relies solely on [Web APIs](https://developer.mozilla.org/en-US/docs/Web/API) and has no dependencies on Node.js. For modern browsers and Node v16+, this should work out of the box.
|
||||
|
||||
### `@sonr.io/es/protobufs`
|
||||
|
||||
This directory contains the auto-generated code for various Cosmos SDK based protobufs. See `scripts/gen-protobufs.mjs` for the script that generates the code.
|
||||
|
||||
### `@sonr.io/es/registry`
|
||||
|
||||
This directory contains various APIs, data, and types needed for wallet interactions (ie. Keplr). Some types are auto-generated, see `scripts/gen-registry.mjs` for the script that generates the types.
|
||||
|
||||
### `@sonr.io/es/wallet`
|
||||
|
||||
This directory is a [Cosmos Kit](https://cosmoskit.com) alternative to interact with wallets across all Cosmos SDK based blockchains. See [`examples/solid-vite`](./examples/solid-vite) for a working example.
|
||||
|
||||
**Wallets supported**:
|
||||
|
||||
- [Station](https://docs.terra.money/learn/station/)
|
||||
- [Keplr](https://www.keplr.app/)
|
||||
- [Leap](https://www.leapwallet.io/)
|
||||
- [Cosmostation](https://wallet.cosmostation.io/)
|
||||
- [OWallet](https://owallet.dev/)
|
||||
- [Compass](https://compasswallet.io/) (for Sei only)
|
||||
- [MetaMask](https://metamask.io/) (for Injective only)
|
||||
- [Ninji](https://ninji.xyz/) (for Injective only)
|
||||
|
||||
**Features**:
|
||||
|
||||
- Supports both browser extension (desktop) and WalletConnect (mobile)
|
||||
- Unified interface for connecting, signing, broadcasting, and event handling
|
||||
- Signing of arbitrary messages (for wallets that support it)
|
||||
- Simultaneous connections to multiple WalletConnect wallets
|
||||
|
||||
## Benchmarks
|
||||
|
||||
See the [`benchmarks`](./benchmarks) folder, where the bundle size of SonrES is compared against Cosmos Kit. The following are adhered to:
|
||||
|
||||
- Apps should only contain the minimal functionality of connecting to Osmosis via Keplr using both the browser extension and WalletConnect wallets
|
||||
- Apps should be built using React 18 (as Cosmos Kit has a [hard dependency](https://docs.cosmoskit.com/get-started)) and Vite
|
||||
- Use the total sum of all generated bundles as reported by Vite after running the `vite build` command, including the size of all other dependencies like React/HTML/CSS/etc. (note: this is crude and not 100% accurate, but is the simplest method)
|
||||
|
||||
### Results
|
||||
|
||||
> Last updated: 4th May 2024
|
||||
|
||||
| Package | Minified | Gzipped |
|
||||
| ------------- | -------- | ------- |
|
||||
| SonrES | 553 KB | 153 KB |
|
||||
| Cosmos Kit v1 | 6010 KB | 1399 KB |
|
||||
| Cosmos Kit v2 | 6780 KB | 1556 KB |
|
||||
|
||||
## See More
|
||||
|
||||
- [Changelog](./CHANGELOG.md) - for notable changes
|
||||
|
||||
## IPFS Integration
|
||||
|
||||
The `@sonr.io/es` package now includes comprehensive IPFS/Helia support for distributed MPC enclave data storage. This integration enables secure, decentralized storage of vault encryption keys and sensitive cryptographic material.
|
||||
|
||||
### Features
|
||||
|
||||
- 🌐 **Modern IPFS with Helia**: Built on the latest Helia implementation for JavaScript/TypeScript
|
||||
- 🔐 **MPC Enclave Support**: Secure storage and retrieval of Multi-Party Computation enclave data
|
||||
- ⚡ **Performance Optimized**: LRU caching, connection pooling, and retry logic with exponential backoff
|
||||
- 🌍 **Browser & Node.js**: Full support for both environments with automatic transport selection
|
||||
- 🔄 **Gateway Fallbacks**: Automatic fallback to IPFS gateways when direct connections fail
|
||||
- 📦 **Batch Operations**: Efficient batch storage and retrieval of multiple enclaves
|
||||
- 🔍 **DWN Integration**: Query service for backend IPFS operations through Decentralized Web Nodes
|
||||
|
||||
### Quick Start
|
||||
|
||||
```typescript
|
||||
import { ipfs } from '@sonr.io/es';
|
||||
|
||||
// Create IPFS client
|
||||
const client = await ipfs.createIPFSClient({
|
||||
gateways: ['https://gateway.pinata.cloud'],
|
||||
enablePersistence: true,
|
||||
});
|
||||
|
||||
// Store enclave data
|
||||
const enclaveData = {
|
||||
publicKey: 'ed25519:...',
|
||||
privateKeyShares: ['share1', 'share2', 'share3'],
|
||||
threshold: 2,
|
||||
parties: 3,
|
||||
};
|
||||
|
||||
const { cid } = await client.addEnclaveData(
|
||||
new TextEncoder().encode(JSON.stringify(enclaveData))
|
||||
);
|
||||
|
||||
// Retrieve data
|
||||
const retrieved = await client.getEnclaveData(cid);
|
||||
const data = JSON.parse(new TextDecoder().decode(retrieved));
|
||||
|
||||
// Clean up
|
||||
await client.cleanup();
|
||||
```
|
||||
|
||||
### API Reference
|
||||
|
||||
#### IPFSClient
|
||||
|
||||
The main IPFS client for interacting with the network.
|
||||
|
||||
```typescript
|
||||
interface IPFSClient {
|
||||
initialize(): Promise<void>
|
||||
addEnclaveData(data: Uint8Array): Promise<EnclaveDataCID>
|
||||
getEnclaveData(cid: string): Promise<Uint8Array>
|
||||
pin(cid: string): Promise<void>
|
||||
unpin(cid: string): Promise<void>
|
||||
isPinned(cid: string): Promise<boolean>
|
||||
listPins(): Promise<string[]>
|
||||
getNodeStatus(): Promise<IPFSNodeStatus>
|
||||
cleanup(): Promise<void>
|
||||
}
|
||||
```
|
||||
|
||||
#### EnclaveIPFSManager
|
||||
|
||||
Manages MPC enclave data with encryption and integrity verification.
|
||||
|
||||
```typescript
|
||||
interface EnclaveIPFSManager {
|
||||
storeEnclaveData(
|
||||
data: EnclaveDataWithCID,
|
||||
payload: Uint8Array
|
||||
): Promise<EnclaveStorageResult>
|
||||
|
||||
retrieveEnclaveData(cid: string): Promise<Uint8Array>
|
||||
|
||||
verifyEnclaveDataIntegrity(
|
||||
cid: string,
|
||||
expectedData: Uint8Array
|
||||
): Promise<boolean>
|
||||
|
||||
batchStoreEnclaves(
|
||||
enclaves: Array<{data: EnclaveDataWithCID, payload: Uint8Array}>
|
||||
): Promise<EnclaveStorageResult[]>
|
||||
}
|
||||
```
|
||||
|
||||
#### VaultClientWithIPFS
|
||||
|
||||
Enhanced vault client with integrated IPFS support.
|
||||
|
||||
```typescript
|
||||
interface VaultClientWithIPFS extends VaultClient {
|
||||
initializeWithIPFS(
|
||||
wasmPath?: string,
|
||||
accountAddress?: string,
|
||||
ipfsConfig?: any
|
||||
): Promise<void>
|
||||
|
||||
storeEnclaveToIPFS(
|
||||
data: EnclaveDataWithCID,
|
||||
payload: Uint8Array
|
||||
): Promise<string>
|
||||
|
||||
retrieveEnclaveFromIPFS(cid: string): Promise<Uint8Array>
|
||||
|
||||
listPinnedEnclaves(): Promise<string[]>
|
||||
|
||||
syncWithIPFS(): Promise<void>
|
||||
}
|
||||
```
|
||||
|
||||
#### IPFSCache
|
||||
|
||||
High-performance caching layer with LRU eviction and TTL support.
|
||||
|
||||
```typescript
|
||||
interface IPFSCache {
|
||||
get(cid: string): Promise<Uint8Array | null>
|
||||
set(cid: string, data: Uint8Array, metadata?: any): Promise<void>
|
||||
has(cid: string): Promise<boolean>
|
||||
remove(cid: string): Promise<boolean>
|
||||
clear(): Promise<void>
|
||||
preload(
|
||||
cids: string[],
|
||||
fetchFn: (cid: string) => Promise<Uint8Array>
|
||||
): Promise<void>
|
||||
getStats(): CacheStats
|
||||
}
|
||||
```
|
||||
|
||||
### Configuration
|
||||
|
||||
#### IPFSClientConfig
|
||||
|
||||
```typescript
|
||||
interface IPFSClientConfig {
|
||||
gatewayUrl?: string // Primary IPFS gateway URL for content retrieval
|
||||
apiUrl?: string // IPFS API URL for node operations (e.g., pinning)
|
||||
gateways?: string[] // List of fallback IPFS gateway URLs
|
||||
enablePersistence?: boolean // Enable persistent storage
|
||||
libp2pConfig?: any // Custom libp2p configuration
|
||||
environment?: 'local' | 'testnet' | 'mainnet' // Auto-selects appropriate endpoints
|
||||
timeout?: number // Request timeout in milliseconds (default: 30000)
|
||||
maxRetries?: number // Max retries for failed requests (default: 3)
|
||||
}
|
||||
```
|
||||
|
||||
#### Default Configuration
|
||||
|
||||
```typescript
|
||||
const DEFAULT_IPFS_CONFIG = {
|
||||
gatewayUrl: 'https://gateway.pinata.cloud',
|
||||
apiUrl: 'http://localhost:5001', // Changes based on environment
|
||||
gateways: [
|
||||
'https://gateway.pinata.cloud',
|
||||
'https://ipfs.io',
|
||||
'https://cloudflare-ipfs.com',
|
||||
'https://dweb.link'
|
||||
],
|
||||
apiEndpoints: {
|
||||
local: 'http://localhost:5001',
|
||||
testnet: 'https://ipfs.testnet.sonr.io',
|
||||
mainnet: 'https://ipfs.sonr.io'
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Environment Variables
|
||||
|
||||
The IPFS client automatically detects and uses these environment variables:
|
||||
|
||||
- `IPFS_GATEWAY_URL` - Primary gateway URL
|
||||
- `IPFS_API_URL` - API endpoint URL
|
||||
- `SONR_ENV` - Environment ('local', 'testnet', 'mainnet')
|
||||
|
||||
```bash
|
||||
# Example .env file
|
||||
IPFS_GATEWAY_URL=https://my-custom-gateway.com
|
||||
IPFS_API_URL=https://my-ipfs-api.com:5001
|
||||
SONR_ENV=testnet
|
||||
```
|
||||
|
||||
#### EnclaveStorageConfig
|
||||
|
||||
```typescript
|
||||
interface EnclaveStorageConfig {
|
||||
encryptionRequired: boolean // Require encryption for all data
|
||||
pinningEnabled: boolean // Auto-pin stored data
|
||||
redundancy: number // Number of redundant copies
|
||||
maxRetries: number // Max retry attempts
|
||||
operationTimeout?: number // Operation timeout in ms
|
||||
}
|
||||
```
|
||||
|
||||
### Usage Examples
|
||||
|
||||
#### Basic Configuration
|
||||
|
||||
```typescript
|
||||
import { createIPFSClient, DEFAULT_IPFS_CONFIG } from '@sonr.io/es/ipfs'
|
||||
|
||||
// Use defaults
|
||||
const client = await createIPFSClient()
|
||||
|
||||
// Custom configuration
|
||||
const customClient = await createIPFSClient({
|
||||
gatewayUrl: 'https://my.gateway.com',
|
||||
apiUrl: 'https://my.api.com:5001',
|
||||
environment: 'testnet',
|
||||
timeout: 60000,
|
||||
maxRetries: 5
|
||||
})
|
||||
|
||||
// Update configuration dynamically
|
||||
client.updateConfig({
|
||||
gatewayUrl: 'https://new.gateway.com',
|
||||
timeout: 30000
|
||||
})
|
||||
|
||||
// Get current configuration
|
||||
const config = client.getConfig()
|
||||
console.log('Using gateway:', config.gatewayUrl)
|
||||
```
|
||||
|
||||
#### Using the API Methods
|
||||
|
||||
```typescript
|
||||
// Add content via HTTP API (requires apiUrl configuration)
|
||||
const data = new Uint8Array([1, 2, 3, 4])
|
||||
const cid = await client.addViaAPI(data)
|
||||
console.log('Added via API:', cid)
|
||||
|
||||
// Pin content to prevent garbage collection
|
||||
await client.pinViaAPI(cid)
|
||||
|
||||
// Get IPFS node information
|
||||
const nodeInfo = await client.getNodeInfoViaAPI()
|
||||
console.log('Node ID:', nodeInfo.ID)
|
||||
console.log('Agent:', nodeInfo.AgentVersion)
|
||||
```
|
||||
|
||||
See the [examples directory](./examples/ipfs-enclave-usage.ts) for comprehensive usage examples including:
|
||||
|
||||
- Basic IPFS operations
|
||||
- MPC enclave storage
|
||||
- Vault integration
|
||||
- Caching strategies
|
||||
- Error handling
|
||||
- Performance optimization
|
||||
|
||||
### Performance Best Practices
|
||||
|
||||
1. **Use Caching Aggressively**: Enable the cache layer for frequently accessed data
|
||||
2. **Batch Operations**: Use batch methods when storing/retrieving multiple items
|
||||
3. **Preload Critical Data**: Use cache preloading for known CIDs
|
||||
4. **Configure Gateways**: Provide multiple gateway URLs for redundancy
|
||||
5. **Set Appropriate Timeouts**: Configure timeouts based on your network conditions
|
||||
6. **Monitor Cache Stats**: Use cache statistics to optimize hit rates
|
||||
|
||||
### Troubleshooting
|
||||
|
||||
#### Common Issues
|
||||
|
||||
**Connection Failed**
|
||||
```typescript
|
||||
// Provide fallback gateways
|
||||
const client = await createIPFSClient({
|
||||
gateways: [
|
||||
'http://localhost:5001', // Local node
|
||||
'https://gateway.pinata.cloud', // Public gateway
|
||||
'https://ipfs.io' // Fallback
|
||||
]
|
||||
});
|
||||
```
|
||||
|
||||
**Slow Retrieval**
|
||||
```typescript
|
||||
// Enable caching for better performance
|
||||
const cache = createIPFSCache({
|
||||
maxSize: 200,
|
||||
ttl: 300000, // 5 minutes
|
||||
enablePersistence: true
|
||||
});
|
||||
|
||||
// Preload frequently used CIDs
|
||||
await cache.preload(cids, fetchFunction);
|
||||
```
|
||||
|
||||
**Network Timeouts**
|
||||
```typescript
|
||||
// Configure retry logic
|
||||
const manager = new EnclaveIPFSManager(client, {
|
||||
maxRetries: 5,
|
||||
operationTimeout: 30000 // 30 seconds
|
||||
});
|
||||
```
|
||||
|
||||
### Security Considerations
|
||||
|
||||
1. **Always Encrypt Sensitive Data**: Use consensus-based encryption for enclave data
|
||||
2. **Verify CID Integrity**: Always verify retrieved data matches expected CID
|
||||
3. **Use HTTPS Gateways**: Prefer HTTPS gateways over HTTP
|
||||
4. **Validate Enclave Structure**: Validate threshold and parties before storage
|
||||
5. **Implement Access Control**: Use UCAN tokens for authorization
|
||||
|
||||
### Testing
|
||||
|
||||
Run unit tests:
|
||||
```bash
|
||||
pnpm test
|
||||
```
|
||||
|
||||
Run integration tests (requires Docker):
|
||||
```bash
|
||||
docker-compose up -d ipfs
|
||||
pnpm test:integration
|
||||
```
|
||||
|
||||
### Dependencies
|
||||
|
||||
- `helia`: Core IPFS implementation
|
||||
- `@helia/unixfs`: UnixFS for file operations
|
||||
- `@helia/verified-fetch`: Verified content fetching
|
||||
- `@libp2p/webrtc`: WebRTC transport
|
||||
- `@libp2p/websockets`: WebSocket transport
|
||||
- `multiformats`: CID and multiformat support
|
||||
- `@tanstack/query-core`: Query caching for DWN service
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
{
|
||||
"$schema": "https://biomejs.dev/schemas/2.1.4/schema.json",
|
||||
"extends": ["../../biome.json"],
|
||||
"linter": {
|
||||
"rules": {
|
||||
"suspicious": {
|
||||
"noExplicitAny": "off"
|
||||
},
|
||||
"correctness": {
|
||||
"noUnusedVariables": "warn"
|
||||
},
|
||||
"complexity": {
|
||||
"noStaticOnlyClass": "off"
|
||||
},
|
||||
"style": {
|
||||
"useTemplate": "warn",
|
||||
"noUnusedTemplateLiteral": "warn"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
# see: https://docs.buf.build/configuration/v1/buf-gen-yaml
|
||||
version: v1
|
||||
plugins:
|
||||
- plugin: es
|
||||
opt: target=ts
|
||||
out: .
|
||||
- plugin: cosmes
|
||||
path: ./scripts/protoc-gen-cosmes.mjs
|
||||
opt: target=ts
|
||||
out: .
|
||||
@@ -0,0 +1,2 @@
|
||||
# Generated by buf. DO NOT EDIT.
|
||||
version: v1
|
||||
@@ -0,0 +1,263 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>Sonr ES Autoloader Example</title>
|
||||
<style>
|
||||
body {
|
||||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
|
||||
max-width: 1200px;
|
||||
margin: 0 auto;
|
||||
padding: 20px;
|
||||
background: #f5f5f5;
|
||||
}
|
||||
h1 {
|
||||
color: #333;
|
||||
border-bottom: 2px solid #4CAF50;
|
||||
padding-bottom: 10px;
|
||||
}
|
||||
.section {
|
||||
background: white;
|
||||
border-radius: 8px;
|
||||
padding: 20px;
|
||||
margin: 20px 0;
|
||||
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
|
||||
}
|
||||
.status {
|
||||
padding: 10px;
|
||||
border-radius: 4px;
|
||||
margin: 10px 0;
|
||||
}
|
||||
.success {
|
||||
background: #d4edda;
|
||||
color: #155724;
|
||||
border: 1px solid #c3e6cb;
|
||||
}
|
||||
.error {
|
||||
background: #f8d7da;
|
||||
color: #721c24;
|
||||
border: 1px solid #f5c6cb;
|
||||
}
|
||||
.info {
|
||||
background: #d1ecf1;
|
||||
color: #0c5460;
|
||||
border: 1px solid #bee5eb;
|
||||
}
|
||||
button {
|
||||
background: #4CAF50;
|
||||
color: white;
|
||||
border: none;
|
||||
padding: 10px 20px;
|
||||
border-radius: 4px;
|
||||
cursor: pointer;
|
||||
font-size: 16px;
|
||||
margin: 5px;
|
||||
}
|
||||
button:hover {
|
||||
background: #45a049;
|
||||
}
|
||||
button:disabled {
|
||||
background: #ccc;
|
||||
cursor: not-allowed;
|
||||
}
|
||||
pre {
|
||||
background: #f4f4f4;
|
||||
padding: 10px;
|
||||
border-radius: 4px;
|
||||
overflow-x: auto;
|
||||
}
|
||||
code {
|
||||
font-family: 'Courier New', Courier, monospace;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<h1>Sonr ES Autoloader Example</h1>
|
||||
|
||||
<div class="section">
|
||||
<h2>Library Status</h2>
|
||||
<div id="loadStatus" class="status info">Loading Sonr ES library...</div>
|
||||
<div id="environment" class="status info" style="display: none;"></div>
|
||||
</div>
|
||||
|
||||
<div class="section">
|
||||
<h2>WebAuthn Demo</h2>
|
||||
<div id="webauthnStatus" class="status info">Checking WebAuthn availability...</div>
|
||||
|
||||
<div id="webauthnDemo" style="display: none;">
|
||||
<h3>Register with Passkey</h3>
|
||||
<input type="text" id="username" placeholder="Enter username" style="padding: 8px; margin: 5px;">
|
||||
<button id="registerBtn" onclick="registerUser()">Register</button>
|
||||
|
||||
<h3>Login with Passkey</h3>
|
||||
<button id="loginBtn" onclick="loginUser()">Login</button>
|
||||
|
||||
<div id="webauthnResult" style="margin-top: 20px;"></div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="section">
|
||||
<h2>Available Modules</h2>
|
||||
<div id="modules"></div>
|
||||
</div>
|
||||
|
||||
<div class="section">
|
||||
<h2>Console Output</h2>
|
||||
<pre id="console"></pre>
|
||||
</div>
|
||||
|
||||
<!-- Load the Sonr ES autoloader -->
|
||||
<script type="module">
|
||||
// Import from local build (change to CDN URL in production)
|
||||
import '../dist/autoloader.js';
|
||||
|
||||
// Custom console logger
|
||||
const consoleEl = document.getElementById('console');
|
||||
const originalLog = console.log;
|
||||
console.log = function(...args) {
|
||||
originalLog.apply(console, args);
|
||||
const message = args.map(arg =>
|
||||
typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg
|
||||
).join(' ');
|
||||
consoleEl.textContent += message + '\n';
|
||||
};
|
||||
|
||||
// Wait for Sonr to be ready
|
||||
window.addEventListener('sonr:ready', (event) => {
|
||||
const Sonr = event.detail;
|
||||
|
||||
// Update load status
|
||||
document.getElementById('loadStatus').className = 'status success';
|
||||
document.getElementById('loadStatus').textContent = 'Sonr ES library loaded successfully!';
|
||||
|
||||
// Show environment info
|
||||
const env = Sonr.getEnvironment();
|
||||
document.getElementById('environment').style.display = 'block';
|
||||
document.getElementById('environment').innerHTML = `
|
||||
<strong>Environment:</strong> ${env.type}<br>
|
||||
<strong>WebAuthn:</strong> ${env.webauthn ? 'Supported' : 'Not supported'}<br>
|
||||
<strong>Service Worker:</strong> ${env.serviceWorker ? 'Supported' : 'Not supported'}
|
||||
`;
|
||||
|
||||
// Check WebAuthn
|
||||
checkWebAuthn();
|
||||
|
||||
// List available modules
|
||||
listModules();
|
||||
});
|
||||
|
||||
async function checkWebAuthn() {
|
||||
if (window.Sonr && window.Sonr.webauthn) {
|
||||
const isAvailable = await window.Sonr.webauthn.isAvailable();
|
||||
const isConditional = await window.Sonr.webauthn.isConditionalAvailable();
|
||||
|
||||
const statusEl = document.getElementById('webauthnStatus');
|
||||
if (isAvailable) {
|
||||
statusEl.className = 'status success';
|
||||
statusEl.innerHTML = `
|
||||
WebAuthn is available!<br>
|
||||
Conditional mediation (autofill): ${isConditional ? 'Supported' : 'Not supported'}
|
||||
`;
|
||||
document.getElementById('webauthnDemo').style.display = 'block';
|
||||
} else {
|
||||
statusEl.className = 'status error';
|
||||
statusEl.textContent = 'WebAuthn is not available in this browser';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function listModules() {
|
||||
const modulesEl = document.getElementById('modules');
|
||||
if (window.Sonr) {
|
||||
const modules = [
|
||||
'auth - Authentication utilities',
|
||||
'client - Blockchain client',
|
||||
'codec - Encoding/decoding utilities',
|
||||
'wallet - Wallet management',
|
||||
'registry - Chain registry',
|
||||
'plugins - WASM plugins (motor, vault)',
|
||||
'webauthn - WebAuthn shortcuts'
|
||||
];
|
||||
|
||||
modulesEl.innerHTML = '<ul>' +
|
||||
modules.map(m => `<li><code>window.Sonr.${m.split(' - ')[0]}</code> - ${m.split(' - ')[1]}</li>`).join('') +
|
||||
'</ul>';
|
||||
}
|
||||
}
|
||||
|
||||
// Make functions available globally
|
||||
window.registerUser = async function() {
|
||||
const username = document.getElementById('username').value;
|
||||
if (!username) {
|
||||
alert('Please enter a username');
|
||||
return;
|
||||
}
|
||||
|
||||
const resultEl = document.getElementById('webauthnResult');
|
||||
resultEl.className = 'status info';
|
||||
resultEl.textContent = 'Starting registration...';
|
||||
|
||||
try {
|
||||
const result = await window.Sonr.webauthn.register({
|
||||
username,
|
||||
displayName: username,
|
||||
// Add your RP info here
|
||||
rpId: window.location.hostname,
|
||||
rpName: 'Sonr ES Demo'
|
||||
});
|
||||
|
||||
console.log('Registration successful:', result);
|
||||
resultEl.className = 'status success';
|
||||
resultEl.innerHTML = `
|
||||
<strong>Registration successful!</strong><br>
|
||||
Credential ID: ${result.credentialId}<br>
|
||||
User verified: ${result.userVerified}
|
||||
`;
|
||||
} catch (error) {
|
||||
console.error('Registration failed:', error);
|
||||
resultEl.className = 'status error';
|
||||
resultEl.textContent = `Registration failed: ${error.message}`;
|
||||
}
|
||||
};
|
||||
|
||||
window.loginUser = async function() {
|
||||
const resultEl = document.getElementById('webauthnResult');
|
||||
resultEl.className = 'status info';
|
||||
resultEl.textContent = 'Starting login...';
|
||||
|
||||
try {
|
||||
const result = await window.Sonr.webauthn.login({
|
||||
rpId: window.location.hostname
|
||||
});
|
||||
|
||||
console.log('Login successful:', result);
|
||||
resultEl.className = 'status success';
|
||||
resultEl.innerHTML = `
|
||||
<strong>Login successful!</strong><br>
|
||||
Credential ID: ${result.credentialId}<br>
|
||||
User verified: ${result.userVerified}
|
||||
`;
|
||||
} catch (error) {
|
||||
console.error('Login failed:', error);
|
||||
resultEl.className = 'status error';
|
||||
resultEl.textContent = `Login failed: ${error.message}`;
|
||||
}
|
||||
};
|
||||
</script>
|
||||
|
||||
<!-- Alternative: Load from CDN -->
|
||||
<!-- <script type="module" src="https://unpkg.com/@sonr.io/es@latest/dist/autoloader.js"></script> -->
|
||||
|
||||
<!-- Alternative: Load with regular script tag (non-module) -->
|
||||
<!--
|
||||
<script>
|
||||
// The library will be available as window.Sonr after loading
|
||||
window.addEventListener('sonr:ready', function(event) {
|
||||
console.log('Sonr is ready!', window.Sonr);
|
||||
});
|
||||
</script>
|
||||
<script src="https://unpkg.com/@sonr.io/es@latest/dist/autoloader.js"></script>
|
||||
-->
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,489 @@
|
||||
/**
|
||||
* Usage examples for IPFS/Helia integration with MPC enclave data
|
||||
*
|
||||
* This file demonstrates how to use the IPFS integration for
|
||||
* storing and retrieving MPC enclave data in the Sonr ecosystem.
|
||||
*/
|
||||
|
||||
import {
|
||||
// IPFS client
|
||||
IPFSClient,
|
||||
createIPFSClient,
|
||||
type IPFSClientConfig,
|
||||
// Enclave manager
|
||||
EnclaveIPFSManager,
|
||||
createEnclaveIPFSManager,
|
||||
type EnclaveDataWithCID,
|
||||
// Enhanced vault client
|
||||
VaultClientWithIPFS,
|
||||
createVaultClientWithIPFS,
|
||||
// Caching
|
||||
IPFSCache,
|
||||
createIPFSCache,
|
||||
// DWN query service
|
||||
DWNIPFSQueryService,
|
||||
createDWNIPFSQueryService,
|
||||
} from '@sonr.io/es';
|
||||
|
||||
// ============================================
|
||||
// Example 1: Basic IPFS Client Usage
|
||||
// ============================================
|
||||
async function basicIPFSExample() {
|
||||
console.log('🌐 Basic IPFS Client Example');
|
||||
|
||||
// Create and initialize IPFS client
|
||||
const ipfsClient = await createIPFSClient({
|
||||
gateways: ['https://gateway.pinata.cloud', 'https://ipfs.io'],
|
||||
enablePersistence: true,
|
||||
});
|
||||
|
||||
try {
|
||||
// Store data
|
||||
const data = new TextEncoder().encode('Hello from Sonr!');
|
||||
const { cid, size, timestamp } = await ipfsClient.addEnclaveData(data);
|
||||
console.log(`✅ Stored data with CID: ${cid} (${size} bytes)`);
|
||||
|
||||
// Retrieve data
|
||||
const retrieved = await ipfsClient.getEnclaveData(cid);
|
||||
const text = new TextDecoder().decode(retrieved);
|
||||
console.log(`✅ Retrieved: "${text}"`);
|
||||
|
||||
// Get node status
|
||||
const status = await ipfsClient.getNodeStatus();
|
||||
console.log(`📊 Node Status:`, status);
|
||||
|
||||
// Pin important data
|
||||
await ipfsClient.pin(cid);
|
||||
console.log(`📌 Pinned CID: ${cid}`);
|
||||
|
||||
// List all pins
|
||||
const pins = await ipfsClient.listPins();
|
||||
console.log(`📋 Total pinned items: ${pins.length}`);
|
||||
} finally {
|
||||
await ipfsClient.cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Example 2: MPC Enclave Storage
|
||||
// ============================================
|
||||
async function mpcEnclaveExample() {
|
||||
console.log('🔐 MPC Enclave Storage Example');
|
||||
|
||||
const ipfsClient = await createIPFSClient();
|
||||
const enclaveManager = await createEnclaveIPFSManager(ipfsClient, {
|
||||
encryptionRequired: true,
|
||||
pinningEnabled: true,
|
||||
maxRetries: 3,
|
||||
});
|
||||
|
||||
try {
|
||||
// Create MPC enclave data
|
||||
const enclaveData: EnclaveDataWithCID = {
|
||||
publicKey: 'ed25519:8FYH...publickey...ZKpQ',
|
||||
privateKeyShares: [
|
||||
'share1_encrypted_base64...',
|
||||
'share2_encrypted_base64...',
|
||||
'share3_encrypted_base64...',
|
||||
],
|
||||
threshold: 2, // Need 2 out of 3 shares to reconstruct
|
||||
parties: 3,
|
||||
encryptionMetadata: {
|
||||
algorithm: 'AES-256-GCM',
|
||||
keyVersion: 1,
|
||||
consensusHeight: 12345,
|
||||
nonce: crypto.randomUUID(),
|
||||
},
|
||||
};
|
||||
|
||||
// Encrypt the payload (in production, use consensus keys)
|
||||
const payload = JSON.stringify({
|
||||
...enclaveData,
|
||||
timestamp: Date.now(),
|
||||
chainId: 'sonr-mainnet-1',
|
||||
});
|
||||
const encryptedPayload = new TextEncoder().encode(payload);
|
||||
|
||||
// Store enclave data
|
||||
const result = await enclaveManager.storeEnclaveData(
|
||||
enclaveData,
|
||||
encryptedPayload
|
||||
);
|
||||
console.log(`✅ Stored enclave with CID: ${result.cid}`);
|
||||
console.log(` - Size: ${result.size} bytes`);
|
||||
console.log(` - Pinned: ${result.isPinned}`);
|
||||
|
||||
// Retrieve and verify
|
||||
const retrieved = await enclaveManager.retrieveEnclaveData(result.cid);
|
||||
const isValid = await enclaveManager.verifyEnclaveDataIntegrity(
|
||||
result.cid,
|
||||
encryptedPayload
|
||||
);
|
||||
console.log(`✅ Retrieved enclave data (integrity: ${isValid})`);
|
||||
|
||||
// Check status
|
||||
const status = await enclaveManager.getEnclaveStatus(result.cid);
|
||||
console.log(`📊 Enclave Status:`, status);
|
||||
} finally {
|
||||
await ipfsClient.cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Example 3: Vault Client with IPFS
|
||||
// ============================================
|
||||
async function vaultWithIPFSExample() {
|
||||
console.log('🔒 Vault Client with IPFS Example');
|
||||
|
||||
const vaultClient = createVaultClientWithIPFS({
|
||||
chainId: 'sonr-testnet-1',
|
||||
enableIPFSPersistence: true,
|
||||
ipfsGateways: ['https://gateway.pinata.cloud'],
|
||||
enclave: {
|
||||
publicKey: 'test-public-key',
|
||||
privateKeyShares: ['share1', 'share2', 'share3'],
|
||||
threshold: 2,
|
||||
parties: 3,
|
||||
},
|
||||
});
|
||||
|
||||
try {
|
||||
// Initialize vault with IPFS
|
||||
await vaultClient.initializeWithIPFS(
|
||||
'/path/to/vault.wasm',
|
||||
'sonr1abc...xyz'
|
||||
);
|
||||
|
||||
// Store vault enclave
|
||||
const cid = await vaultClient.storeVaultEnclave([
|
||||
'encrypted_share1',
|
||||
'encrypted_share2',
|
||||
'encrypted_share3',
|
||||
]);
|
||||
console.log(`✅ Stored vault enclave: ${cid}`);
|
||||
|
||||
// Retrieve vault enclave
|
||||
const enclave = await vaultClient.retrieveVaultEnclave(cid);
|
||||
console.log(`✅ Retrieved enclave for ${enclave.parties} parties`);
|
||||
|
||||
// List pinned enclaves
|
||||
const pinnedEnclaves = await vaultClient.listPinnedEnclaves();
|
||||
console.log(`📌 Pinned enclaves: ${pinnedEnclaves.length}`);
|
||||
|
||||
// Sync with IPFS network
|
||||
await vaultClient.syncWithIPFS();
|
||||
console.log('✅ Synced with IPFS network');
|
||||
|
||||
// Get IPFS status
|
||||
const ipfsStatus = await vaultClient.getIPFSStatus();
|
||||
console.log(`📊 IPFS Status:`, ipfsStatus);
|
||||
} catch (error) {
|
||||
// Handle WASM errors gracefully
|
||||
if (error.message.includes('WASM')) {
|
||||
console.log('⚠️ WASM not available, using IPFS features only');
|
||||
} else {
|
||||
throw error;
|
||||
}
|
||||
} finally {
|
||||
await vaultClient.cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Example 4: Caching Layer
|
||||
// ============================================
|
||||
async function cachingExample() {
|
||||
console.log('⚡ IPFS Caching Example');
|
||||
|
||||
const ipfsClient = await createIPFSClient();
|
||||
const cache = createIPFSCache({
|
||||
maxSize: 50,
|
||||
ttl: 60000, // 1 minute TTL
|
||||
enablePersistence: true,
|
||||
});
|
||||
|
||||
try {
|
||||
// Store some data in IPFS
|
||||
const data1 = new TextEncoder().encode('Data item 1');
|
||||
const data2 = new TextEncoder().encode('Data item 2');
|
||||
const data3 = new TextEncoder().encode('Data item 3');
|
||||
|
||||
const { cid: cid1 } = await ipfsClient.addEnclaveData(data1);
|
||||
const { cid: cid2 } = await ipfsClient.addEnclaveData(data2);
|
||||
const { cid: cid3 } = await ipfsClient.addEnclaveData(data3);
|
||||
|
||||
// Preload into cache
|
||||
console.log('📥 Preloading data into cache...');
|
||||
await cache.preload(
|
||||
[cid1, cid2, cid3],
|
||||
async (cid) => await ipfsClient.getEnclaveData(cid)
|
||||
);
|
||||
|
||||
// Measure cache performance
|
||||
console.time('Cache retrieval');
|
||||
const cached1 = await cache.get(cid1);
|
||||
const cached2 = await cache.get(cid2);
|
||||
const cached3 = await cache.get(cid3);
|
||||
console.timeEnd('Cache retrieval');
|
||||
|
||||
// Get cache statistics
|
||||
const stats = cache.getStats();
|
||||
console.log('📊 Cache Statistics:');
|
||||
console.log(` - Size: ${stats.size} items`);
|
||||
console.log(` - Total bytes: ${stats.totalBytes}`);
|
||||
console.log(` - Hit rate: ${stats.hitRate.toFixed(2)}%`);
|
||||
console.log(` - Avg access time: ${stats.avgAccessTime.toFixed(2)}ms`);
|
||||
|
||||
// Clean up expired entries
|
||||
const removed = await cache.cleanup();
|
||||
console.log(`🧹 Cleaned up ${removed} expired entries`);
|
||||
} finally {
|
||||
await cache.destroy();
|
||||
await ipfsClient.cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Example 5: DWN IPFS Query Service
|
||||
// ============================================
|
||||
async function dwnQueryServiceExample() {
|
||||
console.log('🔍 DWN IPFS Query Service Example');
|
||||
|
||||
const queryService = createDWNIPFSQueryService({
|
||||
rpcEndpoint: 'http://localhost:1317',
|
||||
defaultStaleTime: 30000,
|
||||
});
|
||||
|
||||
try {
|
||||
// Query IPFS status from backend
|
||||
const ipfsStatus = await queryService.queryIPFSStatus();
|
||||
console.log('📊 Backend IPFS Status:');
|
||||
console.log(` - Enabled: ${ipfsStatus.enabled}`);
|
||||
console.log(` - Peer ID: ${ipfsStatus.peerId}`);
|
||||
console.log(` - Connected peers: ${ipfsStatus.connectedPeers}`);
|
||||
|
||||
// Query specific CID content
|
||||
const cidResponse = await queryService.queryCIDContent(
|
||||
'QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG',
|
||||
false // Don't decrypt
|
||||
);
|
||||
if (cidResponse.error) {
|
||||
console.log(`⚠️ CID not found: ${cidResponse.error}`);
|
||||
} else {
|
||||
console.log(`✅ Found CID content (${cidResponse.size} bytes)`);
|
||||
}
|
||||
|
||||
// Query enclave data for a vault
|
||||
const enclaveResponse = await queryService.queryEnclaveData(
|
||||
'did:sonr:vault123',
|
||||
false // Don't include private shares
|
||||
);
|
||||
if (enclaveResponse.enclaveCid) {
|
||||
console.log(`✅ Found enclave for vault: ${enclaveResponse.enclaveCid}`);
|
||||
}
|
||||
|
||||
// Store new enclave data via backend
|
||||
const newEnclaveData = new TextEncoder().encode('New enclave data');
|
||||
const storeResult = await queryService.storeEnclaveData(
|
||||
'did:sonr:newvault',
|
||||
newEnclaveData
|
||||
);
|
||||
console.log(`✅ Stored via backend: ${storeResult.cid}`);
|
||||
} finally {
|
||||
await queryService.cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Example 6: Error Handling and Recovery
|
||||
// ============================================
|
||||
async function errorHandlingExample() {
|
||||
console.log('🛡️ Error Handling Example');
|
||||
|
||||
const ipfsClient = await createIPFSClient({
|
||||
gateways: [
|
||||
'https://gateway.pinata.cloud',
|
||||
'https://ipfs.io',
|
||||
'http://localhost:8080', // Local fallback
|
||||
],
|
||||
});
|
||||
|
||||
const enclaveManager = new EnclaveIPFSManager(ipfsClient, {
|
||||
encryptionRequired: true,
|
||||
pinningEnabled: true,
|
||||
maxRetries: 3,
|
||||
operationTimeout: 10000,
|
||||
});
|
||||
|
||||
try {
|
||||
// Handle invalid CID
|
||||
try {
|
||||
await ipfsClient.getEnclaveData('invalid-cid-format');
|
||||
} catch (error) {
|
||||
console.log('✅ Caught invalid CID error:', error.message);
|
||||
}
|
||||
|
||||
// Handle missing encryption metadata
|
||||
try {
|
||||
const invalidEnclave: EnclaveDataWithCID = {
|
||||
publicKey: 'test',
|
||||
privateKeyShares: ['share1'],
|
||||
threshold: 1,
|
||||
parties: 1,
|
||||
// Missing encryptionMetadata when encryptionRequired is true
|
||||
};
|
||||
await enclaveManager.storeEnclaveData(
|
||||
invalidEnclave,
|
||||
new Uint8Array()
|
||||
);
|
||||
} catch (error) {
|
||||
console.log('✅ Caught missing encryption metadata:', error.message);
|
||||
}
|
||||
|
||||
// Handle network timeout with retry
|
||||
console.log('🔄 Testing retry logic...');
|
||||
const enclaveData: EnclaveDataWithCID = {
|
||||
publicKey: 'retry-test',
|
||||
privateKeyShares: ['share1'],
|
||||
threshold: 1,
|
||||
parties: 1,
|
||||
encryptionMetadata: {
|
||||
algorithm: 'AES-256-GCM',
|
||||
keyVersion: 1,
|
||||
consensusHeight: 1,
|
||||
nonce: 'test',
|
||||
},
|
||||
};
|
||||
|
||||
const result = await enclaveManager.storeEnclaveData(
|
||||
enclaveData,
|
||||
new Uint8Array([1, 2, 3])
|
||||
);
|
||||
console.log('✅ Succeeded with retry logic');
|
||||
} finally {
|
||||
await ipfsClient.cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Example 7: Performance Best Practices
|
||||
// ============================================
|
||||
async function performanceExample() {
|
||||
console.log('🚀 Performance Best Practices Example');
|
||||
|
||||
// 1. Use connection pooling
|
||||
const ipfsClient = await createIPFSClient({
|
||||
gateways: ['https://gateway.pinata.cloud'],
|
||||
libp2pConfig: {
|
||||
connectionManager: {
|
||||
maxConnections: 100,
|
||||
minConnections: 10,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
// 2. Use caching aggressively
|
||||
const cache = createIPFSCache({
|
||||
maxSize: 200,
|
||||
ttl: 300000, // 5 minutes
|
||||
enablePersistence: true,
|
||||
});
|
||||
|
||||
// 3. Batch operations
|
||||
const enclaveManager = new EnclaveIPFSManager(ipfsClient, {
|
||||
encryptionRequired: false,
|
||||
pinningEnabled: true,
|
||||
redundancy: 3,
|
||||
maxRetries: 2,
|
||||
});
|
||||
|
||||
try {
|
||||
// Batch store multiple items
|
||||
console.log('📦 Batch storing enclaves...');
|
||||
const enclaves = Array.from({ length: 10 }, (_, i) => ({
|
||||
data: {
|
||||
publicKey: `key-${i}`,
|
||||
privateKeyShares: [`share-${i}`],
|
||||
threshold: 1,
|
||||
parties: 1,
|
||||
} as EnclaveDataWithCID,
|
||||
payload: new Uint8Array([i, i, i]),
|
||||
}));
|
||||
|
||||
console.time('Batch store');
|
||||
const results = await enclaveManager.batchStoreEnclaves(enclaves);
|
||||
console.timeEnd('Batch store');
|
||||
console.log(`✅ Stored ${results.length} enclaves in batch`);
|
||||
|
||||
// Preload frequently accessed data
|
||||
const cids = results.map((r) => r.cid);
|
||||
console.time('Preload cache');
|
||||
await cache.preload(cids.slice(0, 5), async (cid) =>
|
||||
enclaveManager.retrieveEnclaveData(cid)
|
||||
);
|
||||
console.timeEnd('Preload cache');
|
||||
|
||||
// Use cache for fast retrieval
|
||||
console.time('Cached retrieval');
|
||||
for (const cid of cids.slice(0, 5)) {
|
||||
await cache.get(cid);
|
||||
}
|
||||
console.timeEnd('Cached retrieval');
|
||||
|
||||
const stats = cache.getStats();
|
||||
console.log(`📊 Cache hit rate: ${stats.hitRate.toFixed(2)}%`);
|
||||
} finally {
|
||||
await cache.destroy();
|
||||
await ipfsClient.cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Main: Run all examples
|
||||
// ============================================
|
||||
async function main() {
|
||||
console.log('🌟 Sonr IPFS/Helia Integration Examples\n');
|
||||
|
||||
try {
|
||||
await basicIPFSExample();
|
||||
console.log('\n---\n');
|
||||
|
||||
await mpcEnclaveExample();
|
||||
console.log('\n---\n');
|
||||
|
||||
await vaultWithIPFSExample();
|
||||
console.log('\n---\n');
|
||||
|
||||
await cachingExample();
|
||||
console.log('\n---\n');
|
||||
|
||||
await dwnQueryServiceExample();
|
||||
console.log('\n---\n');
|
||||
|
||||
await errorHandlingExample();
|
||||
console.log('\n---\n');
|
||||
|
||||
await performanceExample();
|
||||
|
||||
console.log('\n✅ All examples completed successfully!');
|
||||
} catch (error) {
|
||||
console.error('❌ Example failed:', error);
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// Run if executed directly
|
||||
if (require.main === module) {
|
||||
main();
|
||||
}
|
||||
|
||||
// Export examples for use in other modules
|
||||
export {
|
||||
basicIPFSExample,
|
||||
mpcEnclaveExample,
|
||||
vaultWithIPFSExample,
|
||||
cachingExample,
|
||||
dwnQueryServiceExample,
|
||||
errorHandlingExample,
|
||||
performanceExample,
|
||||
};
|
||||
@@ -0,0 +1,442 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>Motor WASM Service Worker Test</title>
|
||||
<style>
|
||||
body {
|
||||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
|
||||
max-width: 1200px;
|
||||
margin: 0 auto;
|
||||
padding: 20px;
|
||||
background: #f5f5f5;
|
||||
}
|
||||
.container {
|
||||
background: white;
|
||||
border-radius: 8px;
|
||||
padding: 20px;
|
||||
margin-bottom: 20px;
|
||||
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
|
||||
}
|
||||
h1 {
|
||||
color: #333;
|
||||
border-bottom: 2px solid #007bff;
|
||||
padding-bottom: 10px;
|
||||
}
|
||||
h2 {
|
||||
color: #555;
|
||||
margin-top: 30px;
|
||||
}
|
||||
.status {
|
||||
padding: 10px;
|
||||
border-radius: 4px;
|
||||
margin: 10px 0;
|
||||
font-family: 'Courier New', monospace;
|
||||
}
|
||||
.success {
|
||||
background: #d4edda;
|
||||
border: 1px solid #c3e6cb;
|
||||
color: #155724;
|
||||
}
|
||||
.error {
|
||||
background: #f8d7da;
|
||||
border: 1px solid #f5c6cb;
|
||||
color: #721c24;
|
||||
}
|
||||
.info {
|
||||
background: #d1ecf1;
|
||||
border: 1px solid #bee5eb;
|
||||
color: #0c5460;
|
||||
}
|
||||
.warning {
|
||||
background: #fff3cd;
|
||||
border: 1px solid #ffeeba;
|
||||
color: #856404;
|
||||
}
|
||||
button {
|
||||
background: #007bff;
|
||||
color: white;
|
||||
border: none;
|
||||
padding: 10px 20px;
|
||||
border-radius: 4px;
|
||||
cursor: pointer;
|
||||
margin: 5px;
|
||||
font-size: 14px;
|
||||
}
|
||||
button:hover {
|
||||
background: #0056b3;
|
||||
}
|
||||
button:disabled {
|
||||
background: #ccc;
|
||||
cursor: not-allowed;
|
||||
}
|
||||
.test-section {
|
||||
margin: 20px 0;
|
||||
padding: 15px;
|
||||
border-left: 4px solid #007bff;
|
||||
background: #f8f9fa;
|
||||
}
|
||||
pre {
|
||||
background: #f4f4f4;
|
||||
padding: 10px;
|
||||
border-radius: 4px;
|
||||
overflow-x: auto;
|
||||
}
|
||||
.log-entry {
|
||||
font-family: 'Courier New', monospace;
|
||||
font-size: 12px;
|
||||
padding: 2px 0;
|
||||
}
|
||||
#logs {
|
||||
max-height: 300px;
|
||||
overflow-y: auto;
|
||||
background: #f8f9fa;
|
||||
padding: 10px;
|
||||
border-radius: 4px;
|
||||
font-size: 12px;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="container">
|
||||
<h1>🚀 Motor WASM Service Worker Test</h1>
|
||||
|
||||
<div class="test-section">
|
||||
<h2>Service Worker Status</h2>
|
||||
<div id="worker-status" class="status info">Checking service worker support...</div>
|
||||
<button id="register-worker">Register Service Worker</button>
|
||||
<button id="unregister-worker" disabled>Unregister Service Worker</button>
|
||||
</div>
|
||||
|
||||
<div class="test-section">
|
||||
<h2>Plugin Initialization</h2>
|
||||
<div id="plugin-status" class="status info">Plugin not initialized</div>
|
||||
<button id="init-plugin" disabled>Initialize Motor Plugin</button>
|
||||
</div>
|
||||
|
||||
<div class="test-section">
|
||||
<h2>API Tests</h2>
|
||||
<div id="test-results"></div>
|
||||
|
||||
<h3>Identity Operations</h3>
|
||||
<button id="test-issuer-did" disabled>Test Get Issuer DID</button>
|
||||
|
||||
<h3>UCAN Token Operations</h3>
|
||||
<button id="test-origin-token" disabled>Test Create Origin Token</button>
|
||||
<button id="test-attenuated-token" disabled>Test Create Attenuated Token</button>
|
||||
|
||||
<h3>Cryptographic Operations</h3>
|
||||
<button id="test-sign-verify" disabled>Test Sign & Verify</button>
|
||||
|
||||
<h3>DWN Operations</h3>
|
||||
<button id="test-dwn-crud" disabled>Test DWN CRUD</button>
|
||||
</div>
|
||||
|
||||
<div class="test-section">
|
||||
<h2>Console Logs</h2>
|
||||
<div id="logs"></div>
|
||||
<button id="clear-logs">Clear Logs</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script type="module">
|
||||
// Logging utility
|
||||
const logContainer = document.getElementById('logs');
|
||||
function log(message, type = 'info') {
|
||||
const timestamp = new Date().toLocaleTimeString();
|
||||
const entry = document.createElement('div');
|
||||
entry.className = 'log-entry';
|
||||
entry.innerHTML = `<span style="color: ${
|
||||
type === 'error' ? '#dc3545' :
|
||||
type === 'success' ? '#28a745' :
|
||||
type === 'warning' ? '#ffc107' : '#007bff'
|
||||
}">[${timestamp}]</span> ${message}`;
|
||||
logContainer.appendChild(entry);
|
||||
logContainer.scrollTop = logContainer.scrollHeight;
|
||||
console.log(`[${type}]`, message);
|
||||
}
|
||||
|
||||
// Clear logs button
|
||||
document.getElementById('clear-logs').addEventListener('click', () => {
|
||||
logContainer.innerHTML = '';
|
||||
log('Logs cleared', 'info');
|
||||
});
|
||||
|
||||
// Check service worker support
|
||||
const workerStatusEl = document.getElementById('worker-status');
|
||||
const registerBtn = document.getElementById('register-worker');
|
||||
const unregisterBtn = document.getElementById('unregister-worker');
|
||||
const initPluginBtn = document.getElementById('init-plugin');
|
||||
const pluginStatusEl = document.getElementById('plugin-status');
|
||||
|
||||
let motorPlugin = null;
|
||||
let serviceWorkerRegistration = null;
|
||||
|
||||
// Check if service workers are supported
|
||||
if ('serviceWorker' in navigator) {
|
||||
workerStatusEl.className = 'status success';
|
||||
workerStatusEl.textContent = '✅ Service Workers are supported in this browser';
|
||||
log('Service Workers supported', 'success');
|
||||
|
||||
// Check if already registered
|
||||
navigator.serviceWorker.getRegistrations().then(registrations => {
|
||||
if (registrations.length > 0) {
|
||||
const motorWorker = registrations.find(r => r.active?.scriptURL.includes('motor'));
|
||||
if (motorWorker) {
|
||||
serviceWorkerRegistration = motorWorker;
|
||||
workerStatusEl.textContent = '✅ Motor Service Worker already registered';
|
||||
unregisterBtn.disabled = false;
|
||||
initPluginBtn.disabled = false;
|
||||
log('Found existing Motor service worker', 'info');
|
||||
}
|
||||
}
|
||||
});
|
||||
} else {
|
||||
workerStatusEl.className = 'status error';
|
||||
workerStatusEl.textContent = '❌ Service Workers are not supported in this browser';
|
||||
registerBtn.disabled = true;
|
||||
log('Service Workers not supported', 'error');
|
||||
}
|
||||
|
||||
// Register service worker
|
||||
registerBtn.addEventListener('click', async () => {
|
||||
try {
|
||||
log('Registering Motor service worker...', 'info');
|
||||
registerBtn.disabled = true;
|
||||
|
||||
// Check if Motor service worker file exists
|
||||
const workerUrl = '/dist/wasm/motr-sw.js';
|
||||
|
||||
// Try to fetch the worker file first
|
||||
try {
|
||||
const response = await fetch(workerUrl);
|
||||
if (!response.ok) {
|
||||
throw new Error(`Worker file not found at ${workerUrl}. Status: ${response.status}`);
|
||||
}
|
||||
log(`Worker file found at ${workerUrl}`, 'success');
|
||||
} catch (fetchError) {
|
||||
throw new Error(`Cannot access worker file: ${fetchError.message}. Make sure you're serving the dist/wasm directory.`);
|
||||
}
|
||||
|
||||
// Register the service worker
|
||||
serviceWorkerRegistration = await navigator.serviceWorker.register(workerUrl, {
|
||||
scope: '/',
|
||||
updateViaCache: 'none'
|
||||
});
|
||||
|
||||
log('Service worker registered successfully', 'success');
|
||||
|
||||
// Wait for activation
|
||||
await navigator.serviceWorker.ready;
|
||||
|
||||
workerStatusEl.className = 'status success';
|
||||
workerStatusEl.textContent = '✅ Motor Service Worker registered and active';
|
||||
unregisterBtn.disabled = false;
|
||||
initPluginBtn.disabled = false;
|
||||
log('Service worker is ready', 'success');
|
||||
|
||||
} catch (error) {
|
||||
workerStatusEl.className = 'status error';
|
||||
workerStatusEl.textContent = `❌ Registration failed: ${error.message}`;
|
||||
log(`Registration failed: ${error.message}`, 'error');
|
||||
registerBtn.disabled = false;
|
||||
}
|
||||
});
|
||||
|
||||
// Unregister service worker
|
||||
unregisterBtn.addEventListener('click', async () => {
|
||||
try {
|
||||
log('Unregistering service worker...', 'info');
|
||||
unregisterBtn.disabled = true;
|
||||
|
||||
if (serviceWorkerRegistration) {
|
||||
await serviceWorkerRegistration.unregister();
|
||||
serviceWorkerRegistration = null;
|
||||
}
|
||||
|
||||
workerStatusEl.className = 'status info';
|
||||
workerStatusEl.textContent = 'Service Worker unregistered';
|
||||
registerBtn.disabled = false;
|
||||
initPluginBtn.disabled = true;
|
||||
motorPlugin = null;
|
||||
pluginStatusEl.className = 'status info';
|
||||
pluginStatusEl.textContent = 'Plugin not initialized';
|
||||
log('Service worker unregistered', 'success');
|
||||
|
||||
// Disable all test buttons
|
||||
document.querySelectorAll('button[id^="test-"]').forEach(btn => {
|
||||
btn.disabled = true;
|
||||
});
|
||||
|
||||
} catch (error) {
|
||||
log(`Unregistration failed: ${error.message}`, 'error');
|
||||
unregisterBtn.disabled = false;
|
||||
}
|
||||
});
|
||||
|
||||
// Initialize Motor plugin
|
||||
initPluginBtn.addEventListener('click', async () => {
|
||||
try {
|
||||
log('Initializing Motor plugin...', 'info');
|
||||
initPluginBtn.disabled = true;
|
||||
|
||||
// Dynamically import the Motor plugin
|
||||
// In a real application, this would be imported from @sonr.io/es/client/motor
|
||||
const { createMotorPluginForBrowser } = await import('/dist/client/motor/index.js');
|
||||
|
||||
motorPlugin = await createMotorPluginForBrowser('/api/motor', {
|
||||
auto_register_worker: false, // We already registered it
|
||||
debug: true
|
||||
});
|
||||
|
||||
pluginStatusEl.className = 'status success';
|
||||
pluginStatusEl.textContent = '✅ Motor Plugin initialized successfully';
|
||||
log('Motor plugin initialized', 'success');
|
||||
|
||||
// Enable test buttons
|
||||
document.querySelectorAll('button[id^="test-"]').forEach(btn => {
|
||||
btn.disabled = false;
|
||||
});
|
||||
|
||||
} catch (error) {
|
||||
pluginStatusEl.className = 'status error';
|
||||
pluginStatusEl.textContent = `❌ Initialization failed: ${error.message}`;
|
||||
log(`Plugin initialization failed: ${error.message}`, 'error');
|
||||
initPluginBtn.disabled = false;
|
||||
}
|
||||
});
|
||||
|
||||
// Test functions
|
||||
function addTestResult(testName, success, message) {
|
||||
const resultsContainer = document.getElementById('test-results');
|
||||
const result = document.createElement('div');
|
||||
result.className = `status ${success ? 'success' : 'error'}`;
|
||||
result.textContent = `${success ? '✅' : '❌'} ${testName}: ${message}`;
|
||||
resultsContainer.appendChild(result);
|
||||
log(`Test "${testName}": ${message}`, success ? 'success' : 'error');
|
||||
}
|
||||
|
||||
// Test Get Issuer DID
|
||||
document.getElementById('test-issuer-did').addEventListener('click', async () => {
|
||||
try {
|
||||
log('Testing Get Issuer DID...', 'info');
|
||||
const result = await motorPlugin.getIssuerDID();
|
||||
addTestResult('Get Issuer DID', true, `DID: ${result.issuer_did}, Address: ${result.address}`);
|
||||
} catch (error) {
|
||||
addTestResult('Get Issuer DID', false, error.message);
|
||||
}
|
||||
});
|
||||
|
||||
// Test Create Origin Token
|
||||
document.getElementById('test-origin-token').addEventListener('click', async () => {
|
||||
try {
|
||||
log('Testing Create Origin Token...', 'info');
|
||||
const result = await motorPlugin.newOriginToken({
|
||||
audience_did: 'did:sonr:test_audience',
|
||||
attenuations: [{ can: ['sign', 'verify'], with: 'vault://test' }],
|
||||
facts: ['test_fact'],
|
||||
expires_at: Date.now() + 3600000
|
||||
});
|
||||
addTestResult('Create Origin Token', true, `Token created, Issuer: ${result.issuer}`);
|
||||
} catch (error) {
|
||||
addTestResult('Create Origin Token', false, error.message);
|
||||
}
|
||||
});
|
||||
|
||||
// Test Create Attenuated Token
|
||||
document.getElementById('test-attenuated-token').addEventListener('click', async () => {
|
||||
try {
|
||||
log('Testing Create Attenuated Token...', 'info');
|
||||
// First create an origin token
|
||||
const originToken = await motorPlugin.newOriginToken({
|
||||
audience_did: 'did:sonr:test',
|
||||
attenuations: [{ can: ['sign', 'verify'], with: 'vault://test' }]
|
||||
});
|
||||
|
||||
// Then create attenuated token
|
||||
const result = await motorPlugin.newAttenuatedToken({
|
||||
parent_token: originToken.token,
|
||||
audience_did: 'did:sonr:delegated',
|
||||
attenuations: [{ can: ['sign'], with: 'vault://restricted' }]
|
||||
});
|
||||
addTestResult('Create Attenuated Token', true, `Delegated token created`);
|
||||
} catch (error) {
|
||||
addTestResult('Create Attenuated Token', false, error.message);
|
||||
}
|
||||
});
|
||||
|
||||
// Test Sign & Verify
|
||||
document.getElementById('test-sign-verify').addEventListener('click', async () => {
|
||||
try {
|
||||
log('Testing Sign & Verify...', 'info');
|
||||
const message = new TextEncoder().encode('Test message for signing');
|
||||
|
||||
// Sign the message
|
||||
const signResult = await motorPlugin.signData({ data: message });
|
||||
log(`Signed message, signature length: ${signResult.signature.length} bytes`, 'info');
|
||||
|
||||
// Verify the signature
|
||||
const verifyResult = await motorPlugin.verifyData({
|
||||
data: message,
|
||||
signature: signResult.signature
|
||||
});
|
||||
|
||||
addTestResult('Sign & Verify', verifyResult.valid,
|
||||
verifyResult.valid ? 'Signature verified successfully' : 'Signature verification failed');
|
||||
} catch (error) {
|
||||
addTestResult('Sign & Verify', false, error.message);
|
||||
}
|
||||
});
|
||||
|
||||
// Test DWN CRUD
|
||||
document.getElementById('test-dwn-crud').addEventListener('click', async () => {
|
||||
try {
|
||||
log('Testing DWN CRUD operations...', 'info');
|
||||
|
||||
// Create a record
|
||||
const createResult = await motorPlugin.createRecord({
|
||||
schema: 'https://schema.org/Person',
|
||||
data: new TextEncoder().encode(JSON.stringify({
|
||||
name: 'Test User',
|
||||
email: 'test@example.com'
|
||||
})),
|
||||
is_encrypted: false
|
||||
});
|
||||
log(`Created record: ${createResult.record_id}`, 'success');
|
||||
|
||||
// Read the record
|
||||
const readResult = await motorPlugin.readRecord({
|
||||
record_id: createResult.record_id
|
||||
});
|
||||
log(`Read record: ${readResult.record_id}`, 'success');
|
||||
|
||||
// Update the record
|
||||
const updateResult = await motorPlugin.updateRecord({
|
||||
record_id: createResult.record_id,
|
||||
data: new TextEncoder().encode(JSON.stringify({
|
||||
name: 'Updated User',
|
||||
email: 'updated@example.com'
|
||||
}))
|
||||
});
|
||||
log(`Updated record: ${updateResult.record_id}`, 'success');
|
||||
|
||||
// Delete the record
|
||||
const deleteResult = await motorPlugin.deleteRecord({
|
||||
record_id: createResult.record_id
|
||||
});
|
||||
log(`Deleted record: ${deleteResult.success}`, 'success');
|
||||
|
||||
addTestResult('DWN CRUD', true, 'All CRUD operations completed successfully');
|
||||
} catch (error) {
|
||||
addTestResult('DWN CRUD', false, error.message);
|
||||
}
|
||||
});
|
||||
|
||||
// Initial log
|
||||
log('Motor WASM Service Worker Test Page loaded', 'info');
|
||||
log('Make sure to serve this page over HTTP (not file://) for service workers to work', 'warning');
|
||||
log('Example: python3 -m http.server 8080', 'info');
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,310 @@
|
||||
/**
|
||||
* Example usage of the Motor WASM service worker integration.
|
||||
* This demonstrates how to use the Motor plugin for both DWN and Wallet operations.
|
||||
*/
|
||||
|
||||
import {
|
||||
createMotorPlugin,
|
||||
createMotorPluginForNode,
|
||||
createMotorPluginForBrowser,
|
||||
isMotorSupported,
|
||||
getMotorEnvironment,
|
||||
type MotorPlugin,
|
||||
type NewOriginTokenRequest,
|
||||
type CreateRecordRequest,
|
||||
} from '@sonr.io/es/client/motor';
|
||||
|
||||
// ╭─────────────────────────────────────────────────────────╮
|
||||
// │ Environment Detection │
|
||||
// ╰─────────────────────────────────────────────────────────╯
|
||||
|
||||
async function detectEnvironment(): Promise<void> {
|
||||
console.log('🔍 Detecting environment capabilities...');
|
||||
|
||||
const env = getMotorEnvironment();
|
||||
console.log('Environment info:', {
|
||||
browser: env.is_browser,
|
||||
node: env.is_node,
|
||||
serviceWorker: env.supports_service_worker,
|
||||
wasm: env.supports_wasm,
|
||||
});
|
||||
|
||||
const supported = isMotorSupported();
|
||||
console.log('Motor supported:', supported);
|
||||
}
|
||||
|
||||
// ╭─────────────────────────────────────────────────────────╮
|
||||
// │ Auto Plugin Creation │
|
||||
// ╰─────────────────────────────────────────────────────────╯
|
||||
|
||||
async function createPlugin(): Promise<MotorPlugin> {
|
||||
console.log('🚀 Creating Motor plugin...');
|
||||
|
||||
// Auto-detects environment and creates appropriate plugin
|
||||
const plugin = await createMotorPlugin({
|
||||
debug: true,
|
||||
timeout: 30000,
|
||||
max_retries: 3,
|
||||
});
|
||||
|
||||
console.log('✅ Plugin created successfully');
|
||||
return plugin;
|
||||
}
|
||||
|
||||
// ╭─────────────────────────────────────────────────────────╮
|
||||
// │ Environment-Specific Creation │
|
||||
// ╰─────────────────────────────────────────────────────────╯
|
||||
|
||||
async function createBrowserPlugin(): Promise<MotorPlugin> {
|
||||
console.log('🌐 Creating browser-specific Motor plugin...');
|
||||
|
||||
const plugin = await createMotorPluginForBrowser('/motor-worker', {
|
||||
auto_register_worker: true,
|
||||
prefer_service_worker: true,
|
||||
debug: true,
|
||||
});
|
||||
|
||||
console.log('✅ Browser plugin created with service worker support');
|
||||
return plugin;
|
||||
}
|
||||
|
||||
async function createNodePlugin(): Promise<MotorPlugin> {
|
||||
console.log('🖥️ Creating Node.js-specific Motor plugin...');
|
||||
|
||||
const plugin = await createMotorPluginForNode('http://localhost:8080', {
|
||||
timeout: 15000,
|
||||
max_retries: 2,
|
||||
debug: true,
|
||||
});
|
||||
|
||||
console.log('✅ Node.js plugin created with HTTP fallback');
|
||||
return plugin;
|
||||
}
|
||||
|
||||
// ╭─────────────────────────────────────────────────────────╮
|
||||
// │ Wallet Operations │
|
||||
// ╰─────────────────────────────────────────────────────────╯
|
||||
|
||||
async function demonstrateWalletOperations(plugin: MotorPlugin): Promise<void> {
|
||||
console.log('💼 Demonstrating wallet operations...');
|
||||
|
||||
try {
|
||||
// Get issuer DID
|
||||
console.log('📋 Getting issuer DID...');
|
||||
const issuerResponse = await plugin.getIssuerDID();
|
||||
console.log('Issuer DID:', issuerResponse.issuer_did);
|
||||
console.log('Address:', issuerResponse.address);
|
||||
|
||||
// Create origin token
|
||||
console.log('🎫 Creating UCAN origin token...');
|
||||
const tokenRequest: NewOriginTokenRequest = {
|
||||
audience_did: 'did:sonr:example-audience',
|
||||
attenuations: [
|
||||
{
|
||||
can: ['sign', 'encrypt'],
|
||||
with: 'vault://example-vault',
|
||||
},
|
||||
],
|
||||
facts: ['motor-wasm-demo'],
|
||||
expires_at: Date.now() + (24 * 60 * 60 * 1000), // 24 hours
|
||||
};
|
||||
|
||||
const tokenResponse = await plugin.newOriginToken(tokenRequest);
|
||||
console.log('✅ Origin token created:', tokenResponse.token.substring(0, 50) + '...');
|
||||
|
||||
// Create attenuated token
|
||||
console.log('🔗 Creating attenuated token...');
|
||||
const attenuatedResponse = await plugin.newAttenuatedToken({
|
||||
parent_token: tokenResponse.token,
|
||||
audience_did: 'did:sonr:delegated-audience',
|
||||
attenuations: [
|
||||
{
|
||||
can: ['sign'],
|
||||
with: 'vault://limited-access',
|
||||
},
|
||||
],
|
||||
expires_at: Date.now() + (2 * 60 * 60 * 1000), // 2 hours
|
||||
});
|
||||
console.log('✅ Attenuated token created:', attenuatedResponse.token.substring(0, 50) + '...');
|
||||
|
||||
// Sign data
|
||||
console.log('✍️ Signing data...');
|
||||
const dataToSign = new TextEncoder().encode('Hello, Motor WASM!');
|
||||
const signResponse = await plugin.signData({ data: dataToSign });
|
||||
console.log('✅ Data signed, signature length:', signResponse.signature.length);
|
||||
|
||||
// Verify signature
|
||||
console.log('🔍 Verifying signature...');
|
||||
const verifyResponse = await plugin.verifyData({
|
||||
data: dataToSign,
|
||||
signature: signResponse.signature,
|
||||
});
|
||||
console.log('✅ Signature valid:', verifyResponse.valid);
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Wallet operation failed:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// ╭─────────────────────────────────────────────────────────╮
|
||||
// │ DWN Operations │
|
||||
// ╰─────────────────────────────────────────────────────────╯
|
||||
|
||||
async function demonstrateDWNOperations(plugin: MotorPlugin): Promise<void> {
|
||||
console.log('🌐 Demonstrating DWN operations...');
|
||||
|
||||
try {
|
||||
// Create a record
|
||||
console.log('📝 Creating DWN record...');
|
||||
const recordData = new TextEncoder().encode(JSON.stringify({
|
||||
message: 'Hello from Motor DWN!',
|
||||
timestamp: new Date().toISOString(),
|
||||
version: '1.0.0',
|
||||
}));
|
||||
|
||||
const createRequest: CreateRecordRequest = {
|
||||
target: 'did:sonr:alice',
|
||||
data: recordData,
|
||||
schema: 'https://schema.org/Message',
|
||||
protocol: 'https://protocol.example.com/messaging',
|
||||
published: true,
|
||||
encrypt: true, // Encrypt the data
|
||||
};
|
||||
|
||||
const createResponse = await plugin.createRecord?.(createRequest);
|
||||
if (!createResponse) {
|
||||
console.log('ℹ️ DWN operations not available in this plugin instance');
|
||||
return;
|
||||
}
|
||||
|
||||
console.log('✅ Record created:', createResponse.record_id);
|
||||
console.log('📅 Created at:', new Date(createResponse.created_at * 1000).toISOString());
|
||||
console.log('🔒 Encrypted:', createResponse.is_encrypted);
|
||||
|
||||
// Read the record
|
||||
console.log('📖 Reading DWN record...');
|
||||
const readResponse = await plugin.readRecord?.(createResponse.record_id, createRequest.target);
|
||||
if (readResponse) {
|
||||
const decodedData = new TextDecoder().decode(readResponse.data);
|
||||
console.log('✅ Record data:', JSON.parse(decodedData));
|
||||
console.log('🔓 Decrypted successfully:', !readResponse.is_encrypted || readResponse.data.length > 0);
|
||||
}
|
||||
|
||||
// Update the record
|
||||
console.log('✏️ Updating DWN record...');
|
||||
const updatedData = new TextEncoder().encode(JSON.stringify({
|
||||
message: 'Updated message from Motor DWN!',
|
||||
timestamp: new Date().toISOString(),
|
||||
version: '1.1.0',
|
||||
updated: true,
|
||||
}));
|
||||
|
||||
const updateResponse = await plugin.updateRecord?.({
|
||||
record_id: createResponse.record_id,
|
||||
target: createRequest.target,
|
||||
data: updatedData,
|
||||
published: true,
|
||||
});
|
||||
|
||||
if (updateResponse) {
|
||||
console.log('✅ Record updated at:', new Date(updateResponse.updated_at * 1000).toISOString());
|
||||
}
|
||||
|
||||
// Delete the record
|
||||
console.log('🗑️ Deleting DWN record...');
|
||||
const deleteResponse = await plugin.deleteRecord?.(createResponse.record_id, createRequest.target);
|
||||
if (deleteResponse) {
|
||||
console.log('✅ Record deleted:', deleteResponse.status);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ DWN operation failed:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// ╭─────────────────────────────────────────────────────────╮
|
||||
// │ Health Monitoring │
|
||||
// ╰─────────────────────────────────────────────────────────╯
|
||||
|
||||
async function checkServiceHealth(plugin: MotorPlugin): Promise<void> {
|
||||
console.log('🏥 Checking service health...');
|
||||
|
||||
try {
|
||||
// Test connection
|
||||
const connected = await plugin.testConnection();
|
||||
console.log('🔗 Connected:', connected);
|
||||
|
||||
if (connected) {
|
||||
// Get health status
|
||||
const health = await plugin.getHealth();
|
||||
console.log('💓 Health status:', health.status);
|
||||
console.log('🏷️ Service:', health.service);
|
||||
console.log('📦 Version:', health.version);
|
||||
|
||||
// Get service info
|
||||
const info = await plugin.getServiceInfo();
|
||||
console.log('📋 Service info:', {
|
||||
description: info.description,
|
||||
endpoints: Object.keys(info.endpoints),
|
||||
});
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('❌ Health check failed:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// ╭─────────────────────────────────────────────────────────╮
|
||||
// │ Main Demo │
|
||||
// ╰─────────────────────────────────────────────────────────╯
|
||||
|
||||
async function runDemo(): Promise<void> {
|
||||
console.log('🎬 Starting Motor WASM Service Worker Demo');
|
||||
console.log('==========================================');
|
||||
|
||||
try {
|
||||
// Detect environment
|
||||
await detectEnvironment();
|
||||
console.log();
|
||||
|
||||
// Create plugin (auto-detection)
|
||||
const plugin = await createPlugin();
|
||||
console.log();
|
||||
|
||||
// Check service health
|
||||
await checkServiceHealth(plugin);
|
||||
console.log();
|
||||
|
||||
// Demonstrate wallet operations
|
||||
await demonstrateWalletOperations(plugin);
|
||||
console.log();
|
||||
|
||||
// Demonstrate DWN operations
|
||||
await demonstrateDWNOperations(plugin);
|
||||
console.log();
|
||||
|
||||
// Cleanup
|
||||
console.log('🧹 Cleaning up...');
|
||||
await plugin.cleanup?.();
|
||||
console.log('✅ Demo completed successfully!');
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Demo failed:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Export for use in other modules
|
||||
export {
|
||||
detectEnvironment,
|
||||
createPlugin,
|
||||
createBrowserPlugin,
|
||||
createNodePlugin,
|
||||
demonstrateWalletOperations,
|
||||
demonstrateDWNOperations,
|
||||
checkServiceHealth,
|
||||
runDemo,
|
||||
};
|
||||
|
||||
// Run demo if this file is executed directly
|
||||
if (typeof require !== 'undefined' && require.main === module) {
|
||||
runDemo().catch(console.error);
|
||||
}
|
||||
@@ -0,0 +1,136 @@
|
||||
/**
|
||||
* Example demonstrating the usage of plugins from @sonr.io/es
|
||||
*/
|
||||
|
||||
// Import plugins module
|
||||
import { plugins } from '@sonr.io/es';
|
||||
|
||||
// Or import specific plugins
|
||||
import { createVaultClient, createMotorPlugin } from '@sonr.io/es/plugins';
|
||||
|
||||
// Or import plugins directly
|
||||
import { VaultClient } from '@sonr.io/es/plugins/vault';
|
||||
import { MotorPluginImpl } from '@sonr.io/es/plugins/motor';
|
||||
|
||||
async function demonstrateVaultPlugin() {
|
||||
console.log('=== Vault Plugin Demo ===');
|
||||
|
||||
// Create a vault client
|
||||
const vault = createVaultClient({
|
||||
chainId: 'sonr-testnet-1',
|
||||
// enclave configuration would go here
|
||||
});
|
||||
|
||||
// Initialize the vault
|
||||
await vault.initialize();
|
||||
|
||||
// Get issuer DID
|
||||
const issuerInfo = await vault.getIssuerDID();
|
||||
console.log('Issuer DID:', issuerInfo.issuer_did);
|
||||
console.log('Address:', issuerInfo.address);
|
||||
|
||||
// Create a UCAN token
|
||||
const tokenResponse = await vault.newOriginToken({
|
||||
audience_did: 'did:sonr:example123',
|
||||
attenuations: [
|
||||
{ can: ['sign', 'verify'], with: 'vault://keys/*' }
|
||||
],
|
||||
expires_at: Date.now() + 3600000, // 1 hour from now
|
||||
});
|
||||
console.log('UCAN Token created:', tokenResponse.token.substring(0, 50) + '...');
|
||||
|
||||
// Sign some data
|
||||
const dataToSign = new TextEncoder().encode('Hello, Sonr!');
|
||||
const signature = await vault.signData({ data: dataToSign });
|
||||
console.log('Signature created');
|
||||
|
||||
// Verify the signature
|
||||
const verification = await vault.verifyData({
|
||||
data: dataToSign,
|
||||
signature: signature.signature,
|
||||
});
|
||||
console.log('Signature valid:', verification.valid);
|
||||
|
||||
// Clean up
|
||||
await vault.cleanup();
|
||||
}
|
||||
|
||||
async function demonstrateMotorPlugin() {
|
||||
console.log('\n=== Motor Plugin Demo ===');
|
||||
|
||||
// Create a motor plugin (auto-detects environment)
|
||||
const motor = await createMotorPlugin({
|
||||
debug: true,
|
||||
timeout: 30000,
|
||||
});
|
||||
|
||||
// Check if motor is ready
|
||||
const isReady = await motor.isReady();
|
||||
console.log('Motor ready:', isReady);
|
||||
|
||||
// Get service info
|
||||
const serviceInfo = await motor.getServiceInfo();
|
||||
console.log('Service version:', serviceInfo.version);
|
||||
console.log('Service status:', serviceInfo.status);
|
||||
|
||||
// Create a DWN record
|
||||
const record = await motor.createRecord({
|
||||
data: { message: 'Hello from Motor!' },
|
||||
published: false,
|
||||
schema: 'https://schema.org/Message',
|
||||
dataFormat: 'application/json',
|
||||
});
|
||||
console.log('Record created:', record.record_id);
|
||||
|
||||
// Read the record back
|
||||
const readResult = await motor.readRecord(record.record_id);
|
||||
console.log('Record data:', readResult.data);
|
||||
|
||||
// Create a UCAN token using motor
|
||||
const tokenResponse = await motor.newOriginToken({
|
||||
audience_did: 'did:sonr:motor123',
|
||||
attenuations: [
|
||||
{ can: ['create', 'read', 'update', 'delete'], with: 'dwn://records/*' }
|
||||
],
|
||||
});
|
||||
console.log('Motor UCAN Token:', tokenResponse.token.substring(0, 50) + '...');
|
||||
|
||||
// Clean up
|
||||
await motor.cleanup();
|
||||
}
|
||||
|
||||
async function demonstratePluginNamespaces() {
|
||||
console.log('\n=== Using Plugin Namespaces ===');
|
||||
|
||||
// Access plugins through namespace
|
||||
const vaultClient = plugins.vault.createVaultClient();
|
||||
const motorPlugin = await plugins.motor.createMotorPlugin();
|
||||
|
||||
console.log('Vault client created via namespace');
|
||||
console.log('Motor plugin created via namespace');
|
||||
|
||||
// Use the plugins...
|
||||
// ...
|
||||
|
||||
// Clean up
|
||||
await vaultClient.cleanup();
|
||||
await motorPlugin.cleanup();
|
||||
}
|
||||
|
||||
// Main execution
|
||||
async function main() {
|
||||
try {
|
||||
await demonstrateVaultPlugin();
|
||||
await demonstrateMotorPlugin();
|
||||
await demonstratePluginNamespaces();
|
||||
|
||||
console.log('\n✅ All plugin demonstrations completed successfully!');
|
||||
} catch (error) {
|
||||
console.error('❌ Error during plugin demonstration:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Run if executed directly
|
||||
if (import.meta.url === `file://${process.argv[1]}`) {
|
||||
main();
|
||||
}
|
||||
@@ -0,0 +1,382 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>Enhanced WebAuthn Example - Sonr ES</title>
|
||||
<style>
|
||||
* {
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
body {
|
||||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
|
||||
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
|
||||
min-height: 100vh;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
padding: 20px;
|
||||
}
|
||||
|
||||
.container {
|
||||
background: white;
|
||||
border-radius: 20px;
|
||||
box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
|
||||
max-width: 500px;
|
||||
width: 100%;
|
||||
padding: 40px;
|
||||
}
|
||||
|
||||
h1 {
|
||||
color: #333;
|
||||
margin-bottom: 10px;
|
||||
font-size: 28px;
|
||||
}
|
||||
|
||||
.subtitle {
|
||||
color: #666;
|
||||
margin-bottom: 30px;
|
||||
font-size: 14px;
|
||||
}
|
||||
|
||||
.preset-selector {
|
||||
margin-bottom: 30px;
|
||||
}
|
||||
|
||||
.preset-selector label {
|
||||
display: block;
|
||||
margin-bottom: 8px;
|
||||
color: #555;
|
||||
font-weight: 500;
|
||||
}
|
||||
|
||||
.preset-selector select {
|
||||
width: 100%;
|
||||
padding: 10px;
|
||||
border: 2px solid #e0e0e0;
|
||||
border-radius: 8px;
|
||||
font-size: 16px;
|
||||
background: white;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.input-group {
|
||||
margin-bottom: 20px;
|
||||
}
|
||||
|
||||
.input-group label {
|
||||
display: block;
|
||||
margin-bottom: 8px;
|
||||
color: #555;
|
||||
font-weight: 500;
|
||||
}
|
||||
|
||||
.input-group input {
|
||||
width: 100%;
|
||||
padding: 12px;
|
||||
border: 2px solid #e0e0e0;
|
||||
border-radius: 8px;
|
||||
font-size: 16px;
|
||||
transition: border-color 0.3s;
|
||||
}
|
||||
|
||||
.input-group input:focus {
|
||||
outline: none;
|
||||
border-color: #667eea;
|
||||
}
|
||||
|
||||
.button-group {
|
||||
display: flex;
|
||||
gap: 10px;
|
||||
margin-bottom: 20px;
|
||||
}
|
||||
|
||||
.webauthn-button {
|
||||
flex: 1;
|
||||
padding: 12px 20px;
|
||||
border: none;
|
||||
border-radius: 8px;
|
||||
font-size: 16px;
|
||||
font-weight: 600;
|
||||
cursor: pointer;
|
||||
transition: all 0.3s;
|
||||
color: white;
|
||||
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
|
||||
}
|
||||
|
||||
.webauthn-button:hover:not(:disabled) {
|
||||
transform: translateY(-2px);
|
||||
box-shadow: 0 10px 20px rgba(102, 126, 234, 0.4);
|
||||
}
|
||||
|
||||
.webauthn-button:disabled {
|
||||
opacity: 0.5;
|
||||
cursor: not-allowed;
|
||||
}
|
||||
|
||||
.webauthn-button.webauthn-success {
|
||||
background: linear-gradient(135deg, #56ab2f 0%, #a8e063 100%);
|
||||
}
|
||||
|
||||
.webauthn-button.webauthn-error {
|
||||
background: linear-gradient(135deg, #ff416c 0%, #ff4b2b 100%);
|
||||
}
|
||||
|
||||
.webauthn-button.webauthn-warning {
|
||||
background: linear-gradient(135deg, #f7971e 0%, #ffd200 100%);
|
||||
}
|
||||
|
||||
.status-box {
|
||||
background: #f8f9fa;
|
||||
border-radius: 8px;
|
||||
padding: 15px;
|
||||
margin-bottom: 20px;
|
||||
min-height: 60px;
|
||||
}
|
||||
|
||||
.status-box h3 {
|
||||
color: #333;
|
||||
font-size: 14px;
|
||||
margin-bottom: 8px;
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 1px;
|
||||
}
|
||||
|
||||
#status {
|
||||
color: #666;
|
||||
font-size: 14px;
|
||||
line-height: 1.5;
|
||||
}
|
||||
|
||||
.callback-log {
|
||||
background: #2d3748;
|
||||
color: #a0aec0;
|
||||
border-radius: 8px;
|
||||
padding: 15px;
|
||||
font-family: 'Courier New', monospace;
|
||||
font-size: 12px;
|
||||
max-height: 200px;
|
||||
overflow-y: auto;
|
||||
}
|
||||
|
||||
.callback-log .log-entry {
|
||||
margin-bottom: 5px;
|
||||
padding: 5px;
|
||||
border-left: 3px solid #4a5568;
|
||||
padding-left: 10px;
|
||||
}
|
||||
|
||||
.callback-log .log-entry.info {
|
||||
border-left-color: #667eea;
|
||||
}
|
||||
|
||||
.callback-log .log-entry.success {
|
||||
border-left-color: #56ab2f;
|
||||
}
|
||||
|
||||
.callback-log .log-entry.error {
|
||||
border-left-color: #ff416c;
|
||||
}
|
||||
|
||||
.callback-log .log-entry.warning {
|
||||
border-left-color: #f7971e;
|
||||
}
|
||||
|
||||
.support-info {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(3, 1fr);
|
||||
gap: 10px;
|
||||
margin-bottom: 20px;
|
||||
}
|
||||
|
||||
.support-item {
|
||||
text-align: center;
|
||||
padding: 10px;
|
||||
background: #f8f9fa;
|
||||
border-radius: 8px;
|
||||
}
|
||||
|
||||
.support-item.supported {
|
||||
background: #d4edda;
|
||||
color: #155724;
|
||||
}
|
||||
|
||||
.support-item.unsupported {
|
||||
background: #f8d7da;
|
||||
color: #721c24;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="container">
|
||||
<h1>🔐 Enhanced WebAuthn Demo</h1>
|
||||
<p class="subtitle">Sonr ES Package - Advanced Passkey Features</p>
|
||||
|
||||
<div class="support-info" id="supportInfo">
|
||||
<div class="support-item" id="webauthnSupport">WebAuthn: Checking...</div>
|
||||
<div class="support-item" id="platformSupport">Platform: Checking...</div>
|
||||
<div class="support-item" id="autofillSupport">Autofill: Checking...</div>
|
||||
</div>
|
||||
|
||||
<div class="preset-selector">
|
||||
<label for="presetSelect">Configuration Preset:</label>
|
||||
<select id="presetSelect">
|
||||
<option value="BROAD_COMPATIBILITY">Broad Compatibility (Default)</option>
|
||||
<option value="PLATFORM_ONLY">Platform Only (Biometrics)</option>
|
||||
<option value="SECURITY_KEY">Security Key Focus</option>
|
||||
<option value="MOBILE_FRIENDLY">Mobile Friendly (QR)</option>
|
||||
<option value="HIGH_SECURITY">High Security (Enterprise)</option>
|
||||
</select>
|
||||
</div>
|
||||
|
||||
<div class="input-group">
|
||||
<label for="username">Username:</label>
|
||||
<input type="text" id="username" placeholder="Enter your username" value="demo@example.com">
|
||||
</div>
|
||||
|
||||
<div class="button-group">
|
||||
<button id="registerBtn" class="webauthn-button">Register with Passkey</button>
|
||||
<button id="loginBtn" class="webauthn-button">Login with Passkey</button>
|
||||
</div>
|
||||
|
||||
<div class="status-box">
|
||||
<h3>Status</h3>
|
||||
<div id="status">Ready to start...</div>
|
||||
</div>
|
||||
|
||||
<div class="callback-log" id="callbackLog">
|
||||
<div class="log-entry info">Console initialized. Callbacks will appear here...</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Load the Sonr ES autoloader -->
|
||||
<script type="module">
|
||||
import '../dist/autoloader.js';
|
||||
|
||||
// Wait for Sonr to be ready
|
||||
window.addEventListener('sonr:ready', async (event) => {
|
||||
const Sonr = event.detail;
|
||||
console.log('Sonr ES loaded:', Sonr);
|
||||
|
||||
// Check support
|
||||
const support = await Sonr.webauthn.checkSupport();
|
||||
|
||||
// Update support indicators
|
||||
document.getElementById('webauthnSupport').textContent = `WebAuthn: ${support.supported ? '✓' : '✗'}`;
|
||||
document.getElementById('webauthnSupport').className = `support-item ${support.supported ? 'supported' : 'unsupported'}`;
|
||||
|
||||
document.getElementById('platformSupport').textContent = `Platform: ${support.platformAuthenticator ? '✓' : '✗'}`;
|
||||
document.getElementById('platformSupport').className = `support-item ${support.platformAuthenticator ? 'supported' : 'unsupported'}`;
|
||||
|
||||
document.getElementById('autofillSupport').textContent = `Autofill: ${support.available ? '✓' : '✗'}`;
|
||||
document.getElementById('autofillSupport').className = `support-item ${support.available ? 'supported' : 'unsupported'}`;
|
||||
|
||||
// Log function
|
||||
const addLog = (message, type = 'info') => {
|
||||
const log = document.getElementById('callbackLog');
|
||||
const entry = document.createElement('div');
|
||||
entry.className = `log-entry ${type}`;
|
||||
const timestamp = new Date().toLocaleTimeString();
|
||||
entry.textContent = `[${timestamp}] ${message}`;
|
||||
log.appendChild(entry);
|
||||
log.scrollTop = log.scrollHeight;
|
||||
};
|
||||
|
||||
// Get selected preset
|
||||
const getSelectedPreset = () => {
|
||||
const presetName = document.getElementById('presetSelect').value;
|
||||
return Sonr.webauthn.presets[presetName];
|
||||
};
|
||||
|
||||
// Register button
|
||||
document.getElementById('registerBtn').addEventListener('click', async () => {
|
||||
const username = document.getElementById('username').value;
|
||||
if (!username) {
|
||||
alert('Please enter a username');
|
||||
return;
|
||||
}
|
||||
|
||||
const preset = getSelectedPreset();
|
||||
addLog(`Using preset: ${document.getElementById('presetSelect').value}`, 'info');
|
||||
|
||||
const result = await Sonr.webauthn.register('http://localhost:8080', {
|
||||
username,
|
||||
displayName: username,
|
||||
config: {
|
||||
...preset,
|
||||
onRegistrationStart: (options) => {
|
||||
addLog('Registration started', 'info');
|
||||
addLog(`Challenge: ${options.challenge.substring(0, 20)}...`, 'info');
|
||||
},
|
||||
onRegistrationComplete: (credential) => {
|
||||
addLog('Registration completed!', 'success');
|
||||
addLog(`Credential ID: ${credential.id.substring(0, 30)}...`, 'success');
|
||||
},
|
||||
onRegistrationError: (error) => {
|
||||
addLog(`Registration error: ${error.message}`, 'error');
|
||||
},
|
||||
onStatusUpdate: (status, type) => {
|
||||
document.getElementById('status').textContent = status;
|
||||
addLog(status, type);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
if (result.success) {
|
||||
addLog('✅ Registration successful!', 'success');
|
||||
if (result.details) {
|
||||
addLog(`Authenticator: ${result.details.authenticatorAttachment || 'cross-platform'}`, 'info');
|
||||
}
|
||||
} else {
|
||||
addLog(`❌ Registration failed: ${result.error}`, 'error');
|
||||
}
|
||||
});
|
||||
|
||||
// Login button
|
||||
document.getElementById('loginBtn').addEventListener('click', async () => {
|
||||
const username = document.getElementById('username').value;
|
||||
|
||||
const preset = getSelectedPreset();
|
||||
addLog(`Using preset: ${document.getElementById('presetSelect').value}`, 'info');
|
||||
|
||||
const result = await Sonr.webauthn.login('http://localhost:8080', {
|
||||
username: username || undefined,
|
||||
config: {
|
||||
...preset,
|
||||
onAuthenticationStart: (options) => {
|
||||
addLog('Authentication started', 'info');
|
||||
addLog(`Challenge: ${options.challenge.substring(0, 20)}...`, 'info');
|
||||
},
|
||||
onAuthenticationComplete: (credential) => {
|
||||
addLog('Authentication completed!', 'success');
|
||||
addLog(`Credential ID: ${credential.id.substring(0, 30)}...`, 'success');
|
||||
},
|
||||
onAuthenticationError: (error) => {
|
||||
addLog(`Authentication error: ${error.message}`, 'error');
|
||||
},
|
||||
onStatusUpdate: (status, type) => {
|
||||
document.getElementById('status').textContent = status;
|
||||
addLog(status, type);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
if (result.success) {
|
||||
addLog('✅ Login successful!', 'success');
|
||||
if (result.details) {
|
||||
addLog(`Authenticator: ${result.details.authenticatorAttachment || 'cross-platform'}`, 'info');
|
||||
}
|
||||
} else {
|
||||
addLog(`❌ Login failed: ${result.error}`, 'error');
|
||||
}
|
||||
});
|
||||
|
||||
// Initial log
|
||||
addLog('Sonr ES WebAuthn Enhanced loaded and ready', 'success');
|
||||
});
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,151 @@
|
||||
{
|
||||
"name": "@sonr.io/es",
|
||||
"version": "0.0.12",
|
||||
"private": false,
|
||||
"sideEffects": false,
|
||||
"type": "module",
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"files": [
|
||||
"dist",
|
||||
"README.md"
|
||||
],
|
||||
"main": "./dist/index.js",
|
||||
"module": "./dist/index.js",
|
||||
"jsdelivr": "./dist/index.js",
|
||||
"unpkg": "./dist/index.js",
|
||||
"browser": "./dist/index.js",
|
||||
"exports": {
|
||||
".": {
|
||||
"import": "./dist/index.js",
|
||||
"default": "./dist/index.js"
|
||||
},
|
||||
"./autoloader": {
|
||||
"import": "./dist/autoloader.js",
|
||||
"default": "./dist/autoloader.js"
|
||||
},
|
||||
"./client": {
|
||||
"import": "./dist/client/index.js",
|
||||
"default": "./dist/client/index.js"
|
||||
},
|
||||
"./client/auth": {
|
||||
"import": "./dist/client/auth/index.js",
|
||||
"default": "./dist/client/auth/index.js"
|
||||
},
|
||||
"./plugins": {
|
||||
"import": "./dist/plugins/index.js",
|
||||
"default": "./dist/plugins/index.js"
|
||||
},
|
||||
"./plugins/motor": {
|
||||
"import": "./dist/plugins/motor/index.js",
|
||||
"default": "./dist/plugins/motor/index.js"
|
||||
},
|
||||
"./plugins/vault": {
|
||||
"import": "./dist/plugins/vault/index.js",
|
||||
"default": "./dist/plugins/vault/index.js"
|
||||
},
|
||||
"./codec": {
|
||||
"import": "./dist/codec/index.js",
|
||||
"default": "./dist/codec/index.js"
|
||||
},
|
||||
"./protobufs": {
|
||||
"import": "./dist/protobufs/index.js",
|
||||
"default": "./dist/protobufs/index.js"
|
||||
},
|
||||
"./registry": {
|
||||
"import": "./dist/registry/index.js",
|
||||
"default": "./dist/registry/index.js"
|
||||
},
|
||||
"./wallet": {
|
||||
"import": "./dist/wallet/index.js",
|
||||
"default": "./dist/wallet/index.js"
|
||||
}
|
||||
},
|
||||
"scripts": {
|
||||
"clean": "rimraf dist",
|
||||
"generate": "pnpm gen:protobufs && pnpm gen:registry",
|
||||
"build": "pnpm clean && tsc && tsc-alias && pnpm copy:assets",
|
||||
"copy:assets": "npm run copy:wasm && npm run copy:autoloader",
|
||||
"copy:wasm": "npm run copy:vault-wasm && npm run copy:motor-wasm",
|
||||
"copy:vault-wasm": "cp src/plugin/plugin.wasm dist/plugin/ 2>/dev/null || true",
|
||||
"copy:motor-wasm": "cp src/worker/app.wasm dist/worker/ 2>/dev/null || true && cp src/worker/wasm_exec.js dist/worker/ 2>/dev/null || true",
|
||||
"copy:autoloader": "cp src/autoloader.js dist/autoloader.js 2>/dev/null || true",
|
||||
"dev": "concurrently \"tsc -w\" \"tsc-alias -w\"",
|
||||
"gen:protobufs": "node scripts/gen-protobufs.mjs",
|
||||
"gen:registry": "node scripts/gen-registry.mjs",
|
||||
"lint": "biome lint .",
|
||||
"format": "biome format . --write",
|
||||
"check": "biome check .",
|
||||
"typecheck": "tsc --noEmit",
|
||||
"test": "vitest --run",
|
||||
"test:suite": "pnpm check && pnpm typecheck && pnpm test",
|
||||
"prepublishOnly": "pnpm build",
|
||||
"release": "cz --no-raise 6,21 bump --yes --increment PATCH"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@bufbuild/protobuf": "1.2.0",
|
||||
"@noble/hashes": "^1.3.2",
|
||||
"@noble/secp256k1": "^2.0.0",
|
||||
"@scure/base": "^1.1.3",
|
||||
"@scure/bip32": "^1.3.2",
|
||||
"@scure/bip39": "^1.2.1",
|
||||
"@walletconnect/legacy-client": "^2.0.0",
|
||||
"@walletconnect/sign-client": "2.8.6",
|
||||
"lodash-es": "^4.17.21"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@biomejs/biome": "^2.1.2",
|
||||
"@bufbuild/buf": "1.18.0-1",
|
||||
"@bufbuild/protobuf": "1.2.0",
|
||||
"@bufbuild/protoc-gen-es": "1.2.0",
|
||||
"@bufbuild/protoplugin": "1.2.0",
|
||||
"@keplr-wallet/types": "^0.11.62",
|
||||
"@metamask/providers": "^14.0.2",
|
||||
"@noble/hashes": "^1.3.2",
|
||||
"@noble/secp256k1": "^2.0.0",
|
||||
"@scure/base": "^1.1.3",
|
||||
"@scure/bip32": "^1.3.2",
|
||||
"@scure/bip39": "^1.2.1",
|
||||
"@simplewebauthn/types": "^12.0.0",
|
||||
"@testing-library/jest-dom": "^6.8.0",
|
||||
"@testing-library/react": "^16.3.0",
|
||||
"@types/degit": "^2.8.3",
|
||||
"@types/lodash-es": "^4.17.7",
|
||||
"@vitest/ui": "^3.2.4",
|
||||
"@walletconnect/legacy-client": "^2.0.0",
|
||||
"@walletconnect/legacy-types": "^2.0.0",
|
||||
"@walletconnect/sign-client": "2.8.6",
|
||||
"@walletconnect/types": "2.8.6",
|
||||
"autoprefixer": "^10.4.14",
|
||||
"concurrently": "^8.0.1",
|
||||
"degit": "^2.8.4",
|
||||
"glob": "^10.2.3",
|
||||
"jsdom": "^26.1.0",
|
||||
"json-schema-to-typescript": "^13.1.1",
|
||||
"lodash-es": "^4.17.21",
|
||||
"postcss": "^8.4.23",
|
||||
"rimraf": "^5.0.0",
|
||||
"tsc-alias": "^1.8.6",
|
||||
"tsx": "^3.12.7",
|
||||
"typescript": "^5.0.4",
|
||||
"vitest": "^3.2.4",
|
||||
"fake-indexeddb": "^6.0.0"
|
||||
},
|
||||
"dependencies": {
|
||||
"@extism/extism": "2.0.0-rc13",
|
||||
"@simplewebauthn/browser": "^9.0.1",
|
||||
"dexie": "^4.0.1",
|
||||
"helia": "^4.0.0",
|
||||
"@helia/unixfs": "^3.0.0",
|
||||
"@helia/verified-fetch": "^1.0.0",
|
||||
"@helia/strings": "^3.0.0",
|
||||
"@libp2p/webrtc": "^4.0.0",
|
||||
"@libp2p/websockets": "^8.0.0",
|
||||
"@chainsafe/libp2p-noise": "^15.0.0",
|
||||
"@chainsafe/libp2p-yamux": "^6.0.0",
|
||||
"multiformats": "^13.0.0",
|
||||
"uint8arrays": "^5.0.0",
|
||||
"@tanstack/query-core": "^5.0.0"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,199 @@
|
||||
// @ts-check
|
||||
|
||||
/**
|
||||
* This script generates the src/protobufs directory from the proto files in the
|
||||
* repos specified in `REPOS`. It uses `buf` to generate TS files from the proto
|
||||
* files, and then generates an `index.ts` file to re-export the generated code.
|
||||
*/
|
||||
|
||||
import { spawnSync } from "child_process";
|
||||
import degit from "degit";
|
||||
import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
|
||||
import { globSync } from "glob";
|
||||
import { capitalize } from "lodash-es";
|
||||
import { dirname, join } from "path";
|
||||
import { fileURLToPath } from "url";
|
||||
|
||||
/**
|
||||
* @typedef Repo
|
||||
* @type {object}
|
||||
* @property {string} repo - Git repo and branch to clone
|
||||
* @property {string[]} paths - Paths to proto files relative to the repo root
|
||||
*/
|
||||
|
||||
/**
|
||||
* TODO: Add more repos here when necessary.
|
||||
* @type {Repo[]}
|
||||
*/
|
||||
const REPOS = [
|
||||
// NOTE: cosmos-sdk is excluded because we use pre-generated cosmos proto files
|
||||
// to avoid issues with degit and version mismatches
|
||||
{
|
||||
repo: "cosmos/ibc-go#main",
|
||||
paths: ["proto"],
|
||||
},
|
||||
// Use local proto files for sonr instead of fetching from external repo
|
||||
// {
|
||||
// repo: "onsonr/sonr#main",
|
||||
// paths: ["proto"],
|
||||
// },
|
||||
{
|
||||
repo: "CosmWasm/wasmd#main",
|
||||
paths: ["proto"],
|
||||
},
|
||||
{
|
||||
repo: "osmosis-labs/osmosis#main",
|
||||
paths: ["proto"],
|
||||
},
|
||||
{
|
||||
repo: "evmos/ethermint#main",
|
||||
paths: ["proto"],
|
||||
},
|
||||
// Commented out babylon as it requires cosmos/staking which we don't generate
|
||||
// {
|
||||
// repo: "nomic-io/nomic#develop",
|
||||
// paths: ["src/babylon/proto"],
|
||||
// },
|
||||
];
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
const PROTOBUFS_DIR = join(__dirname, "..", "src", "protobufs");
|
||||
const TMP_DIR = join(PROTOBUFS_DIR, ".tmp");
|
||||
/** Generates a unique dirname from `repo` to use in `TMP_DIR`. */
|
||||
const id = (/** @type {string} */ repo) => repo.replace(/[#/]/g, "-");
|
||||
|
||||
console.log("Initialising directories...");
|
||||
{
|
||||
// Don't delete the entire protobufs directory to preserve cosmos files
|
||||
// Only delete directories that will be regenerated
|
||||
rmSync(TMP_DIR, { recursive: true, force: true });
|
||||
mkdirSync(TMP_DIR);
|
||||
|
||||
// Ensure protobufs directory exists
|
||||
mkdirSync(PROTOBUFS_DIR, { recursive: true });
|
||||
|
||||
// Only clean up directories for repos we're regenerating
|
||||
const dirsToClean = [
|
||||
"ibc",
|
||||
"cosmwasm",
|
||||
"osmosis",
|
||||
"ethermint",
|
||||
"babylon", // Add babylon to clean list
|
||||
"did",
|
||||
"dwn",
|
||||
"svc",
|
||||
];
|
||||
for (const dir of dirsToClean) {
|
||||
const dirPath = join(PROTOBUFS_DIR, dir);
|
||||
rmSync(dirPath, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
console.log("Cloning required repos...");
|
||||
{
|
||||
await Promise.all(
|
||||
REPOS.map(({ repo }) => degit(repo).clone(join(TMP_DIR, id(repo))))
|
||||
);
|
||||
}
|
||||
|
||||
console.log("Generating TS files from proto files...");
|
||||
{
|
||||
for (const { repo, paths } of REPOS) {
|
||||
for (const path of paths) {
|
||||
spawnSync(
|
||||
"pnpm",
|
||||
[
|
||||
"buf",
|
||||
"generate",
|
||||
join(TMP_DIR, id(repo), path),
|
||||
"--output",
|
||||
join(
|
||||
PROTOBUFS_DIR,
|
||||
repo.startsWith("dymensionxyz") ? "dymension" : ""
|
||||
),
|
||||
],
|
||||
{
|
||||
cwd: process.cwd(),
|
||||
stdio: "inherit",
|
||||
}
|
||||
);
|
||||
}
|
||||
console.log(`✔️ [${repo}]`);
|
||||
}
|
||||
|
||||
// Generate from local Sonr proto files
|
||||
console.log("Generating TS files from local Sonr proto files...");
|
||||
const localProtoPath = join(__dirname, "..", "..", "..", "proto");
|
||||
spawnSync(
|
||||
"pnpm",
|
||||
["buf", "generate", localProtoPath, "--output", PROTOBUFS_DIR],
|
||||
{
|
||||
cwd: process.cwd(),
|
||||
stdio: "inherit",
|
||||
}
|
||||
);
|
||||
console.log(`✔️ [local sonr proto files]`);
|
||||
}
|
||||
|
||||
console.log("Generating src/index.ts file and renaming exports...");
|
||||
{
|
||||
const LAST_SEGMENT_REGEX = /[^/]+$/;
|
||||
const EXPORTED_NAME_REGEX = /^export \w+ (\w+) /gm;
|
||||
let contents =
|
||||
"/** This file is generated by gen-protobufs.mjs. Do not edit. */\n\n";
|
||||
/**
|
||||
* Builds the `src/proto/index.ts` file to re-export generated code.
|
||||
* A prefix is added to the exported names to avoid name collisions.
|
||||
* The prefix is the names of the directories in `proto` leading up
|
||||
* to the directory of the exported code, concatenated in PascalCase.
|
||||
* For example, if the exported code is in `proto/foo/bar/goo.ts`, the
|
||||
* prefix will be `FooBar`.
|
||||
* @param {string} dir
|
||||
*/
|
||||
function generateIndexExports(dir) {
|
||||
const files = globSync(join(dir, "*"));
|
||||
if (files.length === 0) {
|
||||
return;
|
||||
}
|
||||
const prefixName = dir
|
||||
.replace(PROTOBUFS_DIR + "/", "")
|
||||
.split("/")
|
||||
.map((name) =>
|
||||
// convert all names to PascalCase
|
||||
name.split(/[-_]/).map(capitalize).join("")
|
||||
)
|
||||
.join("");
|
||||
for (const file of files) {
|
||||
const fileName = file.match(LAST_SEGMENT_REGEX)?.[0];
|
||||
if (!fileName) {
|
||||
console.error("Could not find name for", file);
|
||||
continue;
|
||||
}
|
||||
if (!fileName.endsWith(".ts")) {
|
||||
continue;
|
||||
}
|
||||
const code = readFileSync(file, "utf8");
|
||||
contents += `export {\n`;
|
||||
for (const match of code.matchAll(EXPORTED_NAME_REGEX)) {
|
||||
const exportedName = match[1];
|
||||
contents += ` ${exportedName} as ${prefixName + exportedName},\n`;
|
||||
}
|
||||
const exportedFile = file
|
||||
.replace(PROTOBUFS_DIR + "/", "")
|
||||
.replace(".ts", ".js");
|
||||
contents += `} from "./${exportedFile}";\n`;
|
||||
}
|
||||
for (const file of files) {
|
||||
generateIndexExports(file);
|
||||
}
|
||||
}
|
||||
generateIndexExports(PROTOBUFS_DIR);
|
||||
writeFileSync(join(PROTOBUFS_DIR, "index.ts"), contents);
|
||||
}
|
||||
|
||||
console.log("Cleaning up...");
|
||||
{
|
||||
rmSync(TMP_DIR, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
console.log("Proto generation completed successfully!");
|
||||
@@ -0,0 +1,53 @@
|
||||
import { writeFileSync } from "fs";
|
||||
import { compile } from "json-schema-to-typescript";
|
||||
import { dirname, join } from "path";
|
||||
import { fileURLToPath } from "url";
|
||||
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
|
||||
async function genChainRegistryChainInfo() {
|
||||
const tsName = "ChainRegistryChainInfo";
|
||||
const tsFile = tsName + ".ts";
|
||||
|
||||
console.log("Retrieving JSON schema...");
|
||||
const res = await fetch(
|
||||
"https://raw.githubusercontent.com/cosmos/chain-registry/master/chain.schema.json"
|
||||
);
|
||||
const schema = await res.json();
|
||||
schema.title = tsName;
|
||||
|
||||
console.log("Compiling JSON schema to TypeScript...");
|
||||
const types = await compile(schema, tsName, {
|
||||
// See: https://github.com/bcherny/json-schema-to-typescript?tab=readme-ov-file#options
|
||||
strictIndexSignatures: true,
|
||||
});
|
||||
|
||||
const target = join(__dirname, "..", "src", "registry", "types", tsFile);
|
||||
writeFileSync(target, types);
|
||||
console.log("Wrote types to", target);
|
||||
}
|
||||
|
||||
async function genChainRegistryAssetList() {
|
||||
const tsName = "ChainRegistryAssetList";
|
||||
const tsFile = tsName + ".ts";
|
||||
|
||||
console.log("Retrieving JSON schema...");
|
||||
const res = await fetch(
|
||||
"https://raw.githubusercontent.com/cosmos/chain-registry/master/assetlist.schema.json"
|
||||
);
|
||||
const schema = await res.json();
|
||||
schema.title = tsName;
|
||||
|
||||
console.log("Compiling JSON schema to TypeScript...");
|
||||
const types = await compile(schema, tsName, {
|
||||
// See: https://github.com/bcherny/json-schema-to-typescript?tab=readme-ov-file#options
|
||||
strictIndexSignatures: true,
|
||||
});
|
||||
|
||||
const target = join(__dirname, "..", "src", "registry", "types", tsFile);
|
||||
writeFileSync(target, types);
|
||||
console.log("Wrote types to", target);
|
||||
}
|
||||
|
||||
await genChainRegistryChainInfo();
|
||||
await genChainRegistryAssetList();
|
||||
Executable
+50
@@ -0,0 +1,50 @@
|
||||
#!/usr/bin/env node
|
||||
// @ts-check
|
||||
|
||||
/**
|
||||
* This is a custom plugin for `buf` that generates TS files from the services
|
||||
* defined in the proto files, and is referred to by the root `buf.gen.yaml`.
|
||||
* Files generated using this plugin contains the `_@sonr.io/es` suffix.
|
||||
*
|
||||
* Do not convert this to a TS file as it runs 4x slower!
|
||||
*/
|
||||
|
||||
import { createEcmaScriptPlugin, runNodeJs } from "@bufbuild/protoplugin";
|
||||
import {
|
||||
literalString,
|
||||
localName,
|
||||
makeJsDoc,
|
||||
} from "@bufbuild/protoplugin/ecmascript";
|
||||
|
||||
export function generateTs(schema) {
|
||||
for (const protoFile of schema.files) {
|
||||
const file = schema.generateFile(protoFile.name + "_cosmes.ts");
|
||||
file.preamble(protoFile);
|
||||
for (const service of protoFile.services) {
|
||||
generateService(schema, file, service);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function generateService(schema, f, service) {
|
||||
f.print("const TYPE_NAME = ", literalString(service.typeName), ";");
|
||||
f.print("");
|
||||
for (const method of service.methods) {
|
||||
f.print(makeJsDoc(method));
|
||||
f.print("export const ", localName(service), method.name, "Service = {");
|
||||
f.print(" typeName: TYPE_NAME,");
|
||||
f.print(" method: ", literalString(method.name), ",");
|
||||
f.print(" Request: ", method.input, ",");
|
||||
f.print(" Response: ", method.output, ",");
|
||||
f.print("} as const;");
|
||||
f.print("");
|
||||
}
|
||||
}
|
||||
|
||||
runNodeJs(
|
||||
createEcmaScriptPlugin({
|
||||
name: "protoc-gen-cosmes",
|
||||
version: "v0.0.1",
|
||||
generateTs,
|
||||
})
|
||||
);
|
||||
@@ -0,0 +1,203 @@
|
||||
/**
|
||||
* @sonr.io/es - ESM Autoloader for Browser
|
||||
*
|
||||
* This file automatically loads and exposes all Sonr ES modules
|
||||
* for browser usage via script tag or dynamic import.
|
||||
*
|
||||
* Usage:
|
||||
* <script type="module" src="https://unpkg.com/@sonr.io/es/dist/autoloader.js"></script>
|
||||
*
|
||||
* All exports are available on window.Sonr namespace
|
||||
*/
|
||||
|
||||
// Import all modules
|
||||
import * as auth from './client/auth/index.js';
|
||||
import * as client from './client/index.js';
|
||||
import * as codec from './codec/index.js';
|
||||
import * as wallet from './wallet/index.js';
|
||||
import * as registry from './registry/index.js';
|
||||
import * as plugins from './plugins/index.js';
|
||||
|
||||
// Import specific auth utilities for convenience
|
||||
import {
|
||||
registerWithPasskey,
|
||||
loginWithPasskey,
|
||||
isWebAuthnSupported,
|
||||
isWebAuthnAvailable,
|
||||
isConditionalMediationAvailable,
|
||||
bufferToBase64url,
|
||||
base64urlToBuffer,
|
||||
checkConditionalMediationSupport,
|
||||
createRegistrationButton,
|
||||
createLoginButton,
|
||||
DEFAULT_WEBAUTHN_CONFIG,
|
||||
WEBAUTHN_PRESETS
|
||||
} from './client/auth/webauthn.js';
|
||||
|
||||
// Create the main Sonr namespace
|
||||
const Sonr = {
|
||||
// Core modules
|
||||
auth,
|
||||
client,
|
||||
codec,
|
||||
wallet,
|
||||
registry,
|
||||
plugins,
|
||||
|
||||
// Convenience shortcuts for common operations
|
||||
webauthn: {
|
||||
register: registerWithPasskey,
|
||||
login: loginWithPasskey,
|
||||
isSupported: isWebAuthnSupported,
|
||||
isAvailable: isWebAuthnAvailable,
|
||||
isConditionalAvailable: isConditionalMediationAvailable,
|
||||
bufferToBase64url,
|
||||
base64urlToBuffer,
|
||||
checkSupport: checkConditionalMediationSupport,
|
||||
createRegistrationButton,
|
||||
createLoginButton,
|
||||
|
||||
// Configuration
|
||||
config: DEFAULT_WEBAUTHN_CONFIG,
|
||||
presets: WEBAUTHN_PRESETS
|
||||
},
|
||||
|
||||
// Plugin shortcuts
|
||||
motor: plugins.motor,
|
||||
vault: plugins.vault,
|
||||
|
||||
// Factory functions for plugins
|
||||
createMotorPlugin: plugins.createMotorPlugin,
|
||||
createVaultClient: plugins.createVaultClient,
|
||||
|
||||
// Version info
|
||||
version: '0.0.8',
|
||||
|
||||
// Initialization function for custom configuration
|
||||
init: async (config = {}) => {
|
||||
console.log('[Sonr] Initializing with config:', config);
|
||||
|
||||
// Initialize Motor plugin if service worker is available
|
||||
if ('serviceWorker' in navigator && config.enableMotor !== false) {
|
||||
try {
|
||||
const motorPlugin = await plugins.createMotorPluginForBrowser({
|
||||
wasmUrl: config.motorWasmUrl || '/motor.wasm',
|
||||
...config.motor
|
||||
});
|
||||
Sonr.motor.instance = motorPlugin;
|
||||
console.log('[Sonr] Motor plugin initialized');
|
||||
} catch (error) {
|
||||
console.warn('[Sonr] Motor plugin initialization failed:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Initialize Vault client if requested
|
||||
if (config.enableVault) {
|
||||
try {
|
||||
const vaultClient = await plugins.createVaultClient(config.vault);
|
||||
Sonr.vault.instance = vaultClient;
|
||||
console.log('[Sonr] Vault client initialized');
|
||||
} catch (error) {
|
||||
console.warn('[Sonr] Vault client initialization failed:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Check WebAuthn availability
|
||||
if (await isWebAuthnAvailable()) {
|
||||
console.log('[Sonr] WebAuthn is available');
|
||||
Sonr.webauthn.available = true;
|
||||
|
||||
// Check for conditional mediation (autofill)
|
||||
if (await isConditionalMediationAvailable()) {
|
||||
console.log('[Sonr] Conditional mediation (autofill) is available');
|
||||
Sonr.webauthn.conditionalAvailable = true;
|
||||
}
|
||||
}
|
||||
|
||||
return Sonr;
|
||||
},
|
||||
|
||||
// Helper to check if running in browser
|
||||
isBrowser: typeof window !== 'undefined',
|
||||
|
||||
// Helper to check if running in Node.js
|
||||
isNode: typeof process !== 'undefined' && process.versions && process.versions.node,
|
||||
|
||||
// Helper to get environment info
|
||||
getEnvironment: () => {
|
||||
if (typeof window !== 'undefined') {
|
||||
return {
|
||||
type: 'browser',
|
||||
userAgent: navigator.userAgent,
|
||||
platform: navigator.platform,
|
||||
language: navigator.language,
|
||||
online: navigator.onLine,
|
||||
serviceWorker: 'serviceWorker' in navigator,
|
||||
webauthn: 'credentials' in navigator
|
||||
};
|
||||
} else if (typeof process !== 'undefined') {
|
||||
return {
|
||||
type: 'node',
|
||||
version: process.version,
|
||||
platform: process.platform,
|
||||
arch: process.arch
|
||||
};
|
||||
}
|
||||
return { type: 'unknown' };
|
||||
}
|
||||
};
|
||||
|
||||
// Auto-initialize with default settings if in browser
|
||||
if (typeof window !== 'undefined') {
|
||||
// Make Sonr globally available
|
||||
window.Sonr = Sonr;
|
||||
|
||||
// Auto-init on DOMContentLoaded if not already loaded
|
||||
if (document.readyState === 'loading') {
|
||||
document.addEventListener('DOMContentLoaded', async () => {
|
||||
if (!window.Sonr.initialized) {
|
||||
await Sonr.init();
|
||||
window.Sonr.initialized = true;
|
||||
console.log('[Sonr] Auto-initialized on DOMContentLoaded');
|
||||
|
||||
// Dispatch custom event
|
||||
window.dispatchEvent(new CustomEvent('sonr:ready', { detail: Sonr }));
|
||||
}
|
||||
});
|
||||
} else {
|
||||
// DOM already loaded, init immediately
|
||||
(async () => {
|
||||
if (!window.Sonr.initialized) {
|
||||
await Sonr.init();
|
||||
window.Sonr.initialized = true;
|
||||
console.log('[Sonr] Auto-initialized (DOM already loaded)');
|
||||
|
||||
// Dispatch custom event
|
||||
window.dispatchEvent(new CustomEvent('sonr:ready', { detail: Sonr }));
|
||||
}
|
||||
})();
|
||||
}
|
||||
|
||||
// Log availability
|
||||
console.log('[Sonr] Library loaded. Access via window.Sonr or import modules directly.');
|
||||
console.log('[Sonr] Environment:', Sonr.getEnvironment());
|
||||
}
|
||||
|
||||
// Export everything for ES module usage
|
||||
export default Sonr;
|
||||
export {
|
||||
auth,
|
||||
client,
|
||||
codec,
|
||||
wallet,
|
||||
registry,
|
||||
plugins,
|
||||
// WebAuthn shortcuts
|
||||
registerWithPasskey,
|
||||
loginWithPasskey,
|
||||
isWebAuthnSupported,
|
||||
isWebAuthnAvailable,
|
||||
isConditionalMediationAvailable,
|
||||
bufferToBase64url,
|
||||
base64urlToBuffer
|
||||
};
|
||||
@@ -0,0 +1,16 @@
|
||||
import type { Prettify } from '../../typeutils/prettify';
|
||||
import { RpcClient } from '../clients/RpcClient';
|
||||
import type { ToSignedProtoParams, Tx } from '../models/Tx';
|
||||
|
||||
export type BroadcastTxParams = Prettify<
|
||||
ToSignedProtoParams & {
|
||||
tx: Tx;
|
||||
}
|
||||
>;
|
||||
|
||||
/**
|
||||
* Broadcasts a tx to the network and returns the tx hash if successful.
|
||||
*/
|
||||
export async function broadcastTx(endpoint: string, { tx, ...params }: BroadcastTxParams) {
|
||||
return RpcClient.broadcastTx(endpoint, tx.toSignedProto(params));
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
// TODO: This file needs CosmosAuthV1beta1QueryAccountService from protobufs
|
||||
// which is not currently available. The function is stubbed out until
|
||||
// the protobuf definitions are added.
|
||||
|
||||
export type GetAccountParams = {
|
||||
address: string;
|
||||
};
|
||||
|
||||
export type GetAccountResponse = any; // TODO: Define proper type
|
||||
|
||||
// TODO: Implement getAccount function when CosmosAuthV1beta1QueryAccountService protobuf is available
|
||||
// This function should query account information from the auth module
|
||||
// Parameters: endpoint (RPC/API endpoint), params (address to query)
|
||||
// Returns: Account information including account number, sequence, and public key
|
||||
export async function getAccount(
|
||||
_endpoint: string,
|
||||
_params: GetAccountParams
|
||||
): Promise<GetAccountResponse> {
|
||||
// TODO: Implement when QueryAccountService is available
|
||||
// Steps needed:
|
||||
// 1. Import CosmosAuthV1beta1QueryAccountService from protobufs
|
||||
// 2. Create query request with address from params
|
||||
// 3. Send query to endpoint
|
||||
// 4. Parse and return account response
|
||||
throw new Error('getAccount not implemented - missing QueryAccountService');
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
import { queryContract } from './queryContract';
|
||||
|
||||
export type GetCw20BalanceParams = {
|
||||
address: string;
|
||||
token: string;
|
||||
};
|
||||
|
||||
type Response = {
|
||||
balance: string;
|
||||
};
|
||||
|
||||
export async function getCw20Balance(
|
||||
endpoint: string,
|
||||
{ address, token }: GetCw20BalanceParams
|
||||
): Promise<bigint> {
|
||||
try {
|
||||
const { balance } = await queryContract<Response>(endpoint, {
|
||||
address: token,
|
||||
query: {
|
||||
balance: {
|
||||
address: address,
|
||||
},
|
||||
},
|
||||
});
|
||||
return BigInt(balance);
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return 0n;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
// TODO: This file needs CosmosBankV1beta1QueryAllBalancesService from protobufs
|
||||
// which is not currently available. The functions are stubbed out until
|
||||
// the protobuf definitions are added.
|
||||
|
||||
export type GetNativeBalancesParams = {
|
||||
address: string;
|
||||
pagination?: {
|
||||
key?: Uint8Array;
|
||||
offset?: bigint;
|
||||
limit?: bigint;
|
||||
countTotal?: boolean;
|
||||
reverse?: boolean;
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Gets native balances for an address with pagination support.
|
||||
*
|
||||
* NOTE: This function currently has a placeholder implementation because
|
||||
* CosmosBankV1beta1QueryAllBalancesService is not available in the current
|
||||
* protobufs. It should be updated when bank module protobufs are added.
|
||||
*/
|
||||
// TODO: Implement getNativeBalances function when CosmosBankV1beta1QueryAllBalancesService protobuf is available
|
||||
// This function should query all balances for a given address with pagination support
|
||||
// Parameters: endpoint (RPC/API endpoint), params (address and pagination options)
|
||||
// Returns: Array of coin balances with pagination metadata
|
||||
export async function getNativeBalances(_endpoint: string, _params: GetNativeBalancesParams) {
|
||||
// TODO: Implement when CosmosBankV1beta1QueryAllBalancesService is available
|
||||
// Steps needed:
|
||||
// 1. Import CosmosBankV1beta1QueryAllBalancesService from protobufs
|
||||
// 2. Create query request with address and pagination from params
|
||||
// 3. Send query to endpoint
|
||||
// 4. Parse and return balances with pagination info
|
||||
throw new Error(
|
||||
'Bank module not available - CosmosBankV1beta1QueryAllBalancesService needs to be added to protobufs'
|
||||
);
|
||||
}
|
||||
|
||||
// TODO: Implement getAllNativeBalances function when CosmosBankV1beta1QueryAllBalancesService protobuf is available
|
||||
// This function should query all balances for a given address without pagination limits
|
||||
// Parameters: endpoint (RPC/API endpoint), address (account address to query)
|
||||
// Returns: Complete array of all coin balances for the address
|
||||
export async function getAllNativeBalances(_endpoint: string, _address: string): Promise<any[]> {
|
||||
// TODO: Implement when CosmosBankV1beta1QueryAllBalancesService is available
|
||||
// Steps needed:
|
||||
// 1. Import CosmosBankV1beta1QueryAllBalancesService from protobufs
|
||||
// 2. Create query request with address, iterate through all pages
|
||||
// 3. Send multiple queries if needed to get all balances
|
||||
// 4. Aggregate and return complete balance list
|
||||
throw new Error(
|
||||
'Bank module not available - CosmosBankV1beta1QueryAllBalancesService needs to be added to protobufs'
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
import {
|
||||
type CosmosTxV1beta1GetTxResponse as GetTxResponse,
|
||||
CosmosTxV1beta1ServiceGetTxService as GetTxService,
|
||||
} from '@sonr.io/es/protobufs';
|
||||
|
||||
import { RpcClient } from '../clients/RpcClient';
|
||||
|
||||
export type GetTxParams = {
|
||||
hash: string;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the tx matching the given hash. Throws if the tx is not found.
|
||||
*/
|
||||
export async function getTx(endpoint: string, params: GetTxParams) {
|
||||
const res = await RpcClient.query(endpoint, GetTxService, params);
|
||||
if (!res.tx || !res.txResponse) {
|
||||
throw new Error('Tx not found');
|
||||
}
|
||||
return res as Required<GetTxResponse>;
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
import { wait } from '../utils/wait';
|
||||
import { getTx } from './getTx';
|
||||
|
||||
export type PollTxParams = {
|
||||
hash: string;
|
||||
intervalSeconds?: number;
|
||||
maxAttempts?: number;
|
||||
};
|
||||
|
||||
/**
|
||||
* Polls for the tx matching the given `hash`, with a minimum interval of
|
||||
* `intervalSeconds`. Throws if the tx is not found after the given number
|
||||
* of `maxAttempts`.
|
||||
*/
|
||||
export async function pollTx(
|
||||
endpoint: string,
|
||||
{ intervalSeconds = 2, maxAttempts = 64, ...getTxParams }: PollTxParams
|
||||
) {
|
||||
const intervalMillis = intervalSeconds * 1000;
|
||||
for (let i = 0; i < maxAttempts; i++) {
|
||||
try {
|
||||
return await getTx(endpoint, getTxParams);
|
||||
} catch (_err) {
|
||||
await wait(intervalMillis);
|
||||
}
|
||||
}
|
||||
throw new Error('Tx not found');
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
import type { JsonValue } from '@bufbuild/protobuf';
|
||||
import { utf8 } from '@sonr.io/es/codec';
|
||||
import { CosmwasmWasmV1QuerySmartContractStateService as QuerySmartContractStateService } from '@sonr.io/es/protobufs';
|
||||
|
||||
import { RpcClient } from '../clients/RpcClient';
|
||||
|
||||
export type QueryContractParams = {
|
||||
address: string;
|
||||
query: JsonValue;
|
||||
};
|
||||
|
||||
/**
|
||||
* Queries the contract at `address` with the given `query` JSON message,
|
||||
* and returns the parsed JSON response.
|
||||
*/
|
||||
export async function queryContract<T extends JsonValue>(
|
||||
endpoint: string,
|
||||
{ address, query }: QueryContractParams
|
||||
): Promise<T> {
|
||||
const { data } = await RpcClient.query(endpoint, QuerySmartContractStateService, {
|
||||
address,
|
||||
queryData: utf8.decode(JSON.stringify(query)) as any,
|
||||
});
|
||||
return JSON.parse(utf8.encode(data));
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
import { queryContract } from './queryContract';
|
||||
|
||||
export type SimulateAstroportSinglePoolSwapParams = {
|
||||
poolId: string;
|
||||
fromAsset: string;
|
||||
fromAmount: bigint;
|
||||
isCW20?: boolean | undefined;
|
||||
};
|
||||
|
||||
type Response = {
|
||||
return_amount: string;
|
||||
spread_amount: string;
|
||||
commission_amount: string;
|
||||
};
|
||||
|
||||
/**
|
||||
* Simulates the amount of assets that would be received by swapping
|
||||
* `fromAmount` amount of `fromAsset` assets via the `poolId` pool.
|
||||
* If `fromAsset` is a CW20 token, `isCW20` must be set to `true`.
|
||||
*/
|
||||
export async function simulateAstroportSinglePoolSwap(
|
||||
endpoint: string,
|
||||
{ poolId, fromAsset, fromAmount, isCW20 }: SimulateAstroportSinglePoolSwapParams
|
||||
): Promise<bigint> {
|
||||
try {
|
||||
const { return_amount } = await queryContract<Response>(endpoint, {
|
||||
address: poolId,
|
||||
query: {
|
||||
simulation: {
|
||||
offer_asset: {
|
||||
info: isCW20
|
||||
? { token: { contract_addr: fromAsset } }
|
||||
: { native_token: { denom: fromAsset } },
|
||||
amount: fromAmount.toString(),
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
return BigInt(return_amount);
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return 0n;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
import { queryContract } from './queryContract';
|
||||
|
||||
export type SimulateKujiraSinglePoolSwapParams = {
|
||||
poolId: string;
|
||||
fromAsset: string;
|
||||
fromAmount: bigint;
|
||||
};
|
||||
|
||||
type Response = {
|
||||
return_amount: string;
|
||||
spread_amount: string;
|
||||
commission_amount: string;
|
||||
};
|
||||
|
||||
/**
|
||||
* Simulates the amount of assets that would be received by swapping
|
||||
* `fromAmount` amount of `fromAsset` assets via the `poolId` pool.
|
||||
*/
|
||||
export async function simulateKujiraSinglePoolSwap(
|
||||
endpoint: string,
|
||||
{ poolId, fromAsset, fromAmount }: SimulateKujiraSinglePoolSwapParams
|
||||
): Promise<bigint> {
|
||||
try {
|
||||
const { return_amount } = await queryContract<Response>(endpoint, {
|
||||
address: poolId,
|
||||
query: {
|
||||
simulation: {
|
||||
offer_asset: {
|
||||
info: {
|
||||
native_token: {
|
||||
denom: fromAsset,
|
||||
},
|
||||
},
|
||||
amount: fromAmount.toString(),
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
return BigInt(return_amount);
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return 0n;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
import { CosmosTxV1beta1ServiceSimulateService as SimulateService } from '@sonr.io/es/protobufs';
|
||||
|
||||
import type { Prettify } from '../../typeutils/prettify';
|
||||
import { RpcClient } from '../clients/RpcClient';
|
||||
import type { ToUnsignedProtoParams, Tx } from '../models/Tx';
|
||||
|
||||
export type SimulateTxParams = Prettify<
|
||||
ToUnsignedProtoParams & {
|
||||
tx: Tx;
|
||||
}
|
||||
>;
|
||||
|
||||
/**
|
||||
* Simulates a tx for the purpose of estimating gas fees.
|
||||
*/
|
||||
export async function simulateTx(endpoint: string, { tx, ...params }: SimulateTxParams) {
|
||||
return RpcClient.query(endpoint, SimulateService, {
|
||||
txBytes: tx.toUnsignedProto(params).toBinary() as any,
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
# Sonr WebAuthn Authentication Module
|
||||
|
||||
This module provides WebAuthn helper methods for integrating passwordless authentication with the Sonr blockchain. It wraps the `@simplewebauthn/browser` library and provides convenient methods for registering and authenticating users with WebAuthn credentials.
|
||||
|
||||
## Installation
|
||||
|
||||
The auth module is part of the `@sonr.io/es` package:
|
||||
|
||||
```bash
|
||||
npm install @sonr.io/es
|
||||
# or
|
||||
pnpm add @sonr.io/es
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```typescript
|
||||
import {
|
||||
registerWebAuthn,
|
||||
loginWebAuthn,
|
||||
isWebAuthnSupported
|
||||
} from '@sonr.io/es/auth';
|
||||
```
|
||||
|
||||
## Core Functions
|
||||
|
||||
### Registration
|
||||
|
||||
#### `registerWebAuthn(apiUrl, options)`
|
||||
Performs a complete WebAuthn registration flow.
|
||||
|
||||
```typescript
|
||||
await registerWebAuthn('http://localhost:8080', {
|
||||
username: 'alice',
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Local',
|
||||
timeout: 60000 // optional, defaults to 60 seconds
|
||||
});
|
||||
```
|
||||
|
||||
#### `beginRegistration(apiUrl, options)`
|
||||
Initiates the registration process and returns credential creation options.
|
||||
|
||||
#### `finishRegistration(apiUrl, username, credential)`
|
||||
Completes the registration by sending the credential to the server for verification.
|
||||
|
||||
### Authentication
|
||||
|
||||
#### `loginWebAuthn(apiUrl, options)`
|
||||
Performs a complete WebAuthn authentication flow.
|
||||
|
||||
```typescript
|
||||
const result = await loginWebAuthn('http://localhost:8080', {
|
||||
username: 'alice',
|
||||
rpId: 'localhost',
|
||||
timeout: 30000 // optional, defaults to 30 seconds
|
||||
});
|
||||
|
||||
if (result.success) {
|
||||
console.log('Login successful');
|
||||
}
|
||||
```
|
||||
|
||||
#### `beginLogin(apiUrl, options)`
|
||||
Initiates the authentication process and returns credential request options.
|
||||
|
||||
#### `finishLogin(apiUrl, username, credential)`
|
||||
Completes the authentication by verifying the credential with the server.
|
||||
|
||||
### Utility Functions
|
||||
|
||||
#### `isWebAuthnSupported()`
|
||||
Checks if the browser supports WebAuthn.
|
||||
|
||||
```typescript
|
||||
if (isWebAuthnSupported()) {
|
||||
// WebAuthn is available
|
||||
}
|
||||
```
|
||||
|
||||
#### `isWebAuthnAvailable()`
|
||||
Checks if a platform authenticator is available (e.g., Touch ID, Face ID, Windows Hello).
|
||||
|
||||
```typescript
|
||||
const available = await isWebAuthnAvailable();
|
||||
if (available) {
|
||||
// Platform authenticator is available
|
||||
}
|
||||
```
|
||||
|
||||
#### `isConditionalMediationAvailable()`
|
||||
Checks if conditional mediation (autofill) is supported for seamless authentication.
|
||||
|
||||
```typescript
|
||||
const autofillSupported = await isConditionalMediationAvailable();
|
||||
```
|
||||
|
||||
#### `bufferToBase64url(buffer)`
|
||||
Converts an ArrayBuffer to a base64url-encoded string.
|
||||
|
||||
#### `base64urlToBuffer(base64url)`
|
||||
Converts a base64url-encoded string to an ArrayBuffer.
|
||||
|
||||
## Advanced Usage
|
||||
|
||||
### Custom Registration Flow
|
||||
|
||||
```typescript
|
||||
import {
|
||||
beginRegistration,
|
||||
finishRegistration
|
||||
} from '@sonr.io/es/auth';
|
||||
import { startRegistration } from '@simplewebauthn/browser';
|
||||
|
||||
// Step 1: Get registration options
|
||||
const options = await beginRegistration('http://localhost:8080', {
|
||||
username: 'alice',
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Local'
|
||||
});
|
||||
|
||||
// Step 2: Create credential (with custom UI feedback)
|
||||
console.log('Touch your security key...');
|
||||
const credential = await startRegistration(options);
|
||||
|
||||
// Step 3: Verify with server
|
||||
await finishRegistration('http://localhost:8080', 'alice', credential);
|
||||
```
|
||||
|
||||
### Custom Authentication Flow
|
||||
|
||||
```typescript
|
||||
import {
|
||||
beginLogin,
|
||||
finishLogin
|
||||
} from '@sonr.io/es/auth';
|
||||
import { startAuthentication } from '@simplewebauthn/browser';
|
||||
|
||||
// Step 1: Get authentication options
|
||||
const options = await beginLogin('http://localhost:8080', {
|
||||
username: 'alice',
|
||||
rpId: 'localhost'
|
||||
});
|
||||
|
||||
// Step 2: Get credential from authenticator
|
||||
const credential = await startAuthentication(options);
|
||||
|
||||
// Step 3: Verify with server
|
||||
const result = await finishLogin('http://localhost:8080', 'alice', credential);
|
||||
```
|
||||
|
||||
## Server Requirements
|
||||
|
||||
The WebAuthn helpers expect a server that implements the following endpoints:
|
||||
|
||||
- `GET /begin-register?username={username}` - Returns credential creation options
|
||||
- `POST /finish-register?username={username}` - Verifies and stores the credential
|
||||
- `GET /begin-login?username={username}` - Returns credential request options
|
||||
- `POST /finish-login?username={username}` - Verifies the authentication credential
|
||||
|
||||
These endpoints are implemented in the Sonr blockchain's x/did module WebAuthn server.
|
||||
|
||||
## Browser Compatibility
|
||||
|
||||
WebAuthn is supported in modern browsers:
|
||||
- Chrome/Edge 67+
|
||||
- Firefox 60+
|
||||
- Safari 14+
|
||||
|
||||
Platform authenticator support varies by device:
|
||||
- macOS: Touch ID (MacBooks), Face ID (supported iPads)
|
||||
- Windows: Windows Hello
|
||||
- Android: Fingerprint, Face unlock
|
||||
- iOS: Touch ID, Face ID
|
||||
|
||||
## Security Considerations
|
||||
|
||||
1. Always use HTTPS in production (WebAuthn requires secure contexts)
|
||||
2. The `rpId` must match the domain where the authentication is performed
|
||||
3. Store credentials securely on the server
|
||||
4. Implement proper session management after successful authentication
|
||||
5. Consider implementing backup authentication methods
|
||||
|
||||
## Examples
|
||||
|
||||
See `examples.ts` for complete usage examples including:
|
||||
- Checking WebAuthn support
|
||||
- Simple registration and authentication
|
||||
- Advanced flows with custom handling
|
||||
- Conditional UI authentication (autofill)
|
||||
@@ -0,0 +1,206 @@
|
||||
/**
|
||||
* Example usage of Passkey authentication methods
|
||||
*
|
||||
* These examples demonstrate how to use the passkey helpers
|
||||
* with a Sonr blockchain node running locally or remotely.
|
||||
*/
|
||||
|
||||
import {
|
||||
registerWithPasskey,
|
||||
loginWithPasskey,
|
||||
isWebAuthnSupported,
|
||||
isWebAuthnAvailable,
|
||||
isConditionalMediationAvailable,
|
||||
} from './webauthn';
|
||||
|
||||
// Example 1: Check WebAuthn/Passkey availability
|
||||
export async function checkPasskeySupport() {
|
||||
const supported = isWebAuthnSupported();
|
||||
console.log('Passkey supported:', supported);
|
||||
|
||||
if (supported) {
|
||||
const available = await isWebAuthnAvailable();
|
||||
console.log('Platform authenticator available:', available);
|
||||
|
||||
const conditionalMediation = await isConditionalMediationAvailable();
|
||||
console.log('Conditional mediation available:', conditionalMediation);
|
||||
}
|
||||
}
|
||||
|
||||
// Example 2: Register a new user with passkey and email
|
||||
export async function registerUserWithEmail(username: string, email: string) {
|
||||
const apiUrl = 'http://localhost:1317'; // Your Sonr node API
|
||||
|
||||
try {
|
||||
const result = await registerWithPasskey(apiUrl, {
|
||||
username,
|
||||
email,
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
displayName: username,
|
||||
createVault: true,
|
||||
});
|
||||
|
||||
if (result.success) {
|
||||
console.log('Registration successful!');
|
||||
console.log('DID:', result.did);
|
||||
console.log('Vault ID:', result.vaultId);
|
||||
console.log('Assertion methods:', result.assertionMethods);
|
||||
} else {
|
||||
console.error('Registration failed:', result.error);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Registration error:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Example 3: Register a new user with passkey and phone number
|
||||
export async function registerUserWithPhone(username: string, phoneNumber: string) {
|
||||
const apiUrl = 'http://localhost:1317'; // Your Sonr node API
|
||||
|
||||
try {
|
||||
const result = await registerWithPasskey(apiUrl, {
|
||||
username,
|
||||
tel: phoneNumber,
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
displayName: username,
|
||||
createVault: true,
|
||||
});
|
||||
|
||||
if (result.success) {
|
||||
console.log('Registration successful!');
|
||||
console.log('DID:', result.did);
|
||||
console.log('Vault ID:', result.vaultId);
|
||||
console.log('Assertion methods:', result.assertionMethods);
|
||||
} else {
|
||||
console.error('Registration failed:', result.error);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Registration error:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Example 4: Authenticate a user with passkey
|
||||
export async function authenticateUser(username: string) {
|
||||
const apiUrl = 'http://localhost:1317'; // Your Sonr node API
|
||||
|
||||
try {
|
||||
const result = await loginWithPasskey(apiUrl, {
|
||||
username,
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
});
|
||||
|
||||
if (result.success) {
|
||||
console.log('Authentication successful!');
|
||||
console.log('DID:', result.did);
|
||||
console.log('Vault ID:', result.vaultId);
|
||||
console.log('Session token:', result.sessionToken);
|
||||
} else {
|
||||
console.error('Authentication failed:', result.error);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Authentication error:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Example 5: Registration with custom server configuration
|
||||
export async function registerWithCustomServer(
|
||||
username: string,
|
||||
email: string,
|
||||
serverUrl: string,
|
||||
rpId: string,
|
||||
rpName: string
|
||||
) {
|
||||
try {
|
||||
const result = await registerWithPasskey(serverUrl, {
|
||||
username,
|
||||
email,
|
||||
rpId,
|
||||
rpName,
|
||||
displayName: username,
|
||||
createVault: true,
|
||||
timeout: 120000, // 2 minutes
|
||||
});
|
||||
|
||||
if (result.success) {
|
||||
console.log(`User ${username} registered successfully on ${rpName}`);
|
||||
console.log('DID:', result.did);
|
||||
console.log('Vault ID:', result.vaultId);
|
||||
} else {
|
||||
console.error('Custom registration failed:', result.error);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Custom registration error:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Example 6: Conditional UI authentication (autofill)
|
||||
export async function setupConditionalAuthentication() {
|
||||
const supported = await isConditionalMediationAvailable();
|
||||
|
||||
if (supported) {
|
||||
console.log('Conditional mediation is available');
|
||||
// You can now use conditional UI for seamless authentication
|
||||
// This allows the browser to suggest available credentials
|
||||
// in form fields marked with autocomplete="username webauthn"
|
||||
} else {
|
||||
console.log('Conditional mediation not supported');
|
||||
// Fall back to traditional authentication button
|
||||
}
|
||||
}
|
||||
|
||||
// Example 7: Full registration flow with error handling
|
||||
export async function fullRegistrationFlow(
|
||||
username: string,
|
||||
email?: string,
|
||||
phoneNumber?: string
|
||||
) {
|
||||
const apiUrl = 'http://localhost:1317';
|
||||
|
||||
// Check if passkeys are supported
|
||||
if (!isWebAuthnSupported()) {
|
||||
console.error('Passkeys are not supported in this browser');
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if platform authenticator is available
|
||||
const platformAvailable = await isWebAuthnAvailable();
|
||||
if (!platformAvailable) {
|
||||
console.warn('No platform authenticator available, using cross-platform');
|
||||
}
|
||||
|
||||
try {
|
||||
const result = await registerWithPasskey(apiUrl, {
|
||||
username,
|
||||
email,
|
||||
tel: phoneNumber,
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
displayName: `${username} User`,
|
||||
createVault: true,
|
||||
});
|
||||
|
||||
if (result.success) {
|
||||
console.log('✅ Registration successful!');
|
||||
console.log('📝 DID Document:', result.did);
|
||||
console.log('🔐 Vault ID:', result.vaultId);
|
||||
console.log('🔑 Assertion Methods:', result.assertionMethods);
|
||||
console.log('🎫 UCAN Token:', result.ucanToken);
|
||||
|
||||
// Store the UCAN token for future operations
|
||||
localStorage.setItem('ucan_token', result.ucanToken || '');
|
||||
localStorage.setItem('user_did', result.did || '');
|
||||
localStorage.setItem('vault_id', result.vaultId || '');
|
||||
|
||||
return result;
|
||||
} else {
|
||||
console.error('❌ Registration failed:', result.error);
|
||||
return null;
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('❌ Unexpected error during registration:', error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
// Export passkey authentication functions
|
||||
export {
|
||||
registerWithPasskey,
|
||||
loginWithPasskey,
|
||||
// Utility functions
|
||||
bufferToBase64url,
|
||||
base64urlToBuffer,
|
||||
isWebAuthnSupported,
|
||||
isWebAuthnAvailable,
|
||||
isConditionalMediationAvailable,
|
||||
// Enhanced utilities
|
||||
checkConditionalMediationSupport,
|
||||
createRegistrationButton,
|
||||
createLoginButton,
|
||||
// Configuration and presets
|
||||
DEFAULT_WEBAUTHN_CONFIG,
|
||||
WEBAUTHN_PRESETS,
|
||||
} from './webauthn';
|
||||
|
||||
// Export types
|
||||
export type {
|
||||
PasskeyRegistrationOptions,
|
||||
PasskeyLoginOptions,
|
||||
PasskeyRegistrationResult,
|
||||
PasskeyLoginResult,
|
||||
WebAuthnConfig,
|
||||
} from './webauthn';
|
||||
@@ -0,0 +1,119 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>Sonr WebAuthn Test</title>
|
||||
<script src="https://cdn.tailwindcss.com"></script>
|
||||
</head>
|
||||
<body class="bg-gray-100 min-h-screen p-8">
|
||||
<div class="max-w-2xl mx-auto">
|
||||
<h1 class="text-3xl font-bold mb-8">Sonr WebAuthn Test Page</h1>
|
||||
|
||||
<div class="bg-white rounded-lg shadow p-6 mb-6">
|
||||
<h2 class="text-xl font-semibold mb-4">WebAuthn Support</h2>
|
||||
<div id="support-status" class="space-y-2"></div>
|
||||
</div>
|
||||
|
||||
<div class="bg-white rounded-lg shadow p-6 mb-6">
|
||||
<h2 class="text-xl font-semibold mb-4">Registration</h2>
|
||||
<input type="text" id="username" placeholder="Enter username"
|
||||
class="w-full p-2 border rounded mb-4">
|
||||
<button onclick="testRegistration()"
|
||||
class="bg-blue-500 text-white px-4 py-2 rounded hover:bg-blue-600">
|
||||
Register with WebAuthn
|
||||
</button>
|
||||
<div id="registration-result" class="mt-4"></div>
|
||||
</div>
|
||||
|
||||
<div class="bg-white rounded-lg shadow p-6">
|
||||
<h2 class="text-xl font-semibold mb-4">Authentication</h2>
|
||||
<input type="text" id="login-username" placeholder="Enter username"
|
||||
class="w-full p-2 border rounded mb-4">
|
||||
<button onclick="testAuthentication()"
|
||||
class="bg-green-500 text-white px-4 py-2 rounded hover:bg-green-600">
|
||||
Login with WebAuthn
|
||||
</button>
|
||||
<div id="authentication-result" class="mt-4"></div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script type="module">
|
||||
// This would normally import from @sonr.io/es/auth
|
||||
// For testing, you'd need to build and serve the package
|
||||
|
||||
// Mock functions for demonstration
|
||||
async function checkSupport() {
|
||||
const supportDiv = document.getElementById('support-status');
|
||||
|
||||
const isSupported = !!(window?.PublicKeyCredential);
|
||||
const isPlatformAvailable = isSupported &&
|
||||
await PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
|
||||
const isConditionalAvailable = isSupported &&
|
||||
await PublicKeyCredential.isConditionalMediationAvailable?.();
|
||||
|
||||
supportDiv.innerHTML = `
|
||||
<p>✅ WebAuthn Supported: ${isSupported}</p>
|
||||
<p>✅ Platform Authenticator: ${isPlatformAvailable}</p>
|
||||
<p>✅ Conditional Mediation: ${isConditionalAvailable || false}</p>
|
||||
`;
|
||||
}
|
||||
|
||||
window.testRegistration = async function() {
|
||||
const username = document.getElementById('username').value;
|
||||
const resultDiv = document.getElementById('registration-result');
|
||||
|
||||
if (!username) {
|
||||
resultDiv.innerHTML = '<p class="text-red-500">Please enter a username</p>';
|
||||
return;
|
||||
}
|
||||
|
||||
resultDiv.innerHTML = '<p class="text-blue-500">Initiating registration...</p>';
|
||||
|
||||
// This would call the actual registerWebAuthn function
|
||||
// from @sonr.io/es/auth
|
||||
try {
|
||||
// Simulated call
|
||||
resultDiv.innerHTML = '<p class="text-green-500">Registration would be initiated for: ' + username + '</p>';
|
||||
console.log('Would call registerWebAuthn with:', {
|
||||
apiUrl: 'http://localhost:8080',
|
||||
username,
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Local'
|
||||
});
|
||||
} catch (error) {
|
||||
resultDiv.innerHTML = '<p class="text-red-500">Registration failed: ' + error.message + '</p>';
|
||||
}
|
||||
};
|
||||
|
||||
window.testAuthentication = async function() {
|
||||
const username = document.getElementById('login-username').value;
|
||||
const resultDiv = document.getElementById('authentication-result');
|
||||
|
||||
if (!username) {
|
||||
resultDiv.innerHTML = '<p class="text-red-500">Please enter a username</p>';
|
||||
return;
|
||||
}
|
||||
|
||||
resultDiv.innerHTML = '<p class="text-blue-500">Initiating authentication...</p>';
|
||||
|
||||
// This would call the actual loginWebAuthn function
|
||||
// from @sonr.io/es/auth
|
||||
try {
|
||||
// Simulated call
|
||||
resultDiv.innerHTML = '<p class="text-green-500">Authentication would be initiated for: ' + username + '</p>';
|
||||
console.log('Would call loginWebAuthn with:', {
|
||||
apiUrl: 'http://localhost:8080',
|
||||
username,
|
||||
rpId: 'localhost'
|
||||
});
|
||||
} catch (error) {
|
||||
resultDiv.innerHTML = '<p class="text-red-500">Authentication failed: ' + error.message + '</p>';
|
||||
}
|
||||
};
|
||||
|
||||
// Check support on load
|
||||
checkSupport();
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,412 @@
|
||||
/**
|
||||
* Integration tests for WebAuthn/Passkey authentication
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
|
||||
import {
|
||||
registerWithPasskey,
|
||||
loginWithPasskey,
|
||||
isWebAuthnSupported,
|
||||
isWebAuthnAvailable,
|
||||
bufferToBase64url,
|
||||
base64urlToBuffer,
|
||||
} from './webauthn';
|
||||
|
||||
// Mock @simplewebauthn/browser for testing
|
||||
vi.mock('@simplewebauthn/browser', () => ({
|
||||
browserSupportsWebAuthn: () => true,
|
||||
platformAuthenticatorIsAvailable: () => Promise.resolve(true),
|
||||
browserSupportsWebAuthnAutofill: () => Promise.resolve(true),
|
||||
startRegistration: vi.fn(),
|
||||
startAuthentication: vi.fn(),
|
||||
bufferToBase64URLString: (buffer: ArrayBuffer) => {
|
||||
const bytes = new Uint8Array(buffer);
|
||||
let binary = '';
|
||||
for (let i = 0; i < bytes.byteLength; i++) {
|
||||
binary += String.fromCharCode(bytes[i]);
|
||||
}
|
||||
return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
|
||||
},
|
||||
base64URLStringToBuffer: (base64url: string) => {
|
||||
const base64 = base64url.replace(/-/g, '+').replace(/_/g, '/');
|
||||
const binary = atob(base64);
|
||||
const bytes = new Uint8Array(binary.length);
|
||||
for (let i = 0; i < binary.length; i++) {
|
||||
bytes[i] = binary.charCodeAt(i);
|
||||
}
|
||||
return bytes.buffer;
|
||||
},
|
||||
}));
|
||||
|
||||
// Mock fetch for API calls
|
||||
global.fetch = vi.fn();
|
||||
|
||||
describe('WebAuthn/Passkey Authentication', () => {
|
||||
const mockApiUrl = 'http://localhost:1317';
|
||||
|
||||
beforeAll(() => {
|
||||
// Setup any global mocks or test data
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
vi.clearAllMocks();
|
||||
});
|
||||
|
||||
describe('Utility Functions', () => {
|
||||
it('should check WebAuthn support', () => {
|
||||
const supported = isWebAuthnSupported();
|
||||
expect(supported).toBe(true);
|
||||
});
|
||||
|
||||
it('should check platform authenticator availability', async () => {
|
||||
const available = await isWebAuthnAvailable();
|
||||
expect(available).toBe(true);
|
||||
});
|
||||
|
||||
it('should convert buffer to base64url and back', () => {
|
||||
const testString = 'Hello, WebAuthn!';
|
||||
const encoder = new TextEncoder();
|
||||
const buffer = encoder.encode(testString).buffer;
|
||||
|
||||
const base64url = bufferToBase64url(buffer);
|
||||
expect(base64url).toBeTruthy();
|
||||
expect(base64url).not.toContain('+');
|
||||
expect(base64url).not.toContain('/');
|
||||
expect(base64url).not.toContain('=');
|
||||
|
||||
const decodedBuffer = base64urlToBuffer(base64url);
|
||||
const decoder = new TextDecoder();
|
||||
const decodedString = decoder.decode(decodedBuffer);
|
||||
expect(decodedString).toBe(testString);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Registration with Passkey', () => {
|
||||
it('should successfully register with email assertion', async () => {
|
||||
const { startRegistration } = await import('@simplewebauthn/browser');
|
||||
|
||||
// Mock RegisterStart response
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
challenge: 'test-challenge',
|
||||
rp: { id: 'localhost', name: 'Sonr Network' },
|
||||
user: { id: 'user-id', name: 'alice', displayName: 'Alice' },
|
||||
}),
|
||||
});
|
||||
|
||||
// Mock startRegistration
|
||||
(startRegistration as any).mockResolvedValueOnce({
|
||||
id: 'credential-id',
|
||||
rawId: 'credential-raw-id',
|
||||
response: {
|
||||
publicKey: 'mock-public-key',
|
||||
attestationObject: 'mock-attestation',
|
||||
clientDataJSON: 'mock-client-data',
|
||||
},
|
||||
authenticatorAttachment: 'platform',
|
||||
type: 'public-key',
|
||||
});
|
||||
|
||||
// Mock registration submission response
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
did: 'did:email:abc123',
|
||||
vault_id: 'vault-123',
|
||||
ucan_token: 'ucan-token-123',
|
||||
credential: { id: 'credential-id' },
|
||||
}),
|
||||
});
|
||||
|
||||
const result = await registerWithPasskey(mockApiUrl, {
|
||||
username: 'alice',
|
||||
email: 'alice@example.com',
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
displayName: 'Alice Smith',
|
||||
createVault: true,
|
||||
});
|
||||
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.did).toBe('did:email:abc123');
|
||||
expect(result.vaultId).toBe('vault-123');
|
||||
expect(result.ucanToken).toBe('ucan-token-123');
|
||||
expect(result.assertionMethods).toEqual([
|
||||
'did:sonr:alice',
|
||||
'did:email:alice@example.com',
|
||||
]);
|
||||
});
|
||||
|
||||
it('should successfully register with phone assertion', async () => {
|
||||
const { startRegistration } = await import('@simplewebauthn/browser');
|
||||
|
||||
// Mock RegisterStart response
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
challenge: 'test-challenge',
|
||||
rp: { id: 'localhost', name: 'Sonr Network' },
|
||||
user: { id: 'user-id', name: 'bob', displayName: 'Bob' },
|
||||
}),
|
||||
});
|
||||
|
||||
// Mock startRegistration
|
||||
(startRegistration as any).mockResolvedValueOnce({
|
||||
id: 'credential-id-2',
|
||||
rawId: 'credential-raw-id-2',
|
||||
response: {
|
||||
publicKey: 'mock-public-key-2',
|
||||
attestationObject: 'mock-attestation-2',
|
||||
clientDataJSON: 'mock-client-data-2',
|
||||
},
|
||||
authenticatorAttachment: 'platform',
|
||||
type: 'public-key',
|
||||
});
|
||||
|
||||
// Mock registration submission response
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
did: 'did:tel:xyz789',
|
||||
vault_id: 'vault-456',
|
||||
ucan_token: 'ucan-token-456',
|
||||
credential: { id: 'credential-id-2' },
|
||||
}),
|
||||
});
|
||||
|
||||
const result = await registerWithPasskey(mockApiUrl, {
|
||||
username: 'bob',
|
||||
tel: '+1234567890',
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
displayName: 'Bob Johnson',
|
||||
createVault: true,
|
||||
});
|
||||
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.did).toBe('did:tel:xyz789');
|
||||
expect(result.vaultId).toBe('vault-456');
|
||||
expect(result.assertionMethods).toEqual([
|
||||
'did:sonr:bob',
|
||||
'did:tel:+1234567890',
|
||||
]);
|
||||
});
|
||||
|
||||
it('should handle registration failure gracefully', async () => {
|
||||
// Mock RegisterStart failure
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: false,
|
||||
json: async () => ({ error: 'Invalid origin' }),
|
||||
});
|
||||
|
||||
const result = await registerWithPasskey(mockApiUrl, {
|
||||
username: 'charlie',
|
||||
email: 'charlie@example.com',
|
||||
rpId: 'malicious.com',
|
||||
rpName: 'Malicious Site',
|
||||
createVault: false,
|
||||
});
|
||||
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.error).toContain('Invalid origin');
|
||||
});
|
||||
|
||||
it('should handle WebAuthn ceremony cancellation', async () => {
|
||||
const { startRegistration } = await import('@simplewebauthn/browser');
|
||||
|
||||
// Mock RegisterStart success
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
challenge: 'test-challenge',
|
||||
rp: { id: 'localhost', name: 'Sonr Network' },
|
||||
user: { id: 'user-id', name: 'dave', displayName: 'Dave' },
|
||||
}),
|
||||
});
|
||||
|
||||
// Mock user cancellation
|
||||
(startRegistration as any).mockRejectedValueOnce(
|
||||
new Error('User cancelled the ceremony')
|
||||
);
|
||||
|
||||
const result = await registerWithPasskey(mockApiUrl, {
|
||||
username: 'dave',
|
||||
email: 'dave@example.com',
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
createVault: true,
|
||||
});
|
||||
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.error).toContain('User cancelled');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Login with Passkey', () => {
|
||||
it('should successfully authenticate with passkey', async () => {
|
||||
const { startAuthentication } = await import('@simplewebauthn/browser');
|
||||
|
||||
// Mock LoginStart response
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
challenge: 'login-challenge',
|
||||
rpId: 'localhost',
|
||||
allowCredentials: [
|
||||
{ id: 'credential-id', type: 'public-key' },
|
||||
],
|
||||
userVerification: 'preferred',
|
||||
}),
|
||||
});
|
||||
|
||||
// Mock startAuthentication
|
||||
(startAuthentication as any).mockResolvedValueOnce({
|
||||
id: 'credential-id',
|
||||
rawId: 'credential-raw-id',
|
||||
response: {
|
||||
authenticatorData: 'mock-auth-data',
|
||||
clientDataJSON: 'mock-client-data',
|
||||
signature: 'mock-signature',
|
||||
},
|
||||
type: 'public-key',
|
||||
});
|
||||
|
||||
// Mock login finish response
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
did: 'did:email:abc123',
|
||||
vault_id: 'vault-123',
|
||||
session_token: 'session-token-xyz',
|
||||
}),
|
||||
});
|
||||
|
||||
const result = await loginWithPasskey(mockApiUrl, {
|
||||
username: 'alice',
|
||||
rpId: 'localhost',
|
||||
});
|
||||
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.did).toBe('did:email:abc123');
|
||||
expect(result.vaultId).toBe('vault-123');
|
||||
expect(result.sessionToken).toBe('session-token-xyz');
|
||||
});
|
||||
|
||||
it('should handle authentication failure', async () => {
|
||||
// Mock LoginStart failure
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: false,
|
||||
text: async () => 'User not found',
|
||||
});
|
||||
|
||||
const result = await loginWithPasskey(mockApiUrl, {
|
||||
username: 'nonexistent',
|
||||
rpId: 'localhost',
|
||||
});
|
||||
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.error).toContain('User not found');
|
||||
});
|
||||
|
||||
it('should handle invalid credentials', async () => {
|
||||
const { startAuthentication } = await import('@simplewebauthn/browser');
|
||||
|
||||
// Mock LoginStart success
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
challenge: 'login-challenge',
|
||||
rpId: 'localhost',
|
||||
allowCredentials: [],
|
||||
}),
|
||||
});
|
||||
|
||||
// Mock authentication with wrong credential
|
||||
(startAuthentication as any).mockResolvedValueOnce({
|
||||
id: 'wrong-credential-id',
|
||||
rawId: 'wrong-credential-raw-id',
|
||||
response: {
|
||||
authenticatorData: 'mock-auth-data',
|
||||
clientDataJSON: 'mock-client-data',
|
||||
signature: 'mock-signature',
|
||||
},
|
||||
type: 'public-key',
|
||||
});
|
||||
|
||||
// Mock login finish failure
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: false,
|
||||
json: async () => ({ error: 'Invalid credential' }),
|
||||
});
|
||||
|
||||
const result = await loginWithPasskey(mockApiUrl, {
|
||||
username: 'alice',
|
||||
rpId: 'localhost',
|
||||
});
|
||||
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.error).toContain('Invalid credential');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Edge Cases and Error Handling', () => {
|
||||
it('should handle network errors', async () => {
|
||||
// Mock network error
|
||||
(global.fetch as any).mockRejectedValueOnce(
|
||||
new Error('Network request failed')
|
||||
);
|
||||
|
||||
const result = await registerWithPasskey(mockApiUrl, {
|
||||
username: 'network-test',
|
||||
email: 'test@example.com',
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
createVault: false,
|
||||
});
|
||||
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.error).toContain('Network request failed');
|
||||
});
|
||||
|
||||
it('should handle malformed API responses', async () => {
|
||||
// Mock malformed response
|
||||
(global.fetch as any).mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => { throw new Error('Invalid JSON'); },
|
||||
});
|
||||
|
||||
const result = await registerWithPasskey(mockApiUrl, {
|
||||
username: 'malformed-test',
|
||||
email: 'test@example.com',
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
createVault: false,
|
||||
});
|
||||
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.error).toBeTruthy();
|
||||
});
|
||||
|
||||
it('should handle timeout scenarios', async () => {
|
||||
// Mock timeout
|
||||
(global.fetch as any).mockImplementationOnce(() =>
|
||||
new Promise((_, reject) =>
|
||||
setTimeout(() => reject(new Error('Request timeout')), 100)
|
||||
)
|
||||
);
|
||||
|
||||
const result = await registerWithPasskey(mockApiUrl, {
|
||||
username: 'timeout-test',
|
||||
email: 'test@example.com',
|
||||
rpId: 'localhost',
|
||||
rpName: 'Sonr Network',
|
||||
timeout: 50, // Very short timeout
|
||||
createVault: false,
|
||||
});
|
||||
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.error).toContain('timeout');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,621 @@
|
||||
import {
|
||||
base64URLStringToBuffer,
|
||||
browserSupportsWebAuthn,
|
||||
browserSupportsWebAuthnAutofill,
|
||||
bufferToBase64URLString,
|
||||
platformAuthenticatorIsAvailable,
|
||||
startAuthentication,
|
||||
startRegistration,
|
||||
} from '@simplewebauthn/browser';
|
||||
import type {
|
||||
AuthenticationResponseJSON,
|
||||
PublicKeyCredentialCreationOptionsJSON,
|
||||
PublicKeyCredentialRequestOptionsJSON,
|
||||
RegistrationResponseJSON,
|
||||
} from '@simplewebauthn/types';
|
||||
|
||||
// Configuration for WebAuthn operations
|
||||
export interface WebAuthnConfig {
|
||||
// Authenticator preferences
|
||||
authenticatorSelection?: {
|
||||
authenticatorAttachment?: 'platform' | 'cross-platform';
|
||||
requireResidentKey?: boolean;
|
||||
residentKey?: 'required' | 'preferred' | 'discouraged';
|
||||
userVerification?: 'required' | 'preferred' | 'discouraged';
|
||||
};
|
||||
|
||||
// Attestation preference
|
||||
attestation?: 'none' | 'indirect' | 'direct' | 'enterprise';
|
||||
|
||||
// Algorithm preferences (in order of preference)
|
||||
algorithms?: number[];
|
||||
|
||||
// UI/UX options
|
||||
showQROption?: boolean;
|
||||
preferPlatformAuthenticator?: boolean;
|
||||
|
||||
// Callbacks
|
||||
onStart?: (options: any) => void | Promise<void>;
|
||||
onComplete?: (credential: any) => void | Promise<void>;
|
||||
onError?: (error: Error) => void | Promise<void>;
|
||||
onStatusUpdate?: (status: string, type: 'info' | 'success' | 'error' | 'warning') => void;
|
||||
}
|
||||
|
||||
// Default configuration with broad compatibility
|
||||
export const DEFAULT_WEBAUTHN_CONFIG: WebAuthnConfig = {
|
||||
authenticatorSelection: {
|
||||
// No authenticatorAttachment to allow both platform and cross-platform
|
||||
requireResidentKey: false,
|
||||
residentKey: 'preferred',
|
||||
userVerification: 'preferred', // Broad compatibility
|
||||
},
|
||||
attestation: 'none', // Simplest option for broad compatibility
|
||||
algorithms: [
|
||||
-7, // ES256 (most common)
|
||||
-257, // RS256
|
||||
-8, // EdDSA
|
||||
],
|
||||
showQROption: true,
|
||||
preferPlatformAuthenticator: false,
|
||||
};
|
||||
|
||||
// Preset configurations for common use cases
|
||||
export const WEBAUTHN_PRESETS = {
|
||||
// Maximum compatibility - works with most devices
|
||||
BROAD_COMPATIBILITY: DEFAULT_WEBAUTHN_CONFIG,
|
||||
|
||||
// Platform only - for native app feel
|
||||
PLATFORM_ONLY: {
|
||||
...DEFAULT_WEBAUTHN_CONFIG,
|
||||
authenticatorSelection: {
|
||||
authenticatorAttachment: 'platform' as const,
|
||||
requireResidentKey: true,
|
||||
residentKey: 'required' as const,
|
||||
userVerification: 'required' as const,
|
||||
},
|
||||
showQROption: false,
|
||||
preferPlatformAuthenticator: true,
|
||||
},
|
||||
|
||||
// Security key focused
|
||||
SECURITY_KEY: {
|
||||
...DEFAULT_WEBAUTHN_CONFIG,
|
||||
authenticatorSelection: {
|
||||
authenticatorAttachment: 'cross-platform' as const,
|
||||
requireResidentKey: false,
|
||||
residentKey: 'discouraged' as const,
|
||||
userVerification: 'preferred' as const,
|
||||
},
|
||||
attestation: 'direct' as const,
|
||||
showQROption: false,
|
||||
},
|
||||
|
||||
// Mobile friendly with QR codes
|
||||
MOBILE_FRIENDLY: {
|
||||
...DEFAULT_WEBAUTHN_CONFIG,
|
||||
authenticatorSelection: {
|
||||
requireResidentKey: false,
|
||||
residentKey: 'preferred' as const,
|
||||
userVerification: 'preferred' as const,
|
||||
},
|
||||
showQROption: true,
|
||||
preferPlatformAuthenticator: false,
|
||||
},
|
||||
|
||||
// High security (enterprise)
|
||||
HIGH_SECURITY: {
|
||||
...DEFAULT_WEBAUTHN_CONFIG,
|
||||
authenticatorSelection: {
|
||||
requireResidentKey: true,
|
||||
residentKey: 'required' as const,
|
||||
userVerification: 'required' as const,
|
||||
},
|
||||
attestation: 'direct' as const,
|
||||
},
|
||||
};
|
||||
|
||||
// Types for passkey registration and login
|
||||
export interface PasskeyRegistrationOptions {
|
||||
username: string;
|
||||
rpId?: string;
|
||||
rpName?: string;
|
||||
email?: string;
|
||||
tel?: string;
|
||||
displayName?: string;
|
||||
createVault?: boolean;
|
||||
timeout?: number;
|
||||
config?: WebAuthnConfig;
|
||||
}
|
||||
|
||||
export interface PasskeyLoginOptions {
|
||||
username: string;
|
||||
rpId?: string;
|
||||
rpName?: string;
|
||||
timeout?: number;
|
||||
config?: WebAuthnConfig;
|
||||
}
|
||||
|
||||
export interface PasskeyRegistrationResult {
|
||||
success: boolean;
|
||||
did?: string;
|
||||
vaultId?: string;
|
||||
assertionMethods?: string[];
|
||||
ucanToken?: string;
|
||||
credential?: any;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
export interface PasskeyLoginResult {
|
||||
success: boolean;
|
||||
did?: string;
|
||||
vaultId?: string;
|
||||
sessionToken?: string;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
// Utility exports
|
||||
export const bufferToBase64url = bufferToBase64URLString;
|
||||
export const base64urlToBuffer = base64URLStringToBuffer;
|
||||
export const isWebAuthnSupported = browserSupportsWebAuthn;
|
||||
export const isWebAuthnAvailable = platformAuthenticatorIsAvailable;
|
||||
export const isConditionalMediationAvailable = browserSupportsWebAuthnAutofill;
|
||||
|
||||
/**
|
||||
* Register with a passkey (WebAuthn)
|
||||
* Supports email/tel assertion methods for Sonr blockchain
|
||||
*/
|
||||
export async function registerWithPasskey(
|
||||
apiUrl: string,
|
||||
options: PasskeyRegistrationOptions
|
||||
): Promise<PasskeyRegistrationResult> {
|
||||
const config = { ...DEFAULT_WEBAUTHN_CONFIG, ...options.config };
|
||||
|
||||
try {
|
||||
// Check WebAuthn support
|
||||
if (!browserSupportsWebAuthn()) {
|
||||
throw new Error('WebAuthn is not supported in this browser');
|
||||
}
|
||||
|
||||
// Check platform authenticator if preferred
|
||||
if (config.preferPlatformAuthenticator) {
|
||||
const hasPlatform = await platformAuthenticatorIsAvailable();
|
||||
if (!hasPlatform) {
|
||||
config.onStatusUpdate?.('Platform authenticator not available, using cross-platform options', 'warning');
|
||||
}
|
||||
}
|
||||
|
||||
config.onStatusUpdate?.('Preparing registration...', 'info');
|
||||
|
||||
// If using custom config, build options directly
|
||||
if (options.config) {
|
||||
const registrationOptions: PublicKeyCredentialCreationOptionsJSON = {
|
||||
challenge: generateChallenge(),
|
||||
rp: {
|
||||
id: options.rpId || window.location.hostname,
|
||||
name: options.rpName || 'Sonr Identity',
|
||||
},
|
||||
user: {
|
||||
id: btoa(options.username),
|
||||
name: options.username,
|
||||
displayName: options.displayName || options.username,
|
||||
},
|
||||
pubKeyCredParams: (config.algorithms || DEFAULT_WEBAUTHN_CONFIG.algorithms!).map(alg => ({
|
||||
type: 'public-key' as const,
|
||||
alg,
|
||||
})),
|
||||
authenticatorSelection: config.authenticatorSelection,
|
||||
timeout: options.timeout || 60000,
|
||||
attestation: config.attestation as AttestationConveyancePreference,
|
||||
};
|
||||
|
||||
// Call start callback
|
||||
await config.onStart?.(registrationOptions);
|
||||
|
||||
config.onStatusUpdate?.('Please interact with your authenticator...', 'info');
|
||||
|
||||
// Create credential with WebAuthn
|
||||
const credential = await startRegistration(registrationOptions);
|
||||
|
||||
// Call complete callback
|
||||
await config.onComplete?.(credential);
|
||||
|
||||
config.onStatusUpdate?.('Registration successful!', 'success');
|
||||
|
||||
// For custom config, return simplified result
|
||||
return {
|
||||
success: true,
|
||||
credential,
|
||||
did: `did:sonr:${options.username}`, // Placeholder
|
||||
};
|
||||
}
|
||||
|
||||
// Original flow for Sonr blockchain integration
|
||||
const registrationOptions = await beginRegistrationPasskey(apiUrl, options);
|
||||
await config.onStart?.(registrationOptions);
|
||||
|
||||
config.onStatusUpdate?.('Please interact with your authenticator...', 'info');
|
||||
const credential = await startRegistration(registrationOptions);
|
||||
await config.onComplete?.(credential);
|
||||
|
||||
const result = await finishRegistrationPasskey(
|
||||
apiUrl,
|
||||
options,
|
||||
credential,
|
||||
registrationOptions.challenge
|
||||
);
|
||||
|
||||
config.onStatusUpdate?.('Registration successful!', 'success');
|
||||
return result;
|
||||
} catch (error) {
|
||||
const err = error as Error;
|
||||
await config.onError?.(err);
|
||||
config.onStatusUpdate?.(`Registration failed: ${err.message}`, 'error');
|
||||
|
||||
console.error('Passkey registration failed:', error);
|
||||
return {
|
||||
success: false,
|
||||
error: err.message,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Login with a passkey (WebAuthn)
|
||||
*/
|
||||
export async function loginWithPasskey(
|
||||
apiUrl: string,
|
||||
options: PasskeyLoginOptions
|
||||
): Promise<PasskeyLoginResult> {
|
||||
const config = { ...DEFAULT_WEBAUTHN_CONFIG, ...options.config };
|
||||
|
||||
try {
|
||||
// Check WebAuthn support
|
||||
if (!browserSupportsWebAuthn()) {
|
||||
throw new Error('WebAuthn is not supported in this browser');
|
||||
}
|
||||
|
||||
config.onStatusUpdate?.('Preparing authentication...', 'info');
|
||||
|
||||
// If using custom config, build options directly
|
||||
if (options.config) {
|
||||
const authOptions: PublicKeyCredentialRequestOptionsJSON = {
|
||||
challenge: generateChallenge(),
|
||||
rpId: options.rpId || window.location.hostname,
|
||||
timeout: options.timeout || 60000,
|
||||
userVerification: config.authenticatorSelection?.userVerification || 'preferred',
|
||||
};
|
||||
|
||||
// Call start callback
|
||||
await config.onStart?.(authOptions);
|
||||
|
||||
config.onStatusUpdate?.('Please authenticate with your passkey...', 'info');
|
||||
|
||||
// Authenticate with WebAuthn
|
||||
const credential = await startAuthentication(authOptions);
|
||||
|
||||
// Call complete callback
|
||||
await config.onComplete?.(credential);
|
||||
|
||||
config.onStatusUpdate?.('Authentication successful!', 'success');
|
||||
|
||||
// For custom config, return simplified result
|
||||
return {
|
||||
success: true,
|
||||
did: `did:sonr:${options.username}`, // Placeholder
|
||||
sessionToken: credential.id,
|
||||
};
|
||||
}
|
||||
|
||||
// Original flow for Sonr blockchain integration
|
||||
const loginOptions = await beginLoginPasskey(apiUrl, options);
|
||||
await config.onStart?.(loginOptions);
|
||||
|
||||
config.onStatusUpdate?.('Please authenticate with your passkey...', 'info');
|
||||
const credential = await startAuthentication(loginOptions);
|
||||
await config.onComplete?.(credential);
|
||||
|
||||
const result = await finishLoginPasskey(
|
||||
apiUrl,
|
||||
options.username,
|
||||
credential,
|
||||
loginOptions.challenge
|
||||
);
|
||||
|
||||
config.onStatusUpdate?.('Authentication successful!', 'success');
|
||||
return result;
|
||||
} catch (error) {
|
||||
const err = error as Error;
|
||||
await config.onError?.(err);
|
||||
config.onStatusUpdate?.(`Authentication failed: ${err.message}`, 'error');
|
||||
|
||||
console.error('Passkey authentication failed:', error);
|
||||
return {
|
||||
success: false,
|
||||
error: err.message,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random challenge (for demo purposes)
|
||||
* In production, this should come from the server
|
||||
*/
|
||||
function generateChallenge(): string {
|
||||
const array = new Uint8Array(32);
|
||||
crypto.getRandomValues(array);
|
||||
return btoa(String.fromCharCode(...array))
|
||||
.replace(/\+/g, '-')
|
||||
.replace(/\//g, '_')
|
||||
.replace(/=/g, '');
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility to create a button with WebAuthn registration
|
||||
*/
|
||||
export function createRegistrationButton(
|
||||
buttonElement: HTMLButtonElement,
|
||||
apiUrl: string,
|
||||
options: PasskeyRegistrationOptions
|
||||
): void {
|
||||
buttonElement.addEventListener('click', async () => {
|
||||
buttonElement.disabled = true;
|
||||
const originalText = buttonElement.textContent;
|
||||
|
||||
// Default status update if not provided
|
||||
const config = options.config || {};
|
||||
if (!config.onStatusUpdate) {
|
||||
config.onStatusUpdate = (status, type) => {
|
||||
buttonElement.textContent = status;
|
||||
buttonElement.className = `webauthn-button webauthn-${type}`;
|
||||
};
|
||||
}
|
||||
|
||||
const result = await registerWithPasskey(apiUrl, { ...options, config });
|
||||
|
||||
if (result.success) {
|
||||
buttonElement.textContent = '✓ Registered';
|
||||
} else {
|
||||
buttonElement.textContent = originalText;
|
||||
buttonElement.disabled = false;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility to create a button with WebAuthn login
|
||||
*/
|
||||
export function createLoginButton(
|
||||
buttonElement: HTMLButtonElement,
|
||||
apiUrl: string,
|
||||
options: PasskeyLoginOptions
|
||||
): void {
|
||||
buttonElement.addEventListener('click', async () => {
|
||||
buttonElement.disabled = true;
|
||||
const originalText = buttonElement.textContent;
|
||||
|
||||
// Default status update if not provided
|
||||
const config = options.config || {};
|
||||
if (!config.onStatusUpdate) {
|
||||
config.onStatusUpdate = (status, type) => {
|
||||
buttonElement.textContent = status;
|
||||
buttonElement.className = `webauthn-button webauthn-${type}`;
|
||||
};
|
||||
}
|
||||
|
||||
const result = await loginWithPasskey(apiUrl, { ...options, config });
|
||||
|
||||
if (result.success) {
|
||||
buttonElement.textContent = '✓ Logged In';
|
||||
} else {
|
||||
buttonElement.textContent = originalText;
|
||||
buttonElement.disabled = false;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if conditional mediation (autofill) is available
|
||||
*/
|
||||
export async function checkConditionalMediationSupport(): Promise<{
|
||||
supported: boolean;
|
||||
available: boolean;
|
||||
platformAuthenticator: boolean;
|
||||
}> {
|
||||
const supported = browserSupportsWebAuthn();
|
||||
const available = supported && await browserSupportsWebAuthnAutofill();
|
||||
const platformAuthenticator = supported && await platformAuthenticatorIsAvailable();
|
||||
|
||||
return {
|
||||
supported,
|
||||
available,
|
||||
platformAuthenticator,
|
||||
};
|
||||
}
|
||||
|
||||
// Internal helper functions
|
||||
|
||||
async function beginRegistrationPasskey(
|
||||
apiUrl: string,
|
||||
options: PasskeyRegistrationOptions
|
||||
): Promise<PublicKeyCredentialCreationOptionsJSON> {
|
||||
// Determine assertion type and value
|
||||
const assertionValue = options.email || options.tel || options.username;
|
||||
const assertionType = options.email ? 'email' : options.tel ? 'tel' : 'username';
|
||||
const serviceOrigin = typeof window !== 'undefined' ? window.location.origin : options.rpId;
|
||||
|
||||
// Call Sonr's RegisterStart query
|
||||
const response = await fetch(`${apiUrl}/did/v1/register/start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
assertion_value: assertionValue,
|
||||
assertion_type: assertionType,
|
||||
service_origin: serviceOrigin,
|
||||
}),
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
const error = await response
|
||||
.json()
|
||||
.catch(() => ({ error: 'Failed to get registration options' }));
|
||||
throw new Error(error.error || 'Failed to get registration options');
|
||||
}
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
// Generate a challenge if not provided
|
||||
const challenge = data.challenge || generateChallenge();
|
||||
|
||||
// Create WebAuthn options
|
||||
const publicKeyOptions: PublicKeyCredentialCreationOptionsJSON = {
|
||||
challenge,
|
||||
rp: {
|
||||
id: data.rp?.id || options.rpId,
|
||||
name: data.rp?.name || options.rpName,
|
||||
},
|
||||
user: {
|
||||
id: data.user?.id || generateUserId(),
|
||||
name: options.username,
|
||||
displayName: options.displayName || options.username,
|
||||
},
|
||||
pubKeyCredParams: data.pubKeyCredParams || [
|
||||
{ alg: -7, type: 'public-key' }, // ES256
|
||||
{ alg: -257, type: 'public-key' }, // RS256
|
||||
],
|
||||
timeout: data.timeout || options.timeout || 60000,
|
||||
attestation: data.attestation || 'direct',
|
||||
authenticatorSelection: data.authenticatorSelection || {
|
||||
authenticatorAttachment: 'platform',
|
||||
requireResidentKey: false,
|
||||
userVerification: 'preferred',
|
||||
},
|
||||
};
|
||||
|
||||
return publicKeyOptions;
|
||||
}
|
||||
|
||||
async function finishRegistrationPasskey(
|
||||
apiUrl: string,
|
||||
options: PasskeyRegistrationOptions,
|
||||
credential: RegistrationResponseJSON,
|
||||
challenge: string
|
||||
): Promise<PasskeyRegistrationResult> {
|
||||
const assertionValue = options.email || options.tel || options.username;
|
||||
const assertionType = options.email ? 'email' : options.tel ? 'tel' : 'username';
|
||||
|
||||
const response = await fetch(`${apiUrl}/did/v1/tx/register-webauthn-credential`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
username: options.username,
|
||||
assertion_value: assertionValue,
|
||||
assertion_type: assertionType,
|
||||
webauthn_credential: {
|
||||
credential_id: credential.id,
|
||||
public_key: credential.response.publicKey,
|
||||
attestation_object: credential.response.attestationObject,
|
||||
client_data_json: credential.response.clientDataJSON,
|
||||
authenticator_attachment: credential.authenticatorAttachment,
|
||||
},
|
||||
create_vault: options.createVault ?? true,
|
||||
challenge,
|
||||
}),
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
const error = await response
|
||||
.json()
|
||||
.catch(() => ({ error: 'Registration submission failed' }));
|
||||
throw new Error(error.error || 'Registration submission failed');
|
||||
}
|
||||
|
||||
const result = await response.json();
|
||||
return {
|
||||
success: true,
|
||||
did: result.did,
|
||||
vaultId: result.vault_id,
|
||||
assertionMethods: [
|
||||
`did:sonr:${options.username}`,
|
||||
`did:${assertionType}:${assertionValue}`,
|
||||
],
|
||||
ucanToken: result.ucan_token,
|
||||
credential: result.credential,
|
||||
};
|
||||
}
|
||||
|
||||
async function beginLoginPasskey(
|
||||
apiUrl: string,
|
||||
options: PasskeyLoginOptions
|
||||
): Promise<PublicKeyCredentialRequestOptionsJSON> {
|
||||
const url = new URL(`${apiUrl}/did/v1/login/start`);
|
||||
|
||||
const response = await fetch(url.toString(), {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ username: options.username }),
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
const error = await response.text();
|
||||
throw new Error('Failed to get authentication options: ' + error);
|
||||
}
|
||||
|
||||
const loginOptions = await response.json();
|
||||
|
||||
const publicKeyOptions: PublicKeyCredentialRequestOptionsJSON = {
|
||||
challenge: loginOptions.challenge,
|
||||
rpId: loginOptions.rpId || options.rpId,
|
||||
allowCredentials: loginOptions.allowCredentials,
|
||||
userVerification: loginOptions.userVerification || 'preferred',
|
||||
timeout: loginOptions.timeout || options.timeout || 30000,
|
||||
};
|
||||
|
||||
return publicKeyOptions;
|
||||
}
|
||||
|
||||
async function finishLoginPasskey(
|
||||
apiUrl: string,
|
||||
username: string,
|
||||
credential: AuthenticationResponseJSON,
|
||||
challenge: string
|
||||
): Promise<PasskeyLoginResult> {
|
||||
const response = await fetch(`${apiUrl}/did/v1/login/finish`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
username,
|
||||
credential,
|
||||
challenge,
|
||||
}),
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
const error = await response
|
||||
.json()
|
||||
.catch(() => ({ error: 'Authentication verification failed' }));
|
||||
throw new Error(error.error || 'Authentication verification failed');
|
||||
}
|
||||
|
||||
const result = await response.json();
|
||||
return {
|
||||
success: true,
|
||||
did: result.did,
|
||||
vaultId: result.vault_id,
|
||||
sessionToken: result.session_token,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
// Helper function to generate a random user ID
|
||||
function generateUserId(): string {
|
||||
const array = new Uint8Array(16);
|
||||
if (typeof window !== 'undefined' && window.crypto) {
|
||||
window.crypto.getRandomValues(array);
|
||||
} else {
|
||||
// Fallback for Node.js environment
|
||||
for (let i = 0; i < array.length; i++) {
|
||||
array[i] = Math.floor(Math.random() * 256);
|
||||
}
|
||||
}
|
||||
return bufferToBase64URLString(array.buffer);
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
import type { JsonValue } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* A simple and minimal wrapper around the native `fetch` API.
|
||||
*/
|
||||
export class FetchClient {
|
||||
/**
|
||||
* Performs a GET request to the given `endpoint`, and returns the
|
||||
* JSON response.
|
||||
*/
|
||||
public static async get<T>(
|
||||
endpoint: string,
|
||||
searchParams?: Record<string, string> | undefined
|
||||
): Promise<T> {
|
||||
const url = new URL(endpoint);
|
||||
url.search = new URLSearchParams(searchParams).toString();
|
||||
const res = await fetch(url, { method: 'GET' });
|
||||
return res.json();
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs a POST request to the given `endpoint`, and returns the
|
||||
* JSON response.
|
||||
*/
|
||||
public static async post<T>(endpoint: string, body: JsonValue): Promise<T> {
|
||||
const res = await fetch(endpoint, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify(body),
|
||||
});
|
||||
return res.json();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,199 @@
|
||||
import type { JsonValue, Message, PartialMessage } from '@bufbuild/protobuf';
|
||||
import { base16, base64 } from '@sonr.io/es/codec';
|
||||
import type { CosmosTxV1beta1TxRaw as TxRaw } from '@sonr.io/es/protobufs';
|
||||
|
||||
import { FetchClient } from './FetchClient';
|
||||
|
||||
type ErrorResponse = {
|
||||
id: number;
|
||||
jsonrpc: string;
|
||||
error: {
|
||||
code: number;
|
||||
message: string;
|
||||
data: string;
|
||||
};
|
||||
result: never;
|
||||
};
|
||||
type SuccessResponse<T> = {
|
||||
id: number;
|
||||
jsonrpc: string;
|
||||
result: T;
|
||||
error: never;
|
||||
};
|
||||
type Response<T> = SuccessResponse<T> | ErrorResponse;
|
||||
|
||||
type QueryResult = {
|
||||
response: {
|
||||
code: number;
|
||||
log: string;
|
||||
info: string;
|
||||
index: string;
|
||||
key: string | null;
|
||||
value: string | null;
|
||||
proofOps: string[] | null;
|
||||
height: string;
|
||||
codespace: string;
|
||||
};
|
||||
};
|
||||
type QueryService<T extends Message<T>, U extends Message<U>> = {
|
||||
typeName: string;
|
||||
method: string;
|
||||
Request: new (msg: PartialMessage<T>) => T;
|
||||
Response: { fromBinary: (bytes: Uint8Array) => U };
|
||||
};
|
||||
|
||||
type BroadcastTxResult = {
|
||||
code: number;
|
||||
codespace: string;
|
||||
data: string;
|
||||
hash: string;
|
||||
log: string;
|
||||
};
|
||||
|
||||
/**
|
||||
* Wraps the request message with an optional `height` field.
|
||||
*/
|
||||
type RequestMessage<T extends Message<T>> = T extends {
|
||||
height: bigint | string | number;
|
||||
}
|
||||
? PartialMessage<T>
|
||||
: PartialMessage<T> & {
|
||||
/**
|
||||
* The block height at which the query should be executed. Providing a height
|
||||
* that is outside the range of the full node will result in an error. Leave
|
||||
* this field empty to default to the latest block.
|
||||
*/
|
||||
height?: number | undefined;
|
||||
};
|
||||
|
||||
export class RpcClient {
|
||||
private static async doRequest<T>(endpoint: string, method: string, params: JsonValue) {
|
||||
const { result, error } = await FetchClient.post<Response<T>>(endpoint, {
|
||||
id: Date.now(),
|
||||
jsonrpc: '2.0',
|
||||
method,
|
||||
params,
|
||||
});
|
||||
if (error != null) {
|
||||
throw new Error(error.data);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Posts an ABCI query to the RPC `endpoint`. If successful, returns the response,
|
||||
* otherwise throws an error.
|
||||
*/
|
||||
public static async query<T extends Message<T>, U extends Message<U>>(
|
||||
endpoint: string,
|
||||
{ typeName, method, Request, Response }: QueryService<T, U>,
|
||||
requestMsg: RequestMessage<T>
|
||||
): Promise<U> {
|
||||
const { response } = await RpcClient.doRequest<QueryResult>(endpoint, 'abci_query', {
|
||||
path: `/${typeName}/${method}`,
|
||||
data: base16.encode(new Request(requestMsg).toBinary()),
|
||||
...(requestMsg.height ? { height: requestMsg.height.toString() } : {}),
|
||||
});
|
||||
const { log, value } = response;
|
||||
if (!value) {
|
||||
throw new Error(log);
|
||||
}
|
||||
return Response.fromBinary(base64.decode(value));
|
||||
}
|
||||
|
||||
/**
|
||||
* Posts a `broadcast_tx_sync` request to the RPC `endpoint`. If successful,
|
||||
* returns the tx hash, otherwise throws an error.
|
||||
*/
|
||||
public static async broadcastTx(endpoint: string, txRaw: TxRaw): Promise<string> {
|
||||
const { code, log, hash } = await RpcClient.doRequest<BroadcastTxResult>(
|
||||
endpoint,
|
||||
'broadcast_tx_sync',
|
||||
{
|
||||
tx: base64.encode(txRaw.toBinary()),
|
||||
}
|
||||
);
|
||||
if (code !== 0) {
|
||||
throw new Error(log);
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new ABCI batch query.
|
||||
*/
|
||||
public static newBatchQuery(endpoint: string): BatchQuery {
|
||||
return new BatchQuery(endpoint);
|
||||
}
|
||||
}
|
||||
|
||||
class BatchQuery {
|
||||
private readonly endpoint: string;
|
||||
private readonly queries: {
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
queryService: QueryService<any, any>;
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
requestMsg: RequestMessage<any>;
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
callback: (err: Error | null, response: any) => unknown;
|
||||
}[] = [];
|
||||
|
||||
constructor(endpoint: string) {
|
||||
this.endpoint = endpoint;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds an `abci_query` to this query batch.
|
||||
*
|
||||
* @param callback An error-first callback function for the response of the query.
|
||||
* If `err` is not `null`, `response` will be `null` and should not be used.
|
||||
*/
|
||||
public add<T extends Message<T>, U extends Message<U>>(
|
||||
queryService: QueryService<T, U>,
|
||||
requestMsg: RequestMessage<T>,
|
||||
callback: (err: Error | null, response: U) => unknown
|
||||
) {
|
||||
this.queries.push({ queryService, requestMsg, callback });
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the batched query.
|
||||
*/
|
||||
public async send() {
|
||||
if (this.queries.length === 0) {
|
||||
return;
|
||||
}
|
||||
const payload = this.queries.map(({ queryService, requestMsg }, idx) => ({
|
||||
id: idx,
|
||||
jsonrpc: '2.0',
|
||||
method: 'abci_query',
|
||||
params: {
|
||||
path: `/${queryService.typeName}/${queryService.method}`,
|
||||
data: base16.encode(new queryService.Request(requestMsg).toBinary()),
|
||||
...(requestMsg.height ? { height: requestMsg.height.toString() } : {}),
|
||||
},
|
||||
}));
|
||||
const res = await FetchClient.post<
|
||||
// Array is returned if and only if the payload has more than one query
|
||||
Response<QueryResult>[] | Response<QueryResult>
|
||||
>(this.endpoint, payload);
|
||||
const results = Array.isArray(res) ? res : [res];
|
||||
for (const { id, result, error } of results) {
|
||||
const query = this.queries[id];
|
||||
if (!query) continue;
|
||||
const { queryService, callback: handler } = query;
|
||||
if (error != null) {
|
||||
handler(new Error(error.data), null);
|
||||
continue;
|
||||
}
|
||||
const { log, value } = result.response;
|
||||
if (!value) {
|
||||
handler(new Error(log), null);
|
||||
continue;
|
||||
}
|
||||
const responseMsg = queryService.Response.fromBinary(base64.decode(value));
|
||||
handler(null, responseMsg);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
export { type BroadcastTxParams, broadcastTx } from './apis/broadcastTx';
|
||||
export { type GetAccountParams, getAccount } from './apis/getAccount';
|
||||
// Commented out - CosmWasm files have been removed
|
||||
// export {
|
||||
// type GetCw20BalanceParams,
|
||||
// getCw20Balance,
|
||||
// } from "./apis/getCw20Balance";
|
||||
export {
|
||||
type GetNativeBalancesParams,
|
||||
getNativeBalances,
|
||||
} from './apis/getNativeBalances';
|
||||
export { type GetTxParams, getTx } from './apis/getTx';
|
||||
export { type PollTxParams, pollTx } from './apis/pollTx';
|
||||
// Commented out - CosmWasm files have been removed
|
||||
// export { type QueryContractParams, queryContract } from "./apis/queryContract";
|
||||
// Commented out - CosmWasm files have been removed
|
||||
// export {
|
||||
// type SimulateAstroportSinglePoolSwapParams,
|
||||
// simulateAstroportSinglePoolSwap,
|
||||
// } from "./apis/simulateAstroportSinglePoolSwap";
|
||||
// export {
|
||||
// type SimulateKujiraSinglePoolSwapParams,
|
||||
// simulateKujiraSinglePoolSwap,
|
||||
// } from "./apis/simulateKujiraSinglePoolSwap";
|
||||
export { type SimulateTxParams, simulateTx } from './apis/simulateTx';
|
||||
export { RpcClient } from './clients/RpcClient';
|
||||
export type { Adapter } from './models/Adapter';
|
||||
export { MsgBeginRedelegate } from './models/MsgBeginRedelegate';
|
||||
export { MsgDelegate } from './models/MsgDelegate';
|
||||
export { MsgIbcTransfer } from './models/MsgIbcTransfer';
|
||||
export { MsgSend } from './models/MsgSend';
|
||||
export { MsgStoreCode } from './models/MsgStoreCode';
|
||||
export { MsgUndelegate } from './models/MsgUndelegate';
|
||||
export { MsgWithdrawDelegatorRewards } from './models/MsgWithdrawDelegatorRewards';
|
||||
export { MsgWithdrawValidatorCommission } from './models/MsgWithdrawValidatorCommission';
|
||||
|
||||
export { Secp256k1PubKey } from './models/Secp256k1PubKey';
|
||||
export {
|
||||
type ToSignDocParams,
|
||||
type ToSignedProtoParams,
|
||||
type ToStdSignDocParams,
|
||||
type ToUnsignedProtoParams,
|
||||
Tx,
|
||||
} from './models/Tx';
|
||||
export { calculateFee } from './utils/calculateFee';
|
||||
export { toAny } from './utils/toAny';
|
||||
export { toBaseAccount } from './utils/toBaseAccount';
|
||||
|
||||
// Export passkey authentication functions
|
||||
export {
|
||||
registerWithPasskey,
|
||||
loginWithPasskey,
|
||||
// Utility functions
|
||||
bufferToBase64url,
|
||||
base64urlToBuffer,
|
||||
isWebAuthnSupported,
|
||||
isWebAuthnAvailable,
|
||||
isConditionalMediationAvailable,
|
||||
} from './auth';
|
||||
|
||||
// Export passkey types
|
||||
export type {
|
||||
PasskeyRegistrationOptions,
|
||||
PasskeyLoginOptions,
|
||||
PasskeyRegistrationResult,
|
||||
PasskeyLoginResult,
|
||||
} from './auth';
|
||||
@@ -0,0 +1,12 @@
|
||||
import type { Message } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* An adapter to translate between protobuf and amino encodings.
|
||||
*/
|
||||
export type Adapter = {
|
||||
toProto: () => Message;
|
||||
toAmino: () => {
|
||||
type: string;
|
||||
value: Record<string, unknown>;
|
||||
};
|
||||
};
|
||||
@@ -0,0 +1,43 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
// TODO: CosmosStakingV1beta1MsgBeginRedelegate not available in protobufs
|
||||
// // TODO: Missing from protobufs
|
||||
// import { CosmosStakingV1beta1MsgBeginRedelegate as ProtoMsgBeginRedelegate } from "../../protobufs";
|
||||
const _ProtoMsgBeginRedelegate: any = {};
|
||||
type ProtoMsgBeginRedelegate = any;
|
||||
|
||||
import type { DeepPrettify } from '../../typeutils/prettify';
|
||||
import type { Adapter } from './Adapter';
|
||||
|
||||
type Data = DeepPrettify<PlainMessage<ProtoMsgBeginRedelegate>>;
|
||||
|
||||
export class MsgBeginRedelegate implements Adapter {
|
||||
private readonly data: Data;
|
||||
|
||||
constructor(data: Data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
// TODO: Implement toProto() method when CosmosStakingV1beta1MsgBeginRedelegate protobuf is available
|
||||
// This method should create and return a proper ProtoMsgBeginRedelegate instance with this.data
|
||||
// Currently returns empty object due to missing protobuf definition
|
||||
public toProto(): any {
|
||||
// TODO: Implement when ProtoMsgBeginRedelegate is available
|
||||
// throw new Error("MsgBeginRedelegate not implemented - missing protobuf definition");
|
||||
// return new ProtoMsgBeginRedelegate(this.data);
|
||||
return {} as any;
|
||||
}
|
||||
|
||||
// TODO: Verify toAmino() implementation against latest Cosmos SDK amino encoding standards
|
||||
// This method converts the redelegation message to amino JSON format
|
||||
public toAmino() {
|
||||
return {
|
||||
type: 'cosmos-sdk/MsgBeginRedelegate',
|
||||
value: {
|
||||
delegator_address: this.data.delegatorAddress,
|
||||
validator_src_address: this.data.validatorSrcAddress,
|
||||
validator_dst_address: this.data.validatorDstAddress,
|
||||
amount: this.data.amount,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
// TODO: CosmosStakingV1beta1MsgDelegate not available in protobufs
|
||||
// // TODO: Missing from protobufs
|
||||
// import { CosmosStakingV1beta1MsgDelegate as ProtoMsgDelegate } from "../../protobufs";
|
||||
const _ProtoMsgDelegate: any = {};
|
||||
type ProtoMsgDelegate = any;
|
||||
|
||||
import type { DeepPrettify } from '../../typeutils/prettify';
|
||||
import type { Adapter } from './Adapter';
|
||||
|
||||
type Data = DeepPrettify<PlainMessage<ProtoMsgDelegate>>;
|
||||
|
||||
export class MsgDelegate implements Adapter {
|
||||
private readonly data: Data;
|
||||
|
||||
constructor(data: Data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
// TODO: Implement toProto() method when CosmosStakingV1beta1MsgDelegate protobuf is available
|
||||
// This method should create and return a proper ProtoMsgDelegate instance with this.data
|
||||
// Required implementation:
|
||||
// 1. Import the correct protobuf type from @sonr.io/es/protobufs
|
||||
// 2. Create new ProtoMsgDelegate instance with validated data
|
||||
// 3. Set delegatorAddress, validatorAddress, and amount fields
|
||||
// 4. Validate validator address format and amount positivity
|
||||
// 5. Handle coin conversion for amount field (denom and amount)
|
||||
// Currently returns empty object due to missing protobuf definition
|
||||
public toProto(): any {
|
||||
// TODO: Implement when ProtoMsgDelegate is available
|
||||
// throw new Error("MsgDelegate not implemented - missing protobuf definition");
|
||||
// return new ProtoMsgDelegate(this.data);
|
||||
return {} as any;
|
||||
}
|
||||
|
||||
// TODO: Verify toAmino() implementation against latest Cosmos SDK amino encoding standards
|
||||
// This method converts the staking delegation message to amino JSON format
|
||||
public toAmino() {
|
||||
return {
|
||||
type: 'cosmos-sdk/MsgDelegate',
|
||||
value: {
|
||||
delegator_address: this.data.delegatorAddress,
|
||||
validator_address: this.data.validatorAddress,
|
||||
amount: this.data.amount,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
import { IbcApplicationsTransferV1MsgTransfer as ProtoMsgIbcTransfer } from '../../protobufs';
|
||||
|
||||
import type { DeepPrettify } from '../../typeutils/prettify';
|
||||
import type { Adapter } from './Adapter';
|
||||
|
||||
type Data = DeepPrettify<PlainMessage<ProtoMsgIbcTransfer>>;
|
||||
|
||||
export class MsgIbcTransfer implements Adapter {
|
||||
private readonly data: Data;
|
||||
|
||||
constructor(data: Data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
public toProto() {
|
||||
return new ProtoMsgIbcTransfer(this.data);
|
||||
}
|
||||
|
||||
public toAmino() {
|
||||
return {
|
||||
type: 'cosmos-sdk/MsgTransfer',
|
||||
value: {
|
||||
source_port: this.data.sourcePort,
|
||||
source_channel: this.data.sourceChannel,
|
||||
token: this.data.token,
|
||||
sender: this.data.sender,
|
||||
receiver: this.data.receiver,
|
||||
/**
|
||||
* Protobuf type is optional, but Amino type is non-optional.
|
||||
*
|
||||
* @see https://github.com/cosmos/cosmjs/blob/358260bff71c9d3e7ad6644fcf64dc00325cdfb9/packages/stargate/src/modules/ibc/aminomessages.ts#L16-L42
|
||||
*/
|
||||
timeout_height: this.data.timeoutHeight
|
||||
? {
|
||||
revision_number: this.data.timeoutHeight.revisionNumber.toString(),
|
||||
revision_height: this.data.timeoutHeight.revisionHeight.toString(),
|
||||
}
|
||||
: {},
|
||||
timeout_timestamp: this.data.timeoutTimestamp.toString(),
|
||||
memo: this.data.memo,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
// TODO: CosmosBankV1beta1MsgSend not available in protobufs
|
||||
// // TODO: Missing from protobufs
|
||||
// import { CosmosBankV1beta1MsgSend as ProtoMsgSend } from "@sonr.io/es/protobufs";
|
||||
const _ProtoMsgSend: any = {};
|
||||
type ProtoMsgSend = any;
|
||||
|
||||
import type { DeepPrettify } from '../../typeutils/prettify';
|
||||
import type { Adapter } from './Adapter';
|
||||
|
||||
type Data = DeepPrettify<PlainMessage<ProtoMsgSend>>;
|
||||
|
||||
export class MsgSend implements Adapter {
|
||||
private readonly data: Data;
|
||||
private readonly legacy: boolean;
|
||||
|
||||
constructor(data: Data, legacy = false) {
|
||||
this.data = data;
|
||||
this.legacy = legacy;
|
||||
}
|
||||
|
||||
// TODO: Implement toProto() method when CosmosBankV1beta1MsgSend protobuf is available
|
||||
// This method should create and return a proper ProtoMsgSend instance with this.data
|
||||
// Required implementation:
|
||||
// 1. Import the correct protobuf type from @sonr.io/es/protobufs
|
||||
// 2. Create new ProtoMsgSend instance with validated data
|
||||
// 3. Set fromAddress, toAddress, and amount fields
|
||||
// 4. Handle coin conversion for amount field (denom and amount)
|
||||
// Currently returns empty object due to missing protobuf definition
|
||||
public toProto(): any {
|
||||
// TODO: Implement when ProtoMsgSend is available
|
||||
// throw new Error("MsgSend not implemented - missing protobuf definition");
|
||||
// return new ProtoMsgSend(this.data);
|
||||
return {} as any;
|
||||
}
|
||||
|
||||
// TODO: Verify toAmino() implementation against latest Cosmos SDK amino encoding standards
|
||||
// This method converts the message to amino JSON format for legacy support
|
||||
public toAmino() {
|
||||
return {
|
||||
type: this.legacy ? 'bank/MsgSend' : 'cosmos-sdk/MsgSend',
|
||||
value: {
|
||||
from_address: this.data.fromAddress,
|
||||
to_address: this.data.toAddress,
|
||||
amount: this.data.amount,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
import { base64 } from '@sonr.io/es/codec';
|
||||
import { CosmwasmWasmV1MsgStoreCode as ProtoMsgStoreCode } from '@sonr.io/es/protobufs';
|
||||
|
||||
import type { DeepPrettify } from '../../typeutils/prettify';
|
||||
import type { Adapter } from './Adapter';
|
||||
|
||||
type Data = DeepPrettify<PlainMessage<ProtoMsgStoreCode>>;
|
||||
|
||||
export class MsgStoreCode implements Adapter {
|
||||
private readonly data: Data;
|
||||
|
||||
constructor(data: Data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
public toProto() {
|
||||
return new ProtoMsgStoreCode({
|
||||
...this.data,
|
||||
});
|
||||
}
|
||||
|
||||
public toAmino() {
|
||||
return {
|
||||
type: 'wasm/MsgStoreCode',
|
||||
value: {
|
||||
sender: this.data.sender,
|
||||
wasm_byte_code: base64.encode(this.data.wasmByteCode),
|
||||
instantiate_permission: this.data.instantiatePermission,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
// TODO: CosmosStakingV1beta1MsgUndelegate not available in protobufs
|
||||
// // TODO: Missing from protobufs
|
||||
// import { CosmosStakingV1beta1MsgUndelegate as ProtoMsgUndelegate } from "@sonr.io/es/protobufs";
|
||||
const _ProtoMsgUndelegate: any = {};
|
||||
type ProtoMsgUndelegate = any;
|
||||
|
||||
import type { DeepPrettify } from '../../typeutils/prettify';
|
||||
import type { Adapter } from './Adapter';
|
||||
|
||||
type Data = DeepPrettify<PlainMessage<ProtoMsgUndelegate>>;
|
||||
|
||||
export class MsgUndelegate implements Adapter {
|
||||
private readonly data: Data;
|
||||
|
||||
constructor(data: Data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
// TODO: Implement toProto() method when CosmosStakingV1beta1MsgUndelegate protobuf is available
|
||||
// This method should create and return a proper ProtoMsgUndelegate instance with this.data
|
||||
// Currently returns empty object due to missing protobuf definition
|
||||
public toProto(): any {
|
||||
// TODO: Implement when ProtoMsgUndelegate is available
|
||||
// throw new Error("MsgUndelegate not implemented - missing protobuf definition");
|
||||
// return new ProtoMsgUndelegate(this.data);
|
||||
return {} as any;
|
||||
}
|
||||
|
||||
// TODO: Verify toAmino() implementation against latest Cosmos SDK amino encoding standards
|
||||
// This method converts the undelegation message to amino JSON format
|
||||
public toAmino() {
|
||||
return {
|
||||
type: 'cosmos-sdk/MsgUndelegate',
|
||||
value: {
|
||||
delegator_address: this.data.delegatorAddress,
|
||||
validator_address: this.data.validatorAddress,
|
||||
amount: this.data.amount,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
// TODO: CosmosDistributionV1beta1MsgWithdrawDelegatorReward not available in protobufs
|
||||
// import { CosmosDistributionV1beta1MsgWithdrawDelegatorReward as ProtoMsgWithdrawDelegatorRewards } from "@sonr.io/es/protobufs";
|
||||
type ProtoMsgWithdrawDelegatorRewards = any;
|
||||
|
||||
import type { DeepPrettify } from '../../typeutils/prettify';
|
||||
import type { Adapter } from './Adapter';
|
||||
|
||||
type Data = DeepPrettify<PlainMessage<ProtoMsgWithdrawDelegatorRewards>>;
|
||||
|
||||
export class MsgWithdrawDelegatorRewards implements Adapter {
|
||||
private readonly data: Data;
|
||||
private readonly isLegacy: boolean;
|
||||
|
||||
constructor(data: Data, isLegacy = false) {
|
||||
this.data = data;
|
||||
this.isLegacy = isLegacy;
|
||||
}
|
||||
|
||||
// TODO: Implement toProto() method when CosmosDistributionV1beta1MsgWithdrawDelegatorReward protobuf is available
|
||||
// This method should create and return a proper ProtoMsgWithdrawDelegatorRewards instance with this.data
|
||||
// Currently returns empty object due to missing protobuf definition
|
||||
public toProto(): any {
|
||||
// TODO: Implement when ProtoMsgWithdrawDelegatorRewards is available
|
||||
// throw new Error("MsgWithdrawDelegatorRewards not implemented - missing protobuf definition");
|
||||
// return new ProtoMsgWithdrawDelegatorRewards(this.data);
|
||||
return {} as any;
|
||||
}
|
||||
|
||||
// TODO: Verify toAmino() implementation against latest Cosmos SDK amino encoding standards
|
||||
// This method converts the withdraw delegator rewards message to amino JSON format
|
||||
public toAmino() {
|
||||
return {
|
||||
type: this.isLegacy
|
||||
? 'distribution/MsgWithdrawDelegationReward'
|
||||
: 'cosmos-sdk/MsgWithdrawDelegationReward',
|
||||
value: {
|
||||
validator_address: this.data.validatorAddress,
|
||||
delegator_address: this.data.delegatorAddress,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
// TODO: CosmosDistributionV1beta1MsgWithdrawValidatorCommission not available in protobufs
|
||||
// import { CosmosDistributionV1beta1MsgWithdrawValidatorCommission as ProtoMsgWithdrawValidatorCommission } from "@sonr.io/es/protobufs";
|
||||
type ProtoMsgWithdrawValidatorCommission = any;
|
||||
|
||||
import type { DeepPrettify } from '../../typeutils/prettify';
|
||||
import type { Adapter } from './Adapter';
|
||||
|
||||
type Data = DeepPrettify<PlainMessage<ProtoMsgWithdrawValidatorCommission>>;
|
||||
|
||||
export class MsgWithdrawValidatorCommission implements Adapter {
|
||||
private readonly data: Data;
|
||||
|
||||
constructor(data: Data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
// TODO: Implement toProto() method when CosmosDistributionV1beta1MsgWithdrawValidatorCommission protobuf is available
|
||||
// This method should create and return a proper ProtoMsgWithdrawValidatorCommission instance with this.data
|
||||
// Currently returns empty object due to missing protobuf definition
|
||||
public toProto(): any {
|
||||
// TODO: Implement when ProtoMsgWithdrawValidatorCommission is available
|
||||
// throw new Error("MsgWithdrawValidatorCommission not implemented - missing protobuf definition");
|
||||
// return new ProtoMsgWithdrawValidatorCommission(this.data);
|
||||
return {} as any;
|
||||
}
|
||||
|
||||
// TODO: Verify toAmino() implementation against latest Cosmos SDK amino encoding standards
|
||||
// This method converts the withdraw validator commission message to amino JSON format
|
||||
public toAmino() {
|
||||
return {
|
||||
type: 'cosmos-sdk/MsgWithdrawValidatorCommission',
|
||||
value: {
|
||||
validator_address: this.data.validatorAddress,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
import { base64 } from '@sonr.io/es/codec';
|
||||
import {
|
||||
EthermintCryptoV1Ethsecp256k1PubKey as ProtoEthermintSecp256k1PubKey,
|
||||
CosmosCryptoSecp256k1PubKey as ProtoSecp256k1PubKey,
|
||||
} from '@sonr.io/es/protobufs';
|
||||
|
||||
import type { DeepPrettify } from '../../typeutils/prettify';
|
||||
import type { Adapter } from './Adapter';
|
||||
|
||||
type Data = DeepPrettify<
|
||||
{
|
||||
chainId?: string | undefined;
|
||||
} & PlainMessage<ProtoSecp256k1PubKey>
|
||||
>;
|
||||
|
||||
export class Secp256k1PubKey implements Adapter {
|
||||
private readonly data: Data;
|
||||
private readonly type: string;
|
||||
|
||||
constructor(data: Data) {
|
||||
this.data = data;
|
||||
this.type = data.chainId?.split(/[-_]/, 2).at(0) ?? '';
|
||||
}
|
||||
|
||||
public toProto() {
|
||||
const isEthermintChain =
|
||||
this.type === 'dymension' || this.type === 'evmos' || this.type === 'injective';
|
||||
return isEthermintChain
|
||||
? new ProtoEthermintSecp256k1PubKey(this.data)
|
||||
: new ProtoSecp256k1PubKey(this.data);
|
||||
}
|
||||
|
||||
public toAmino() {
|
||||
const isEthermintChain =
|
||||
this.type === 'dymension' || this.type === 'evmos' || this.type === 'injective';
|
||||
|
||||
return {
|
||||
type: isEthermintChain ? 'ethermint/PubKeyEthSecp256k1' : 'tendermint/PubKeySecp256k1',
|
||||
value: {
|
||||
key: base64.encode(this.data.key),
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,208 @@
|
||||
import type { Message, PlainMessage } from '@bufbuild/protobuf';
|
||||
import { base64 } from '@scure/base';
|
||||
import {
|
||||
CosmosTxV1beta1AuthInfo as ProtoAuthInfo,
|
||||
CosmosTxV1beta1Fee as ProtoFee,
|
||||
CosmosTxV1beta1SignDoc as ProtoSignDoc,
|
||||
CosmosTxSigningV1beta1SignMode as ProtoSignMode,
|
||||
type CosmosTxV1beta1SignerInfo as ProtoSignerInfo,
|
||||
CosmosTxV1beta1TxBody as ProtoTxBody,
|
||||
CosmosTxV1beta1TxRaw as ProtoTxRaw,
|
||||
} from '@sonr.io/es/protobufs';
|
||||
import type { SignDoc, StdSignDoc } from '@sonr.io/es/registry';
|
||||
|
||||
import { toAny } from '../utils/toAny';
|
||||
import type { Adapter } from './Adapter';
|
||||
import type { Secp256k1PubKey } from './Secp256k1PubKey';
|
||||
|
||||
type Data = {
|
||||
chainId: string;
|
||||
pubKey: Secp256k1PubKey;
|
||||
msgs: Adapter[];
|
||||
};
|
||||
|
||||
export type ToSignedProtoParams = {
|
||||
sequence: bigint;
|
||||
fee: ProtoFee;
|
||||
signMode: ProtoSignMode;
|
||||
signature: Uint8Array;
|
||||
memo?: string | undefined;
|
||||
timeoutHeight?: bigint | undefined;
|
||||
extensionOptions?: Message[] | undefined;
|
||||
};
|
||||
|
||||
export type ToUnsignedProtoParams = Pick<
|
||||
ToSignedProtoParams,
|
||||
'sequence' | 'memo' | 'timeoutHeight'
|
||||
>;
|
||||
|
||||
export type ToSignDocParams = {
|
||||
accountNumber: bigint;
|
||||
sequence: bigint;
|
||||
fee: ProtoFee;
|
||||
memo?: string | undefined;
|
||||
timeoutHeight?: bigint | undefined;
|
||||
};
|
||||
|
||||
export type ToStdSignDocParams = ToSignDocParams;
|
||||
|
||||
export class Tx {
|
||||
private readonly data: Data;
|
||||
|
||||
constructor(data: Data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the signed, proto-encoded tx, ready to be broadcasted. To create an
|
||||
* unsigned tx for the purpose of simulating it, use {@link toUnsignedProto}.
|
||||
*/
|
||||
public toSignedProto({
|
||||
fee,
|
||||
sequence,
|
||||
signMode,
|
||||
signature,
|
||||
memo,
|
||||
timeoutHeight,
|
||||
extensionOptions,
|
||||
}: ToSignedProtoParams): ProtoTxRaw {
|
||||
return new ProtoTxRaw({
|
||||
authInfoBytes: new ProtoAuthInfo({
|
||||
fee: fee,
|
||||
signerInfos: [this.getSignerInfo(sequence, signMode)],
|
||||
}).toBinary() as any,
|
||||
bodyBytes: new ProtoTxBody({
|
||||
messages: this.data.msgs.map((m) => toAny(m.toProto())),
|
||||
memo: memo,
|
||||
timeoutHeight: timeoutHeight,
|
||||
extensionOptions: extensionOptions?.map(toAny),
|
||||
}).toBinary() as any,
|
||||
signatures: [signature],
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the proto-encoded tx with the sign mode set to `UNSPECIFIED`, useful
|
||||
* for simulating the tx. To create a signed tx, use {@link toSignedProto}.
|
||||
*/
|
||||
public toUnsignedProto(info: ToUnsignedProtoParams): ProtoTxRaw {
|
||||
return this.toSignedProto({
|
||||
...info,
|
||||
fee: new ProtoFee(),
|
||||
signMode: ProtoSignMode.UNSPECIFIED,
|
||||
signature: new Uint8Array(),
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Combines the given `StdSignDoc` and `signature` and returns the proto-encoded
|
||||
* tx with sign mode set to `LEGACY_AMINO_JSON`, ready to be broadcasted.
|
||||
*
|
||||
* @param signature Must be a base64 encoded string or an `Uint8Array`
|
||||
*/
|
||||
public toSignedAmino(
|
||||
{ sequence, fee, memo, timeout_height }: StdSignDoc,
|
||||
signature: string | Uint8Array
|
||||
): ProtoTxRaw {
|
||||
return this.toSignedProto({
|
||||
sequence: BigInt(sequence),
|
||||
fee: new ProtoFee({
|
||||
amount: fee.amount.slice(),
|
||||
gasLimit: BigInt(fee.gas),
|
||||
payer: fee.payer,
|
||||
granter: fee.granter,
|
||||
}),
|
||||
signMode: ProtoSignMode.LEGACY_AMINO_JSON,
|
||||
signature: typeof signature === 'string' ? base64.decode(signature) : signature,
|
||||
memo: memo,
|
||||
timeoutHeight: timeout_height ? BigInt(timeout_height) : undefined,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Combines the given `SignDoc` and `signature` and returns the proto-encoded tx,
|
||||
* ready to be broadcasted.
|
||||
*
|
||||
* @param signature Must be a base64 encoded string or an `Uint8Array`
|
||||
*/
|
||||
public toSignedDirect(
|
||||
{ bodyBytes, authInfoBytes }: SignDoc,
|
||||
signature: string | Uint8Array
|
||||
): ProtoTxRaw {
|
||||
return new ProtoTxRaw({
|
||||
authInfoBytes: authInfoBytes as any,
|
||||
bodyBytes: bodyBytes as any,
|
||||
signatures: [typeof signature === 'string' ? base64.decode(signature) : signature],
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the unsigned, proto-encoded tx ready to be signed by a wallet.
|
||||
*/
|
||||
public toSignDoc({
|
||||
accountNumber,
|
||||
sequence,
|
||||
fee,
|
||||
memo,
|
||||
timeoutHeight,
|
||||
}: ToSignDocParams): ProtoSignDoc {
|
||||
return new ProtoSignDoc({
|
||||
chainId: this.data.chainId,
|
||||
accountNumber: accountNumber,
|
||||
authInfoBytes: new ProtoAuthInfo({
|
||||
fee: fee,
|
||||
signerInfos: [this.getSignerInfo(sequence, ProtoSignMode.DIRECT)],
|
||||
}).toBinary() as any,
|
||||
bodyBytes: new ProtoTxBody({
|
||||
messages: this.data.msgs.map((m) => toAny(m.toProto())),
|
||||
memo: memo,
|
||||
timeoutHeight: timeoutHeight,
|
||||
}).toBinary() as any,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the unsigned, amino-encoded tx ready to be signed by a wallet.
|
||||
*/
|
||||
public toStdSignDoc({
|
||||
accountNumber,
|
||||
sequence,
|
||||
fee,
|
||||
memo,
|
||||
timeoutHeight,
|
||||
}: ToStdSignDocParams): StdSignDoc {
|
||||
return {
|
||||
chain_id: this.data.chainId,
|
||||
account_number: accountNumber.toString(),
|
||||
sequence: sequence.toString(),
|
||||
fee: {
|
||||
amount: fee.amount,
|
||||
gas: fee.gasLimit.toString(),
|
||||
},
|
||||
msgs: this.data.msgs.map((m) => m.toAmino()),
|
||||
memo: memo ?? '',
|
||||
timeout_height: timeoutHeight?.toString(),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the signer info. The chain ID is used to determine if the public key
|
||||
* should be encoded using Injective's custom protobuf.
|
||||
*
|
||||
* **Warning**: Injective's chain ID might change, causing potential issues here.
|
||||
*/
|
||||
private getSignerInfo(sequence: bigint, mode: ProtoSignMode): PlainMessage<ProtoSignerInfo> {
|
||||
return {
|
||||
publicKey: toAny(this.data.pubKey.toProto()),
|
||||
sequence: sequence,
|
||||
modeInfo: {
|
||||
sum: {
|
||||
case: 'single',
|
||||
value: {
|
||||
mode: mode,
|
||||
},
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
import {
|
||||
type CosmosBaseV1beta1Coin as Coin,
|
||||
CosmosTxV1beta1Fee as Fee,
|
||||
type CosmosBaseAbciV1beta1GasInfo as GasInfo,
|
||||
} from '@sonr.io/es/protobufs';
|
||||
|
||||
/**
|
||||
* Estimates the fee for a transaction. For txs which uses more gas, the
|
||||
* `multiplier` can be decreased (default: `1.4`).
|
||||
*/
|
||||
export function calculateFee({ gasUsed }: GasInfo, { amount, denom }: Coin, multiplier = 1.4): Fee {
|
||||
const gasLimit = Number(gasUsed) * multiplier;
|
||||
return new Fee({
|
||||
amount: [
|
||||
{
|
||||
amount: Math.ceil(gasLimit * Number(amount)).toFixed(0),
|
||||
denom: denom,
|
||||
},
|
||||
],
|
||||
gasLimit: BigInt(Math.floor(gasLimit)),
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
import { Any, type Message } from '@bufbuild/protobuf';
|
||||
|
||||
export function toAny(msg: Message): Any {
|
||||
return new Any({
|
||||
typeUrl: `/${msg.getType().typeName}`,
|
||||
value: msg.toBinary(),
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
import type { Any } from '@bufbuild/protobuf';
|
||||
import {
|
||||
EthermintTypesV1EthAccount as EthermintAccount,
|
||||
IbcApplicationsInterchainAccountsV1InterchainAccount as InterchainAccount,
|
||||
} from '@sonr.io/es/protobufs';
|
||||
|
||||
const ERR_UNKNOWN_ACCOUNT_TYPE = 'Unknown account type';
|
||||
const ERR_UNABLE_TO_RESOLVE_BASE_ACCOUNT = 'Unable to resolve base account';
|
||||
|
||||
// Type definition for BaseAccount - this should match the cosmos auth BaseAccount structure
|
||||
type BaseAccount = {
|
||||
address: string;
|
||||
pubKey?: any;
|
||||
accountNumber: bigint;
|
||||
sequence: bigint;
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses an `Any` protobuf message and returns the `BaseAccount`. Throws if unable
|
||||
* to parse correctly.
|
||||
*
|
||||
* NOTE: This function currently supports only the account types available in the
|
||||
* current protobufs. Missing types that should be added when protobufs are updated:
|
||||
* - cosmos.auth.v1beta1.BaseAccount
|
||||
* - cosmos.vesting.v1beta1.BaseVestingAccount
|
||||
* - cosmos.vesting.v1beta1.ContinuousVestingAccount
|
||||
* - cosmos.vesting.v1beta1.DelayedVestingAccount
|
||||
* - cosmos.vesting.v1beta1.PeriodicVestingAccount
|
||||
* - cosmos.auth.v1beta1.ModuleAccount
|
||||
* - cosmos.vesting.v1beta1.PermanentLockedAccount
|
||||
*/
|
||||
export function toBaseAccount({ typeUrl, value }: Any): BaseAccount {
|
||||
switch (typeUrl.slice(1)) {
|
||||
case EthermintAccount.typeName: {
|
||||
const { baseAccount } = EthermintAccount.fromBinary(value);
|
||||
if (!baseAccount) {
|
||||
throw new Error(ERR_UNABLE_TO_RESOLVE_BASE_ACCOUNT);
|
||||
}
|
||||
return baseAccount;
|
||||
}
|
||||
case InterchainAccount.typeName: {
|
||||
const { baseAccount } = InterchainAccount.fromBinary(value);
|
||||
if (!baseAccount) {
|
||||
throw new Error(ERR_UNABLE_TO_RESOLVE_BASE_ACCOUNT);
|
||||
}
|
||||
return baseAccount;
|
||||
}
|
||||
default: {
|
||||
throw new Error(`${ERR_UNKNOWN_ACCOUNT_TYPE}: ${typeUrl.slice(1)}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
/**
|
||||
* Synchronously waits for the given number of `milliseconds`.
|
||||
*/
|
||||
export async function wait(milliseconds: number) {
|
||||
return new Promise((resolve) => setTimeout(resolve, milliseconds));
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { resolveBech32Address, translateEthToBech32Address } from './address';
|
||||
|
||||
const PUB_KEY_1 = 'A6Y9fcWSn5Av/HLHBwthTaVE/vdyRKvsTzi5U7j9bFj5'; // random pub key
|
||||
const PUB_KEY_2 = 'Ag/a1BOl3cdwh67Z8iCbGmAu4WWmBwtuQlQMbDaN385V'; // coinhall.org val pubkey
|
||||
const PUB_KEY_3 = 'AmGjuPKUsuIAuGgJ3xH7KGWlSU9cwVnsesrwWwyYLbMg'; // random pub key
|
||||
|
||||
const ETH_ADDRESS_1 = '0xd6E80d86483C0cF463E03cC95246bDc0FeF6cfbD'; // random eth address
|
||||
|
||||
describe('resolveBech32Address', () => {
|
||||
it('should resolve stars address correctly', () => {
|
||||
const translated = resolveBech32Address(PUB_KEY_1, 'stars');
|
||||
expect(translated).toBe('stars14y420auq56p6xgt78sl8vwz3jxy77r9cuw900r');
|
||||
});
|
||||
|
||||
it('should resolve cosmos address correctly', () => {
|
||||
const translated = resolveBech32Address(PUB_KEY_1, 'cosmos');
|
||||
expect(translated).toBe('cosmos14y420auq56p6xgt78sl8vwz3jxy77r9cgjjjyj');
|
||||
});
|
||||
|
||||
it('should resolve terra address correctly', () => {
|
||||
const translated = resolveBech32Address(PUB_KEY_2, 'terra');
|
||||
expect(translated).toBe('terra1ge3vqn6cjkk2xkfwpg5ussjwxvahs2f6aytr5j');
|
||||
});
|
||||
|
||||
it('should resolve terravaloper address correctly', () => {
|
||||
const translated = resolveBech32Address(PUB_KEY_2, 'terravaloper');
|
||||
expect(translated).toBe('terravaloper1ge3vqn6cjkk2xkfwpg5ussjwxvahs2f6at87yp');
|
||||
});
|
||||
|
||||
it('should resolve ethsecp256k1 type address correctly', () => {
|
||||
const translated = resolveBech32Address(PUB_KEY_3, 'inj', 'ethsecp256k1');
|
||||
expect(translated).toBe('inj1ys3hr2a6sn3wwqsmmrk8pgrvk58e8wrn6zn44m');
|
||||
});
|
||||
});
|
||||
|
||||
describe('translateEthToBech32Address', () => {
|
||||
it('should translate eth address correctly', () => {
|
||||
const translated = translateEthToBech32Address(ETH_ADDRESS_1, 'inj');
|
||||
expect(translated).toBe('inj16m5qmpjg8sx0gclq8ny4y34acrl0dnaantdev0');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,40 @@
|
||||
import { ripemd160 } from '@noble/hashes/ripemd160';
|
||||
import { keccak_256 } from '@noble/hashes/sha3';
|
||||
import { sha256 } from '@noble/hashes/sha256';
|
||||
import { ProjectivePoint } from '@noble/secp256k1';
|
||||
import { base64, bech32 } from '@scure/base';
|
||||
|
||||
import { ethhex } from './ethhex';
|
||||
|
||||
/**
|
||||
* Returns the bech32 address from the given `publicKey` and `prefix`. If needed,
|
||||
* the `type` of the key should be appropriately set.
|
||||
*
|
||||
* @param publicKey Must be either a base64 encoded string or a `Uint8Array`.
|
||||
*/
|
||||
export function resolveBech32Address(
|
||||
publicKey: string | Uint8Array,
|
||||
prefix: string,
|
||||
type: 'secp256k1' | 'ed25519' | 'ethsecp256k1' = 'secp256k1'
|
||||
): string {
|
||||
const pubKey = typeof publicKey === 'string' ? base64.decode(publicKey) : publicKey;
|
||||
const address =
|
||||
type === 'secp256k1'
|
||||
? // For cosmos: take the ripemd160 of the sha256 of the public key
|
||||
ripemd160(sha256(pubKey))
|
||||
: type === 'ed25519'
|
||||
? // For cosmos: take the first 20 bytes of the sha256 of the public key
|
||||
sha256(pubKey).slice(0, 20)
|
||||
: // For eth: take the last 20 bytes of the keccak of the uncompressed public key without the first byte
|
||||
keccak_256(ProjectivePoint.fromHex(pubKey).toRawBytes(false).slice(1)).slice(-20);
|
||||
return bech32.encode(prefix, bech32.toWords(address));
|
||||
}
|
||||
|
||||
/**
|
||||
* Translates the given ethereum address to a bech32 address.
|
||||
* @param ethAddress Must be a valid ethereum address (eg. `0x123...DeF`).
|
||||
*/
|
||||
export function translateEthToBech32Address(ethAddress: string, prefix: string) {
|
||||
const bytes = ethhex.decode(ethAddress);
|
||||
return bech32.encode(prefix, bech32.toWords(bytes));
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
import { type BytesCoder, hex } from '@scure/base';
|
||||
|
||||
/**
|
||||
* Convenience wrapper around `hex` that deals with hex strings typically
|
||||
* seen in Ethereum, where strings start with `0x` and are lower case.
|
||||
*
|
||||
* - For `encode`, the resulting string will be lower case
|
||||
* - For `decode`, the `str` arg can either be lower or upper case
|
||||
*/
|
||||
export const ethhex = {
|
||||
encode: (bytes) => `0x${hex.encode(bytes)}`,
|
||||
decode: (str) => hex.decode(str.replace(/^0x/, '').toLowerCase()),
|
||||
} satisfies BytesCoder;
|
||||
@@ -0,0 +1,14 @@
|
||||
// Re-export @scure/base for their codecs
|
||||
export * from '@scure/base';
|
||||
|
||||
export { resolveBech32Address, translateEthToBech32Address } from './address';
|
||||
export { ethhex } from './ethhex';
|
||||
export { resolveKeyPair } from './key';
|
||||
export { serialiseSignDoc } from './serialise';
|
||||
export {
|
||||
hashEthArbitraryMessage,
|
||||
recoverPubKeyFromEthSignature,
|
||||
signAmino,
|
||||
signDirect,
|
||||
} from './sign';
|
||||
export { verifyADR36, verifyECDSA, verifyEIP191 } from './verify';
|
||||
@@ -0,0 +1,32 @@
|
||||
import { base64 } from '@scure/base';
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { resolveKeyPair } from './key';
|
||||
|
||||
// Randomly generated seed phrase
|
||||
const SEED_PHRASE_1 =
|
||||
'witness snack faint milk gesture memory exhibit oak require mountain hammer crawl innocent day library drum youth result mutual remove capable hour front connect';
|
||||
|
||||
describe('resolveKeyPair', () => {
|
||||
it('should resolve 118 coin type correctly', () => {
|
||||
const { publicKey, privateKey } = resolveKeyPair(SEED_PHRASE_1);
|
||||
expect(base64.encode(publicKey)).toBe('AijdjMWZdjiXxSj0YCNbJHgnW6EsYwNyB9Yf7Wg5PcmE');
|
||||
expect(base64.encode(privateKey)).toBe('SojKJzJhFNruMSceBq3Imw3qZ+kS4p/6+iEpxdPsNg0=');
|
||||
});
|
||||
|
||||
it('should resolve 330 coin type correctly', () => {
|
||||
const { publicKey, privateKey } = resolveKeyPair(SEED_PHRASE_1, {
|
||||
coinType: 330,
|
||||
});
|
||||
expect(base64.encode(publicKey)).toBe('A5G4nX2MIYCsnEdm40NJx7Bb1Z+oUNbEWWcVMssrgI3n');
|
||||
expect(base64.encode(privateKey)).toBe('kpvZKN+f7oWhVLLLk1pmKOazycgfECinugqQZgKRlXg=');
|
||||
});
|
||||
|
||||
it('should resolve provided index correctly', () => {
|
||||
const { publicKey, privateKey } = resolveKeyPair(SEED_PHRASE_1, {
|
||||
index: 69,
|
||||
});
|
||||
expect(base64.encode(publicKey)).toBe('ArHwuHKnyiuPDbprTpWLVl3ZuomV70yzquzzlunGXlmj');
|
||||
expect(base64.encode(privateKey)).toBe('Fdm+CxL/KnM35bjDx/wg3eZc3tZN2q83I+xcY2wSMwk=');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,27 @@
|
||||
import { HDKey } from '@scure/bip32';
|
||||
import { mnemonicToSeedSync } from '@scure/bip39';
|
||||
|
||||
/**
|
||||
* Resolves the given `mnemonic` (aka 12-24 words seed phrase) to its public and
|
||||
* private key pair. Derivation path uses the default for Cosmos chains - provide
|
||||
* the optional `opts` to override.
|
||||
*/
|
||||
export function resolveKeyPair(
|
||||
mnemonic: string,
|
||||
opts?: { coinType?: number | undefined; index?: number | undefined } | undefined
|
||||
): {
|
||||
publicKey: Uint8Array;
|
||||
privateKey: Uint8Array;
|
||||
} {
|
||||
const seed = mnemonicToSeedSync(mnemonic);
|
||||
const { publicKey, privateKey } = HDKey.fromMasterSeed(seed).derive(
|
||||
`m/44'/${opts?.coinType ?? 118}'/0'/0/${opts?.index ?? 0}`
|
||||
);
|
||||
if (!publicKey || !privateKey) {
|
||||
throw new Error('invalid mnemonic');
|
||||
}
|
||||
return {
|
||||
publicKey,
|
||||
privateKey,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { sortObjectByKey } from './serialise';
|
||||
|
||||
describe('sortObjectByKey', () => {
|
||||
it('should sort keys correctly', () => {
|
||||
const obj = {
|
||||
zzz: 1,
|
||||
aaa: 1,
|
||||
xxx: null,
|
||||
bbb: {
|
||||
ttt: {
|
||||
ppp: true,
|
||||
iii: undefined,
|
||||
lll: '1',
|
||||
},
|
||||
ddd: [4, 8, 3, undefined, 4, 5, 7, 8],
|
||||
},
|
||||
};
|
||||
const expected = {
|
||||
aaa: 1,
|
||||
bbb: {
|
||||
ddd: [4, 8, 3, undefined, 4, 5, 7, 8], // arrays are not sorted
|
||||
ttt: {
|
||||
iii: undefined,
|
||||
lll: '1',
|
||||
ppp: true,
|
||||
},
|
||||
},
|
||||
xxx: null,
|
||||
zzz: 1,
|
||||
};
|
||||
// Before sorting, the stringified versions of the objects should NOT be equal
|
||||
expect(JSON.stringify(obj)).not.toBe(JSON.stringify(expected));
|
||||
// After sorting, the stringified versions of the objects should be equal
|
||||
expect(JSON.stringify(sortObjectByKey(obj))).toBe(JSON.stringify(expected));
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,35 @@
|
||||
import { utf8 } from '@scure/base';
|
||||
import type { StdSignDoc } from '@sonr.io/es/registry';
|
||||
|
||||
/**
|
||||
* Escapes <,>,& in string.
|
||||
* Golang's json marshaller escapes <,>,& by default.
|
||||
* However, because JS doesn't do that by default, to match the sign doc with cosmos-sdk,
|
||||
* we should escape <,>,& in string manually.
|
||||
* @param str
|
||||
*/
|
||||
function escapeHtml(str: string): string {
|
||||
return str.replace(/</g, '\\u003c').replace(/>/g, '\\u003e').replace(/&/g, '\\u0026');
|
||||
}
|
||||
|
||||
export function sortObjectByKey<T>(obj: T): T {
|
||||
if (typeof obj !== 'object' || obj == null) {
|
||||
return obj;
|
||||
}
|
||||
if (Array.isArray(obj)) {
|
||||
return obj.map(sortObjectByKey) as T;
|
||||
}
|
||||
const sortedKeys = Object.keys(obj).sort();
|
||||
const result: Record<string, unknown> = {};
|
||||
for (const key of sortedKeys) {
|
||||
result[key] = sortObjectByKey((obj as Record<string, unknown>)[key]);
|
||||
}
|
||||
return result as T;
|
||||
}
|
||||
|
||||
/**
|
||||
* Serialises the given sign doc to a `Uint8Array` in a deterministic manner.
|
||||
*/
|
||||
export function serialiseSignDoc(doc: StdSignDoc): Uint8Array {
|
||||
return utf8.decode(escapeHtml(JSON.stringify(sortObjectByKey(doc))));
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
import type { StdSignDoc } from '@keplr-wallet/types';
|
||||
import { base16, base64, utf8 } from '@scure/base';
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { ethhex } from './ethhex';
|
||||
import { hashEthArbitraryMessage, recoverPubKeyFromEthSignature, signAmino } from './sign';
|
||||
|
||||
describe('signAmino', () => {
|
||||
it('should sign Injective txs correctly', () => {
|
||||
const stdSignDoc: StdSignDoc = {
|
||||
chain_id: '',
|
||||
account_number: '0',
|
||||
sequence: '0',
|
||||
fee: {
|
||||
gas: '0',
|
||||
amount: [],
|
||||
},
|
||||
msgs: [
|
||||
{
|
||||
type: 'sign/MsgSignData',
|
||||
value: {
|
||||
signer: 'inj1l8w4vvmhcku28ryntpeazm37umshetzzl2gc33',
|
||||
data: base64.encode(
|
||||
utf8.decode(
|
||||
'Hi from CosmeES! This is a test message just to prove that the wallet is working.'
|
||||
)
|
||||
),
|
||||
},
|
||||
},
|
||||
],
|
||||
memo: '',
|
||||
};
|
||||
const privKey = base64.decode('o5di+2p2NdLgRYLtBIhJl9gsB9FWll8wKBaep3CmbI0=');
|
||||
const expected = // Signature taken from keplr signArbitrary
|
||||
'qrkZpuo1jpfXgbF3TtBtdR7DynE1nV3xd//bsGXm2FkS08waXeiJJ+FAvdtt9hvStyP/wGae07hxnyYPHEw+Uw==';
|
||||
const actual = base64.encode(signAmino(stdSignDoc, privKey, 'ethsecp256k1'));
|
||||
expect(actual).toStrictEqual(expected);
|
||||
});
|
||||
});
|
||||
|
||||
describe('hashEthArbitraryMessage', () => {
|
||||
it('should hash correctly', () => {
|
||||
const msg = utf8.decode('Hello World!');
|
||||
const expected = hashEthArbitraryMessage(msg);
|
||||
const actual = ethhex.decode(
|
||||
'0xec3608877ecbf8084c29896b7eab2a368b2b3c8d003288584d145613dfa4706c'
|
||||
);
|
||||
expect(actual).toStrictEqual(expected);
|
||||
});
|
||||
});
|
||||
|
||||
describe('recoverPubKeyFromEthSignature', () => {
|
||||
it('should recover public key correctly from a personal_sign signature', () => {
|
||||
const message = utf8.decode('Hello World');
|
||||
const signature = ethhex.decode(
|
||||
'0x63da4222cbcc36f43b22cbe417aa78963c29d088f7db3c9c6d06417dc34cf2df2dc6ffe9a5c9072a12a16a71c93bebf42bf388357aff81190d7dce166e4fa7ad1c'
|
||||
);
|
||||
const expected = base16.decode(
|
||||
'03f73842e6959e5b79f7979f81016e1e4f4d9481a7351a492ddb0807d98bb31f19'.toUpperCase()
|
||||
);
|
||||
const actual = recoverPubKeyFromEthSignature(message, signature);
|
||||
expect(expected).toStrictEqual(actual);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,83 @@
|
||||
import { hmac } from '@noble/hashes/hmac';
|
||||
import { keccak_256 } from '@noble/hashes/sha3';
|
||||
import { sha256 } from '@noble/hashes/sha256';
|
||||
import * as secp256k1 from '@noble/secp256k1';
|
||||
import { utf8 } from '@scure/base';
|
||||
import type { CosmosTxV1beta1SignDoc as SignDoc } from '@sonr.io/es/protobufs';
|
||||
import type { StdSignDoc } from '@sonr.io/es/registry';
|
||||
|
||||
import { serialiseSignDoc } from './serialise';
|
||||
|
||||
function sign(
|
||||
bytes: Uint8Array,
|
||||
privateKey: Uint8Array,
|
||||
type: 'secp256k1' | 'ethsecp256k1'
|
||||
): Uint8Array {
|
||||
// Required polyfills for secp256k1 that must be called before any sign ops.
|
||||
// See: https://github.com/paulmillr/noble-secp256k1?tab=readme-ov-file#usage
|
||||
secp256k1.etc.hmacSha256Sync = (k, ...m) => hmac(sha256, k, secp256k1.etc.concatBytes(...m));
|
||||
const hash = type === 'secp256k1' ? sha256(bytes) : keccak_256(bytes);
|
||||
return secp256k1.sign(hash, privateKey).toCompactRawBytes();
|
||||
}
|
||||
|
||||
/**
|
||||
* Signs the given amino-encoded `stdSignDoc` with the given `privateKey` using
|
||||
* secp256k1, and returns the signature bytes. For Injective, the `type` param
|
||||
* must be set to `ethsecp256k1`.
|
||||
*/
|
||||
export function signAmino(
|
||||
stdSignDoc: StdSignDoc,
|
||||
privateKey: Uint8Array,
|
||||
type: 'secp256k1' | 'ethsecp256k1' = 'secp256k1'
|
||||
): Uint8Array {
|
||||
return sign(serialiseSignDoc(stdSignDoc), privateKey, type);
|
||||
}
|
||||
|
||||
/**
|
||||
* Signs the given proto-encoded `signDoc` with the given `privateKey` using
|
||||
* secp256k1, and returns the signature bytes. For Injective, the `type` param
|
||||
* must be set to `ethsecp256k1`.
|
||||
*/
|
||||
export function signDirect(
|
||||
signDoc: SignDoc,
|
||||
privateKey: Uint8Array,
|
||||
type: 'secp256k1' | 'ethsecp256k1' = 'secp256k1'
|
||||
): Uint8Array {
|
||||
return sign(signDoc.toBinary(), privateKey, type);
|
||||
}
|
||||
|
||||
/**
|
||||
* Hashes and returns the digest of the given EIP191 `message` bytes.
|
||||
*/
|
||||
export function hashEthArbitraryMessage(message: Uint8Array): Uint8Array {
|
||||
return keccak_256(
|
||||
Uint8Array.from([
|
||||
...utf8.decode('\x19Ethereum Signed Message:\n'),
|
||||
...utf8.decode(message.length.toString()),
|
||||
...message,
|
||||
])
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Recovers and returns the secp256k1 public key of the signer given the arbitrary
|
||||
* `message` and `signature` that was signed using EIP191.
|
||||
*/
|
||||
export function recoverPubKeyFromEthSignature(
|
||||
message: Uint8Array,
|
||||
signature: Uint8Array
|
||||
): Uint8Array {
|
||||
if (signature.length !== 65) {
|
||||
throw new Error('Invalid signature');
|
||||
}
|
||||
const r = signature.slice(0, 32);
|
||||
const s = signature.slice(32, 64);
|
||||
const v = signature[64];
|
||||
// Adapted from https://github.com/ethers-io/ethers.js/blob/6017d3d39a4d428793bddae33d82fd814cacd878/src.ts/crypto/signature.ts#L255-L265
|
||||
const yParity = v <= 1 ? v : (v + 1) % 2;
|
||||
const secpSignature = secp256k1.Signature.fromCompact(
|
||||
Uint8Array.from([...r, ...s])
|
||||
).addRecoveryBit(yParity);
|
||||
const digest = hashEthArbitraryMessage(message);
|
||||
return secpSignature.recoverPublicKey(digest).toRawBytes(true);
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
import { base64, utf8 } from '@scure/base';
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { verifyADR36, verifyECDSA, verifyEIP191 } from './verify';
|
||||
|
||||
const DATA = utf8.decode(
|
||||
'Hi from CosmeES! This is a test message just to prove that the wallet is working.'
|
||||
);
|
||||
// Generated using coin type "330" and seed phrase "poverty flat amazing draw goose clay sorry nothing erase switch law intact only invest find memory what weasel fan connect tilt detect trap viable"
|
||||
const VALID_PUBKEY_1 = base64.decode('Ai7ZXTtRWFte/tX7Z6MlKWVd9XA49p3cDNqd61RuKTdT');
|
||||
// Generated using coin type "118" and seed phrase "poverty flat amazing draw goose clay sorry nothing erase switch law intact only invest find memory what weasel fan connect tilt detect trap viable"
|
||||
const VALID_PUBKEY_2 = base64.decode('A8i9vMNUGcTtUgpbmiZqcFtsIrPZ6n8ZYN4/PVRlQvGr');
|
||||
// Generated using coin type "60" and seed phrase "poverty flat amazing draw goose clay sorry nothing erase switch law intact only invest find memory what weasel fan connect tilt detect trap viable"
|
||||
const VALID_PUBKEY_3 = base64.decode('AmGjuPKUsuIAuGgJ3xH7KGWlSU9cwVnsesrwWwyYLbMg');
|
||||
|
||||
describe('verifyECDSA', () => {
|
||||
it('should verify correctly', () => {
|
||||
// Signed using Station wallet on Terra
|
||||
const signature = base64.decode(
|
||||
'Od87qNoOyXuDOVdLCGTXB6dFN7U0XF9Oegc8KDa+AWwX3jkrDXG++2nlPfsF4VJzlDHsoikPeZpxrB7v9PINnw=='
|
||||
);
|
||||
const res1 = verifyECDSA({
|
||||
pubKey: VALID_PUBKEY_1,
|
||||
data: DATA,
|
||||
signature,
|
||||
});
|
||||
expect(res1).toBe(true);
|
||||
|
||||
// Different pub key
|
||||
const res2 = verifyECDSA({
|
||||
pubKey: VALID_PUBKEY_2,
|
||||
data: DATA,
|
||||
signature,
|
||||
});
|
||||
expect(res2).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('verifyADR36', () => {
|
||||
it('should verify correctly', () => {
|
||||
// Signed using Keplr wallet on Osmosis
|
||||
const signature = base64.decode(
|
||||
'nvlcV0x0Ge8ADXLSAQGtfMw6EJkOfpmkDxgP7UI79uR8MhnAOp9T+e+ofgW9kY4bEIr0yhyBG+vSVAZRv9uCxA=='
|
||||
);
|
||||
const res1 = verifyADR36({
|
||||
bech32Prefix: 'osmo',
|
||||
pubKey: VALID_PUBKEY_2,
|
||||
data: DATA,
|
||||
signature,
|
||||
});
|
||||
expect(res1).toBe(true);
|
||||
|
||||
// Different bech32 prefix
|
||||
const res2 = verifyADR36({
|
||||
bech32Prefix: 'terra',
|
||||
pubKey: VALID_PUBKEY_2,
|
||||
data: DATA,
|
||||
signature,
|
||||
});
|
||||
expect(res2).toBe(false);
|
||||
|
||||
// Different pub key
|
||||
const res3 = verifyADR36({
|
||||
bech32Prefix: 'osmo',
|
||||
pubKey: VALID_PUBKEY_1,
|
||||
data: DATA,
|
||||
signature,
|
||||
});
|
||||
expect(res3).toBe(false);
|
||||
});
|
||||
|
||||
it('should verify ethsecp256k1 type signatures correctly', () => {
|
||||
// Signed using Keplr wallet on Injective
|
||||
const signature = base64.decode(
|
||||
'+7PNZm4XxKtpvZA+HqxpMKJgZcqA2w3WVSheLGvzrrIBJZGOTdcpBT7wLUhluY46EokTeRRWUaBDSv2vVoEdfw=='
|
||||
);
|
||||
const res1 = verifyADR36({
|
||||
bech32Prefix: 'inj',
|
||||
pubKey: VALID_PUBKEY_3,
|
||||
data: DATA,
|
||||
signature,
|
||||
type: 'ethsecp256k1',
|
||||
});
|
||||
expect(res1).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('verifyEIP191', () => {
|
||||
it('should verify correctly', () => {
|
||||
// Signed using MetaMask wallet on Injective
|
||||
const signature = base64.decode(
|
||||
'MpriWY0Kq7C+/jR3eOfNB5vUQM144tQk7KkzKyYCTFB5QHGLZjzJyeOSr8/ENFES0k+aaEF47Wepk7OHoZuLzxs='
|
||||
);
|
||||
const res1 = verifyEIP191({
|
||||
pubKey: VALID_PUBKEY_3,
|
||||
data: DATA,
|
||||
signature,
|
||||
});
|
||||
expect(res1).toBe(true);
|
||||
|
||||
// Different pub key
|
||||
const res2 = verifyEIP191({
|
||||
pubKey: VALID_PUBKEY_2,
|
||||
data: DATA,
|
||||
signature,
|
||||
});
|
||||
expect(res2).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,79 @@
|
||||
import { keccak_256 } from '@noble/hashes/sha3';
|
||||
import { sha256 } from '@noble/hashes/sha256';
|
||||
import * as secp256k1 from '@noble/secp256k1';
|
||||
import { base64 } from '@scure/base';
|
||||
|
||||
import { resolveBech32Address } from './address';
|
||||
import { serialiseSignDoc } from './serialise';
|
||||
import { recoverPubKeyFromEthSignature } from './sign';
|
||||
|
||||
type VerifyArbitraryParams = {
|
||||
/** The public key which created the signature */
|
||||
pubKey: Uint8Array;
|
||||
/** The bech32 account address prefix of the signer */
|
||||
bech32Prefix: string;
|
||||
/** The arbitrary bytes that was signed */
|
||||
data: Uint8Array;
|
||||
/** The signature bytes */
|
||||
signature: Uint8Array;
|
||||
/** The type of the signature */
|
||||
type?: 'secp256k1' | 'ethsecp256k1';
|
||||
};
|
||||
|
||||
export function verifyECDSA({
|
||||
pubKey,
|
||||
data,
|
||||
signature,
|
||||
type,
|
||||
}: Omit<VerifyArbitraryParams, 'bech32Prefix'>): boolean {
|
||||
return secp256k1.verify(
|
||||
signature,
|
||||
type === 'ethsecp256k1' ? keccak_256(data) : sha256(data),
|
||||
pubKey
|
||||
);
|
||||
}
|
||||
|
||||
export function verifyADR36({
|
||||
pubKey,
|
||||
bech32Prefix,
|
||||
data,
|
||||
signature,
|
||||
type,
|
||||
}: VerifyArbitraryParams): boolean {
|
||||
const msg = serialiseSignDoc({
|
||||
chain_id: '',
|
||||
account_number: '0',
|
||||
sequence: '0',
|
||||
fee: {
|
||||
gas: '0',
|
||||
amount: [],
|
||||
},
|
||||
msgs: [
|
||||
{
|
||||
type: 'sign/MsgSignData',
|
||||
value: {
|
||||
signer: resolveBech32Address(pubKey, bech32Prefix, type),
|
||||
data: base64.encode(data),
|
||||
},
|
||||
},
|
||||
],
|
||||
memo: '',
|
||||
});
|
||||
return verifyECDSA({
|
||||
pubKey,
|
||||
data: msg,
|
||||
signature,
|
||||
type,
|
||||
});
|
||||
}
|
||||
|
||||
export function verifyEIP191({
|
||||
pubKey,
|
||||
data,
|
||||
signature,
|
||||
}: Omit<VerifyArbitraryParams, 'bech32Prefix'>): boolean {
|
||||
const recoveredPubKey = recoverPubKeyFromEthSignature(data, signature);
|
||||
return (
|
||||
pubKey.length === recoveredPubKey.length && pubKey.every((v, i) => v === recoveredPubKey[i])
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
/**
|
||||
* @sonr.io/es - Sonr ES Module
|
||||
* Main entry point for browser/CDN usage
|
||||
*/
|
||||
// Motor Plugin - Service worker and WebAssembly runtime
|
||||
// Re-export main interfaces and classes for convenience
|
||||
export {
|
||||
MotorPluginImpl,
|
||||
createMotorPlugin,
|
||||
createMotorPluginForNode,
|
||||
createMotorPluginForBrowser,
|
||||
} from './worker';
|
||||
|
||||
export { VaultClient, createVaultClient, getDefaultVaultClient } from './plugin';
|
||||
|
||||
// Re-export Motor types
|
||||
export type {
|
||||
MotorPlugin,
|
||||
MotorPluginConfig,
|
||||
MotorServiceWorkerConfig,
|
||||
// Payment types
|
||||
PaymentInstrument,
|
||||
PaymentMethod,
|
||||
PaymentDetails,
|
||||
ProcessPaymentRequest,
|
||||
ProcessPaymentResponse,
|
||||
PaymentStatus,
|
||||
// OIDC types
|
||||
OIDCConfiguration,
|
||||
OIDCTokenRequest,
|
||||
OIDCTokenResponse,
|
||||
OIDCUserInfo,
|
||||
} from './worker';
|
||||
|
||||
// Re-export Service worker types
|
||||
export type {
|
||||
ServiceWorkerStatus,
|
||||
EnvironmentInfo,
|
||||
HealthCheckResponse,
|
||||
ServiceInfoResponse,
|
||||
ErrorResponse,
|
||||
} from './worker';
|
||||
|
||||
// Re-export Vault types
|
||||
export type {
|
||||
VaultConfig,
|
||||
VaultPlugin,
|
||||
EnclaveData,
|
||||
NewOriginTokenRequest,
|
||||
NewAttenuatedTokenRequest,
|
||||
UCANTokenResponse,
|
||||
SignDataRequest,
|
||||
SignDataResponse,
|
||||
VerifyDataRequest,
|
||||
VerifyDataResponse,
|
||||
GetIssuerDIDResponse,
|
||||
} from './plugin';
|
||||
|
||||
// Re-export error classes
|
||||
export { VaultError, VaultErrorCode } from './plugin';
|
||||
// Re-export auth functions directly for CDN usage
|
||||
export {
|
||||
registerWithPasskey,
|
||||
loginWithPasskey,
|
||||
isWebAuthnSupported,
|
||||
isWebAuthnAvailable,
|
||||
isConditionalMediationAvailable,
|
||||
bufferToBase64url,
|
||||
base64urlToBuffer,
|
||||
} from './client/auth/webauthn';
|
||||
|
||||
// Re-export client functionality
|
||||
export * from './client';
|
||||
|
||||
// Re-export codec utilities
|
||||
export * from './codec';
|
||||
|
||||
// Re-export wallet functionality (be selective to avoid conflicts)
|
||||
export type { ChainInfo, ConnectedWallet, WalletType } from './wallet';
|
||||
|
||||
// Re-export registry
|
||||
export * from './registry';
|
||||
|
||||
// Re-export protobufs
|
||||
export * from './protobufs';
|
||||
|
||||
// Export IPFS services namespace
|
||||
export * as ipfs from './client/services';
|
||||
|
||||
// Vault Plugin - MPC-based cryptographic vault
|
||||
export * as vault from './plugin';
|
||||
export * as motor from './worker';
|
||||
|
||||
@@ -0,0 +1,224 @@
|
||||
# Vault Plugin with Dexie.js Persistence
|
||||
|
||||
The Vault plugin now supports persistent storage using Dexie.js (IndexedDB wrapper), allowing vault state and UCAN tokens to persist across browser sessions.
|
||||
|
||||
## Features
|
||||
|
||||
- 🔐 **Account-based database separation** - Each account has its own isolated database
|
||||
- 💾 **Automatic persistence** - Tokens are automatically saved when created
|
||||
- 🔄 **Cross-browser support** - Works with all modern browsers supporting IndexedDB
|
||||
- ⚡ **Backward compatible** - Storage is opt-in, existing code continues to work
|
||||
- 🧹 **Automatic cleanup** - Expired tokens and sessions are cleaned up periodically
|
||||
|
||||
## Basic Usage
|
||||
|
||||
### Without Persistence (Default Behavior)
|
||||
|
||||
```typescript
|
||||
import { createVaultClient } from '@sonr.io/es/plugins/vault';
|
||||
|
||||
// Create vault client without persistence (backward compatible)
|
||||
const vault = createVaultClient();
|
||||
|
||||
// Initialize the vault
|
||||
await vault.initialize();
|
||||
|
||||
// Use vault as before
|
||||
const token = await vault.newOriginToken({
|
||||
audience_did: 'did:example:123',
|
||||
});
|
||||
```
|
||||
|
||||
### With Persistence Enabled
|
||||
|
||||
```typescript
|
||||
import { createVaultClient } from '@sonr.io/es/plugins/vault';
|
||||
|
||||
// Create vault client with persistence enabled
|
||||
const vault = createVaultClient({
|
||||
enablePersistence: true,
|
||||
autoCleanup: true,
|
||||
cleanupInterval: 3600000, // 1 hour
|
||||
});
|
||||
|
||||
// Initialize with account address for database separation
|
||||
const accountAddress = 'sonr1abc123...';
|
||||
await vault.initialize('/plugin.wasm', accountAddress);
|
||||
|
||||
// Vault state and tokens are now automatically persisted
|
||||
const token = await vault.newOriginToken({
|
||||
audience_did: 'did:example:123',
|
||||
});
|
||||
// Token is automatically saved to IndexedDB
|
||||
|
||||
// Retrieve all persisted tokens
|
||||
const tokens = await vault.getPersistedTokens();
|
||||
console.log(`Found ${tokens.length} saved tokens`);
|
||||
```
|
||||
|
||||
## Advanced Usage
|
||||
|
||||
### Multi-Account Support
|
||||
|
||||
```typescript
|
||||
// Start with account 1
|
||||
await vault.initialize('/plugin.wasm', 'sonr1account1');
|
||||
|
||||
// Do some work...
|
||||
const token1 = await vault.newOriginToken({ audience_did: 'did:1' });
|
||||
|
||||
// Switch to account 2
|
||||
await vault.switchAccount('sonr1account2');
|
||||
|
||||
// Work with account 2's isolated database
|
||||
const token2 = await vault.newOriginToken({ audience_did: 'did:2' });
|
||||
|
||||
// List all accounts with persisted data
|
||||
const accounts = await vault.listPersistedAccounts();
|
||||
console.log('Accounts with saved data:', accounts);
|
||||
|
||||
// Remove an account's data
|
||||
await vault.removeAccount('sonr1account1');
|
||||
```
|
||||
|
||||
### State Management
|
||||
|
||||
```typescript
|
||||
// Manually save current state
|
||||
await vault.persistState();
|
||||
|
||||
// Load persisted state
|
||||
const state = await vault.loadPersistedState();
|
||||
if (state) {
|
||||
console.log('Vault initialized:', state.isInitialized);
|
||||
console.log('Last accessed:', new Date(state.lastAccessed));
|
||||
}
|
||||
|
||||
// Clear all persisted data for current account
|
||||
await vault.clearPersistedState();
|
||||
```
|
||||
|
||||
### Token Management
|
||||
|
||||
```typescript
|
||||
// Manually save a token
|
||||
await vault.saveToken({
|
||||
token: 'eyJ...',
|
||||
issuer: 'did:sonr:123',
|
||||
address: 'sonr1abc...',
|
||||
});
|
||||
|
||||
// Get all saved tokens
|
||||
const tokens = await vault.getPersistedTokens();
|
||||
|
||||
// Remove expired tokens
|
||||
await vault.removeExpiredTokens();
|
||||
```
|
||||
|
||||
### Storage Persistence
|
||||
|
||||
```typescript
|
||||
import { VaultStorageManager } from '@sonr.io/es/plugins/vault';
|
||||
|
||||
const storageManager = new VaultStorageManager({
|
||||
enablePersistence: true,
|
||||
});
|
||||
|
||||
// Request persistent storage (prompts user in some browsers)
|
||||
const isPersisted = await storageManager.requestPersistentStorage();
|
||||
console.log('Storage persisted:', isPersisted);
|
||||
|
||||
// Check persistence status
|
||||
const status = await storageManager.tryPersistWithoutPromptingUser();
|
||||
// Returns: 'persisted' | 'prompt' | 'never'
|
||||
|
||||
// Get storage estimate
|
||||
const estimate = await storageManager.getStorageEstimate();
|
||||
if (estimate) {
|
||||
console.log(`Using ${estimate.usage} of ${estimate.quota} bytes`);
|
||||
}
|
||||
```
|
||||
|
||||
## Configuration Options
|
||||
|
||||
```typescript
|
||||
interface VaultStorageConfig {
|
||||
enablePersistence?: boolean; // Enable IndexedDB storage (default: false)
|
||||
storageQuotaRequest?: number; // Storage quota to request in bytes
|
||||
autoCleanup?: boolean; // Enable automatic cleanup (default: true)
|
||||
cleanupInterval?: number; // Cleanup interval in ms (default: 3600000)
|
||||
}
|
||||
```
|
||||
|
||||
## Browser Compatibility
|
||||
|
||||
- ✅ Chrome/Edge 23+
|
||||
- ✅ Firefox 16+
|
||||
- ✅ Safari 10+
|
||||
- ✅ Opera 15+
|
||||
- ✅ iOS Safari 10+
|
||||
- ✅ Chrome for Android
|
||||
|
||||
## Storage Limits
|
||||
|
||||
- **Chrome/Edge**: 60% of total disk space
|
||||
- **Firefox**: 50% of free disk space
|
||||
- **Safari**: 1GB initially, can request more
|
||||
- **Mobile browsers**: Varies by device
|
||||
|
||||
## Migration Guide
|
||||
|
||||
### From Non-Persistent to Persistent
|
||||
|
||||
```typescript
|
||||
// Before (non-persistent)
|
||||
const vault = createVaultClient();
|
||||
await vault.initialize();
|
||||
|
||||
// After (with persistence)
|
||||
const vault = createVaultClient({
|
||||
enablePersistence: true,
|
||||
});
|
||||
await vault.initialize('/plugin.wasm', accountAddress);
|
||||
```
|
||||
|
||||
No other code changes required - all existing methods work the same way.
|
||||
|
||||
## Security Considerations
|
||||
|
||||
- Databases are named by account address for isolation
|
||||
- No private keys or sensitive cryptographic material is stored
|
||||
- Only UCAN tokens and metadata are persisted
|
||||
- Use HTTPS in production for better storage persistence
|
||||
- Consider encrypting sensitive data before storage
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Storage Not Persisting
|
||||
|
||||
1. Check if running on HTTPS (required for persistence in some browsers)
|
||||
2. Verify IndexedDB is not disabled in browser settings
|
||||
3. Check available storage quota
|
||||
4. Try requesting persistent storage explicitly
|
||||
|
||||
### Database Errors
|
||||
|
||||
```typescript
|
||||
try {
|
||||
await vault.initialize('/plugin.wasm', accountAddress);
|
||||
} catch (error) {
|
||||
if (error.code === 'VAULT_NOT_INITIALIZED') {
|
||||
// Handle initialization error
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Cleanup Issues
|
||||
|
||||
If automatic cleanup is not working:
|
||||
|
||||
```typescript
|
||||
// Manually trigger cleanup
|
||||
const storageManager = new VaultStorageManager();
|
||||
await storageManager.cleanupExpiredData();
|
||||
```
|
||||
@@ -0,0 +1,305 @@
|
||||
/**
|
||||
* Unit tests for MPC enclave manager
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
||||
import { EnclaveIPFSManager, createEnclaveIPFSManager } from '../enclave';
|
||||
import type { IPFSClient } from '../../../client/services/ipfs';
|
||||
import type { EnclaveDataWithCID } from '../enclave';
|
||||
|
||||
// Mock IPFS client
|
||||
const mockIPFSClient: IPFSClient = {
|
||||
initialize: vi.fn(),
|
||||
addEnclaveData: vi.fn().mockResolvedValue({
|
||||
cid: 'QmTestCID123',
|
||||
size: 100,
|
||||
timestamp: Date.now(),
|
||||
}),
|
||||
getEnclaveData: vi.fn().mockResolvedValue(new Uint8Array([1, 2, 3, 4, 5])),
|
||||
verifiedFetch: vi.fn(),
|
||||
pin: vi.fn(),
|
||||
unpin: vi.fn(),
|
||||
isPinned: vi.fn().mockResolvedValue(true),
|
||||
listPins: vi.fn().mockResolvedValue(['QmCID1', 'QmCID2']),
|
||||
getNodeStatus: vi.fn(),
|
||||
isInitialized: vi.fn().mockReturnValue(true),
|
||||
cleanup: vi.fn(),
|
||||
addString: vi.fn(),
|
||||
getString: vi.fn(),
|
||||
} as any;
|
||||
|
||||
describe('EnclaveIPFSManager', () => {
|
||||
let manager: EnclaveIPFSManager;
|
||||
const validEnclaveData: EnclaveDataWithCID = {
|
||||
publicKey: 'public-key-123',
|
||||
privateKeyShares: ['share1', 'share2', 'share3'],
|
||||
threshold: 2,
|
||||
parties: 3,
|
||||
encryptionMetadata: {
|
||||
algorithm: 'AES-256-GCM',
|
||||
keyVersion: 1,
|
||||
consensusHeight: 100,
|
||||
nonce: 'test-nonce',
|
||||
},
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
manager = new EnclaveIPFSManager(mockIPFSClient, {
|
||||
encryptionRequired: true,
|
||||
pinningEnabled: true,
|
||||
redundancy: 3,
|
||||
maxRetries: 2,
|
||||
operationTimeout: 5000,
|
||||
});
|
||||
});
|
||||
|
||||
describe('storeEnclaveData', () => {
|
||||
it('should store encrypted enclave data', async () => {
|
||||
const encryptedPayload = new Uint8Array([10, 20, 30]);
|
||||
|
||||
const result = await manager.storeEnclaveData(
|
||||
validEnclaveData,
|
||||
encryptedPayload
|
||||
);
|
||||
|
||||
expect(result.cid).toBe('QmTestCID123');
|
||||
expect(result.isPinned).toBe(true);
|
||||
expect(result.size).toBe(100);
|
||||
expect(mockIPFSClient.addEnclaveData).toHaveBeenCalledWith(encryptedPayload);
|
||||
expect(mockIPFSClient.pin).toHaveBeenCalledWith('QmTestCID123');
|
||||
});
|
||||
|
||||
it('should require encryption metadata when encryption is required', async () => {
|
||||
const dataWithoutMetadata: EnclaveDataWithCID = {
|
||||
...validEnclaveData,
|
||||
encryptionMetadata: undefined,
|
||||
};
|
||||
|
||||
await expect(
|
||||
manager.storeEnclaveData(dataWithoutMetadata, new Uint8Array())
|
||||
).rejects.toThrow('Encryption metadata required for enclave data storage');
|
||||
});
|
||||
|
||||
it('should validate enclave data structure', async () => {
|
||||
const invalidData: EnclaveDataWithCID = {
|
||||
...validEnclaveData,
|
||||
threshold: 5, // Invalid: threshold > parties
|
||||
};
|
||||
|
||||
await expect(
|
||||
manager.storeEnclaveData(invalidData, new Uint8Array())
|
||||
).rejects.toThrow('Invalid threshold value');
|
||||
});
|
||||
|
||||
it('should retry on failure', async () => {
|
||||
(mockIPFSClient.addEnclaveData as any)
|
||||
.mockRejectedValueOnce(new Error('Network error'))
|
||||
.mockResolvedValueOnce({
|
||||
cid: 'QmRetryCID',
|
||||
size: 50,
|
||||
timestamp: Date.now(),
|
||||
});
|
||||
|
||||
const result = await manager.storeEnclaveData(
|
||||
validEnclaveData,
|
||||
new Uint8Array()
|
||||
);
|
||||
|
||||
expect(result.cid).toBe('QmRetryCID');
|
||||
expect(mockIPFSClient.addEnclaveData).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it('should fail after max retries', async () => {
|
||||
(mockIPFSClient.addEnclaveData as any).mockRejectedValue(
|
||||
new Error('Persistent error')
|
||||
);
|
||||
|
||||
await expect(
|
||||
manager.storeEnclaveData(validEnclaveData, new Uint8Array())
|
||||
).rejects.toThrow('Failed to store enclave data after 2 attempts');
|
||||
});
|
||||
});
|
||||
|
||||
describe('retrieveEnclaveData', () => {
|
||||
it('should retrieve enclave data', async () => {
|
||||
const data = await manager.retrieveEnclaveData('QmTestCID123');
|
||||
|
||||
expect(data).toBeInstanceOf(Uint8Array);
|
||||
expect(Array.from(data)).toEqual([1, 2, 3, 4, 5]);
|
||||
expect(mockIPFSClient.getEnclaveData).toHaveBeenCalledWith('QmTestCID123');
|
||||
});
|
||||
|
||||
it('should retry on failure', async () => {
|
||||
(mockIPFSClient.getEnclaveData as any)
|
||||
.mockRejectedValueOnce(new Error('Network error'))
|
||||
.mockResolvedValueOnce(new Uint8Array([9, 8, 7]));
|
||||
|
||||
const data = await manager.retrieveEnclaveData('QmTestCID123');
|
||||
|
||||
expect(Array.from(data)).toEqual([9, 8, 7]);
|
||||
expect(mockIPFSClient.getEnclaveData).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe('verifyEnclaveDataIntegrity', () => {
|
||||
it('should verify data integrity successfully', async () => {
|
||||
const expectedData = new Uint8Array([1, 2, 3, 4, 5]);
|
||||
(mockIPFSClient.getEnclaveData as any).mockResolvedValue(expectedData);
|
||||
|
||||
const isValid = await manager.verifyEnclaveDataIntegrity(
|
||||
'QmTestCID123',
|
||||
expectedData
|
||||
);
|
||||
|
||||
expect(isValid).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect data mismatch', async () => {
|
||||
const expectedData = new Uint8Array([1, 2, 3]);
|
||||
const actualData = new Uint8Array([4, 5, 6]);
|
||||
(mockIPFSClient.getEnclaveData as any).mockResolvedValue(actualData);
|
||||
|
||||
const isValid = await manager.verifyEnclaveDataIntegrity(
|
||||
'QmTestCID123',
|
||||
expectedData
|
||||
);
|
||||
|
||||
expect(isValid).toBe(false);
|
||||
});
|
||||
|
||||
it('should handle retrieval errors', async () => {
|
||||
(mockIPFSClient.getEnclaveData as any).mockRejectedValue(
|
||||
new Error('Retrieval failed')
|
||||
);
|
||||
|
||||
const isValid = await manager.verifyEnclaveDataIntegrity(
|
||||
'QmTestCID123',
|
||||
new Uint8Array()
|
||||
);
|
||||
|
||||
expect(isValid).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('batch operations', () => {
|
||||
it('should batch store multiple enclaves', async () => {
|
||||
const enclaves = [
|
||||
{ data: validEnclaveData, payload: new Uint8Array([1, 2, 3]) },
|
||||
{ data: validEnclaveData, payload: new Uint8Array([4, 5, 6]) },
|
||||
];
|
||||
|
||||
(mockIPFSClient.addEnclaveData as any)
|
||||
.mockResolvedValueOnce({ cid: 'QmCID1', size: 10, timestamp: Date.now() })
|
||||
.mockResolvedValueOnce({ cid: 'QmCID2', size: 20, timestamp: Date.now() });
|
||||
|
||||
const results = await manager.batchStoreEnclaves(enclaves);
|
||||
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results[0].cid).toBe('QmCID1');
|
||||
expect(results[1].cid).toBe('QmCID2');
|
||||
});
|
||||
|
||||
it('should continue batch operation even if one fails', async () => {
|
||||
const enclaves = [
|
||||
{ data: validEnclaveData, payload: new Uint8Array([1, 2, 3]) },
|
||||
{ data: { ...validEnclaveData, threshold: 10 }, payload: new Uint8Array() }, // Invalid
|
||||
{ data: validEnclaveData, payload: new Uint8Array([4, 5, 6]) },
|
||||
];
|
||||
|
||||
(mockIPFSClient.addEnclaveData as any)
|
||||
.mockResolvedValueOnce({ cid: 'QmCID1', size: 10, timestamp: Date.now() })
|
||||
.mockResolvedValueOnce({ cid: 'QmCID3', size: 30, timestamp: Date.now() });
|
||||
|
||||
const results = await manager.batchStoreEnclaves(enclaves);
|
||||
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results[0].cid).toBe('QmCID1');
|
||||
expect(results[1].cid).toBe('QmCID3');
|
||||
});
|
||||
});
|
||||
|
||||
describe('pin management', () => {
|
||||
it('should list pinned enclaves', async () => {
|
||||
const pins = await manager.listPinnedEnclaves();
|
||||
|
||||
expect(pins).toEqual(['QmCID1', 'QmCID2']);
|
||||
expect(mockIPFSClient.listPins).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should remove enclave data', async () => {
|
||||
await manager.removeEnclaveData('QmTestCID123');
|
||||
|
||||
expect(mockIPFSClient.isPinned).toHaveBeenCalledWith('QmTestCID123');
|
||||
expect(mockIPFSClient.unpin).toHaveBeenCalledWith('QmTestCID123');
|
||||
});
|
||||
|
||||
it('should skip unpinning if not pinned', async () => {
|
||||
(mockIPFSClient.isPinned as any).mockResolvedValue(false);
|
||||
|
||||
await manager.removeEnclaveData('QmTestCID123');
|
||||
|
||||
expect(mockIPFSClient.unpin).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('getEnclaveStatus', () => {
|
||||
it('should get enclave status', async () => {
|
||||
// Set timeout to 0 for instant response
|
||||
manager = new EnclaveIPFSManager(mockIPFSClient, {
|
||||
encryptionRequired: true,
|
||||
pinningEnabled: true,
|
||||
redundancy: 3,
|
||||
maxRetries: 1,
|
||||
operationTimeout: 0,
|
||||
});
|
||||
|
||||
// Mock the getEnclaveData to return a valid response
|
||||
(mockIPFSClient.getEnclaveData as any).mockResolvedValue(new Uint8Array([1, 2, 3, 4, 5]));
|
||||
(mockIPFSClient.isPinned as any).mockResolvedValue(true);
|
||||
|
||||
const status = await manager.getEnclaveStatus('QmTestCID123');
|
||||
|
||||
expect(status.exists).toBe(true);
|
||||
expect(status.isPinned).toBe(true);
|
||||
expect(status.size).toBe(5);
|
||||
});
|
||||
|
||||
it('should handle non-existent enclave', async () => {
|
||||
// Set timeout to 0 for instant response
|
||||
manager = new EnclaveIPFSManager(mockIPFSClient, {
|
||||
encryptionRequired: true,
|
||||
pinningEnabled: true,
|
||||
redundancy: 3,
|
||||
maxRetries: 1,
|
||||
operationTimeout: 0,
|
||||
});
|
||||
|
||||
(mockIPFSClient.getEnclaveData as any).mockRejectedValue(
|
||||
new Error('Not found')
|
||||
);
|
||||
(mockIPFSClient.isPinned as any).mockResolvedValue(false);
|
||||
|
||||
const status = await manager.getEnclaveStatus('QmNonExistent');
|
||||
|
||||
expect(status.exists).toBe(false);
|
||||
expect(status.isPinned).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('createEnclaveIPFSManager factory', () => {
|
||||
it('should create manager with initialized IPFS client', async () => {
|
||||
const manager = await createEnclaveIPFSManager(mockIPFSClient);
|
||||
|
||||
expect(manager).toBeInstanceOf(EnclaveIPFSManager);
|
||||
});
|
||||
|
||||
it('should throw if IPFS client not initialized', async () => {
|
||||
(mockIPFSClient.isInitialized as any).mockReturnValue(false);
|
||||
|
||||
await expect(createEnclaveIPFSManager(mockIPFSClient)).rejects.toThrow(
|
||||
'IPFS client must be initialized before creating enclave manager'
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,416 @@
|
||||
/**
|
||||
* Enhanced VaultClient with IPFS integration
|
||||
*/
|
||||
|
||||
import { VaultClient } from './client';
|
||||
import { IPFSClient, createIPFSClient } from '../client/services/ipfs';
|
||||
import { EnclaveIPFSManager, createEnclaveIPFSManager, type EnclaveDataWithCID } from './enclave';
|
||||
import type {
|
||||
VaultConfigWithIPFS,
|
||||
VaultError,
|
||||
VaultErrorCode,
|
||||
IPFSEnclaveReference,
|
||||
VaultStateWithIPFS,
|
||||
} from './types';
|
||||
|
||||
/**
|
||||
* VaultClient with integrated IPFS support for MPC enclave data
|
||||
*/
|
||||
export class VaultClientWithIPFS extends VaultClient {
|
||||
private ipfsClient: IPFSClient | null = null;
|
||||
private enclaveManager: EnclaveIPFSManager | null = null;
|
||||
private ipfsConfig: VaultConfigWithIPFS;
|
||||
|
||||
constructor(config: VaultConfigWithIPFS = {}) {
|
||||
super(config);
|
||||
this.ipfsConfig = config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize vault with IPFS support
|
||||
*/
|
||||
async initializeWithIPFS(
|
||||
wasmPath?: string,
|
||||
accountAddress?: string,
|
||||
ipfsConfig?: any
|
||||
): Promise<void> {
|
||||
// Initialize base vault client
|
||||
await super.initialize(wasmPath, accountAddress);
|
||||
|
||||
// Initialize IPFS client
|
||||
try {
|
||||
this.ipfsClient = await createIPFSClient({
|
||||
gateways: this.ipfsConfig.ipfsGateways,
|
||||
enablePersistence: this.ipfsConfig.enableIPFSPersistence,
|
||||
libp2pConfig: ipfsConfig || this.ipfsConfig.ipfsNodeConfig,
|
||||
});
|
||||
|
||||
// Initialize enclave manager
|
||||
this.enclaveManager = await createEnclaveIPFSManager(this.ipfsClient, {
|
||||
encryptionRequired: true,
|
||||
pinningEnabled: this.ipfsConfig.enableIPFSPersistence ?? true,
|
||||
maxRetries: 3,
|
||||
});
|
||||
} catch (error) {
|
||||
console.error('Failed to initialize IPFS:', error);
|
||||
throw new Error(`IPFS initialization failed: ${error}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Store enclave data to IPFS
|
||||
*/
|
||||
async storeEnclaveToIPFS(
|
||||
enclaveData: EnclaveDataWithCID,
|
||||
encryptedPayload: Uint8Array
|
||||
): Promise<string> {
|
||||
if (!this.enclaveManager) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
const result = await this.enclaveManager.storeEnclaveData(
|
||||
enclaveData,
|
||||
encryptedPayload
|
||||
);
|
||||
|
||||
// Save reference to database if persistence is enabled
|
||||
if (this.ipfsConfig.enablePersistence) {
|
||||
await this.saveIPFSReference({
|
||||
cid: result.cid,
|
||||
storedAt: result.timestamp,
|
||||
isPinned: result.isPinned,
|
||||
size: result.size,
|
||||
});
|
||||
}
|
||||
|
||||
return result.cid;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve enclave data from IPFS
|
||||
*/
|
||||
async retrieveEnclaveFromIPFS(cid: string): Promise<Uint8Array> {
|
||||
if (!this.enclaveManager) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
return await this.enclaveManager.retrieveEnclaveData(cid);
|
||||
}
|
||||
|
||||
/**
|
||||
* Store vault enclave with automatic encryption
|
||||
*/
|
||||
async storeVaultEnclave(
|
||||
privateKeyShares: string[]
|
||||
): Promise<string> {
|
||||
if (!this.enclaveManager) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
// Get current enclave configuration
|
||||
const enclaveConfig = this.ipfsConfig.enclave;
|
||||
if (!enclaveConfig) {
|
||||
throw new Error('Enclave configuration not set');
|
||||
}
|
||||
|
||||
// Create enclave data with CID
|
||||
const enclaveData: EnclaveDataWithCID = {
|
||||
...enclaveConfig,
|
||||
encryptionMetadata: {
|
||||
algorithm: 'AES-256-GCM',
|
||||
keyVersion: 1,
|
||||
consensusHeight: 0,
|
||||
nonce: this.generateNonce(),
|
||||
},
|
||||
};
|
||||
|
||||
// Prepare encrypted payload
|
||||
const payload = JSON.stringify({
|
||||
publicKey: enclaveData.publicKey,
|
||||
privateKeyShares,
|
||||
threshold: enclaveData.threshold,
|
||||
parties: enclaveData.parties,
|
||||
timestamp: Date.now(),
|
||||
});
|
||||
|
||||
const encryptedPayload = new TextEncoder().encode(payload);
|
||||
|
||||
// Store to IPFS
|
||||
return await this.storeEnclaveToIPFS(enclaveData, encryptedPayload);
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve and decrypt vault enclave
|
||||
*/
|
||||
async retrieveVaultEnclave(cid: string): Promise<EnclaveDataWithCID> {
|
||||
if (!this.enclaveManager) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
// Retrieve encrypted data
|
||||
const encryptedData = await this.retrieveEnclaveFromIPFS(cid);
|
||||
|
||||
// Decrypt and parse
|
||||
const decryptedString = new TextDecoder().decode(encryptedData);
|
||||
const enclaveData = JSON.parse(decryptedString);
|
||||
|
||||
return {
|
||||
...enclaveData,
|
||||
cid,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify enclave data integrity
|
||||
*/
|
||||
async verifyEnclaveIntegrity(
|
||||
cid: string,
|
||||
expectedData: Uint8Array
|
||||
): Promise<boolean> {
|
||||
if (!this.enclaveManager) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
return await this.enclaveManager.verifyEnclaveDataIntegrity(
|
||||
cid,
|
||||
expectedData
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get IPFS node status
|
||||
*/
|
||||
async getIPFSStatus(): Promise<any> {
|
||||
if (!this.ipfsClient) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
return await this.ipfsClient.getNodeStatus();
|
||||
}
|
||||
|
||||
/**
|
||||
* List all pinned enclave CIDs
|
||||
*/
|
||||
async listPinnedEnclaves(): Promise<string[]> {
|
||||
if (!this.enclaveManager) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
return await this.enclaveManager.listPinnedEnclaves();
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove enclave from IPFS (unpin)
|
||||
*/
|
||||
async removeEnclaveFromIPFS(cid: string): Promise<void> {
|
||||
if (!this.enclaveManager) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
await this.enclaveManager.removeEnclaveData(cid);
|
||||
|
||||
// Remove reference from database
|
||||
if (this.ipfsConfig.enablePersistence) {
|
||||
await this.removeIPFSReference(cid);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Batch store multiple enclaves
|
||||
*/
|
||||
async batchStoreEnclaves(
|
||||
enclaves: Array<{
|
||||
data: EnclaveDataWithCID;
|
||||
payload: Uint8Array;
|
||||
}>
|
||||
): Promise<string[]> {
|
||||
if (!this.enclaveManager) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
const results = await this.enclaveManager.batchStoreEnclaves(enclaves);
|
||||
|
||||
// Save references if persistence is enabled
|
||||
if (this.ipfsConfig.enablePersistence) {
|
||||
for (const result of results) {
|
||||
await this.saveIPFSReference({
|
||||
cid: result.cid,
|
||||
storedAt: result.timestamp,
|
||||
isPinned: result.isPinned,
|
||||
size: result.size,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return results.map(r => r.cid);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sync enclave data with IPFS network
|
||||
*/
|
||||
async syncWithIPFS(): Promise<void> {
|
||||
if (!this.ipfsClient || !this.enclaveManager) {
|
||||
throw new Error('IPFS not initialized');
|
||||
}
|
||||
|
||||
// Get stored references
|
||||
const references = await this.getIPFSReferences();
|
||||
|
||||
// Verify each reference
|
||||
for (const ref of references) {
|
||||
try {
|
||||
const status = await this.enclaveManager.getEnclaveStatus(ref.cid);
|
||||
|
||||
// Re-pin if needed
|
||||
if (!status.isPinned && ref.isPinned) {
|
||||
await this.ipfsClient.pin(ref.cid);
|
||||
}
|
||||
} catch (error) {
|
||||
console.warn(`Failed to sync CID ${ref.cid}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
// Update last sync timestamp
|
||||
await this.updateLastIPFSSync();
|
||||
}
|
||||
|
||||
// ============= Storage Methods =============
|
||||
|
||||
/**
|
||||
* Save IPFS reference to storage
|
||||
*/
|
||||
private async saveIPFSReference(ref: IPFSEnclaveReference): Promise<void> {
|
||||
const database = (this as any).database;
|
||||
if (!database) return;
|
||||
|
||||
// Store in metadata collection
|
||||
await database.metadata.put({
|
||||
id: `ipfs_${ref.cid}`,
|
||||
type: 'ipfs_reference',
|
||||
data: ref,
|
||||
createdAt: Date.now(),
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all IPFS references
|
||||
*/
|
||||
private async getIPFSReferences(): Promise<IPFSEnclaveReference[]> {
|
||||
const database = (this as any).database;
|
||||
if (!database) return [];
|
||||
|
||||
const metadata = await database.metadata
|
||||
.where('type')
|
||||
.equals('ipfs_reference')
|
||||
.toArray();
|
||||
|
||||
return metadata.map((m: any) => m.data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove IPFS reference
|
||||
*/
|
||||
private async removeIPFSReference(cid: string): Promise<void> {
|
||||
const database = (this as any).database;
|
||||
if (!database) return;
|
||||
|
||||
await database.metadata.delete(`ipfs_${cid}`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update last IPFS sync timestamp
|
||||
*/
|
||||
private async updateLastIPFSSync(): Promise<void> {
|
||||
const database = (this as any).database;
|
||||
if (!database) return;
|
||||
|
||||
await database.metadata.put({
|
||||
id: 'ipfs_last_sync',
|
||||
type: 'ipfs_sync',
|
||||
timestamp: Date.now(),
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Persist state with IPFS references
|
||||
*/
|
||||
async persistState(): Promise<void> {
|
||||
await super.persistState();
|
||||
|
||||
// Add IPFS-specific state
|
||||
const database = (this as any).database;
|
||||
const accountAddress = (this as any).accountAddress;
|
||||
|
||||
if (!database || !accountAddress) return;
|
||||
|
||||
const references = await this.getIPFSReferences();
|
||||
|
||||
const state: VaultStateWithIPFS = {
|
||||
id: 'current',
|
||||
accountAddress,
|
||||
isInitialized: this.isReady(),
|
||||
enclave: this.ipfsConfig.enclave ?
|
||||
JSON.stringify(this.ipfsConfig.enclave) : undefined,
|
||||
lastAccessed: Date.now(),
|
||||
createdAt: Date.now(),
|
||||
ipfsReferences: references,
|
||||
lastIPFSSync: Date.now(),
|
||||
};
|
||||
|
||||
await database.state.put(state);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random nonce
|
||||
*/
|
||||
private generateNonce(): string {
|
||||
const bytes = new Uint8Array(16);
|
||||
crypto.getRandomValues(bytes);
|
||||
return Array.from(bytes)
|
||||
.map(b => b.toString(16).padStart(2, '0'))
|
||||
.join('');
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleanup with IPFS shutdown
|
||||
*/
|
||||
async cleanup(): Promise<void> {
|
||||
// Clean up IPFS resources
|
||||
if (this.ipfsClient) {
|
||||
await this.ipfsClient.cleanup();
|
||||
this.ipfsClient = null;
|
||||
}
|
||||
|
||||
this.enclaveManager = null;
|
||||
|
||||
// Call parent cleanup
|
||||
await super.cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a VaultClient with IPFS support
|
||||
*/
|
||||
export function createVaultClientWithIPFS(
|
||||
config?: VaultConfigWithIPFS
|
||||
): VaultClientWithIPFS {
|
||||
return new VaultClientWithIPFS(config);
|
||||
}
|
||||
|
||||
/**
|
||||
* Default IPFS-enabled vault client instance
|
||||
*/
|
||||
let defaultIPFSClient: VaultClientWithIPFS | null = null;
|
||||
|
||||
/**
|
||||
* Get or create the default IPFS-enabled vault client
|
||||
*/
|
||||
export async function getDefaultVaultClientWithIPFS(
|
||||
config?: VaultConfigWithIPFS
|
||||
): Promise<VaultClientWithIPFS> {
|
||||
if (!defaultIPFSClient) {
|
||||
defaultIPFSClient = createVaultClientWithIPFS(config);
|
||||
await defaultIPFSClient.initializeWithIPFS();
|
||||
}
|
||||
return defaultIPFSClient;
|
||||
}
|
||||
@@ -0,0 +1,515 @@
|
||||
import { createPlugin, Plugin } from '@extism/extism';
|
||||
import {
|
||||
VaultError,
|
||||
VaultErrorCode,
|
||||
} from './types';
|
||||
import type {
|
||||
VaultConfig,
|
||||
VaultPlugin,
|
||||
NewOriginTokenRequest,
|
||||
NewAttenuatedTokenRequest,
|
||||
SignDataRequest,
|
||||
VerifyDataRequest,
|
||||
UCANTokenResponse,
|
||||
SignDataResponse,
|
||||
VerifyDataResponse,
|
||||
GetIssuerDIDResponse,
|
||||
VaultConfigWithStorage,
|
||||
StoredVaultState,
|
||||
StoredUCANToken,
|
||||
} from './types';
|
||||
import { VaultStorageManager } from './storage';
|
||||
import type { AccountVaultDatabase } from './storage';
|
||||
|
||||
/**
|
||||
* Vault client for interacting with the WASM vault module
|
||||
*/
|
||||
export class VaultClient implements VaultPlugin {
|
||||
private plugin: Plugin | null = null;
|
||||
private config: VaultConfigWithStorage;
|
||||
private wasmModule: ArrayBuffer | null = null;
|
||||
private storageManager: VaultStorageManager | null = null;
|
||||
private database: any | null = null;
|
||||
private accountAddress: string | null = null;
|
||||
|
||||
constructor(config: VaultConfigWithStorage = {}) {
|
||||
this.config = config;
|
||||
|
||||
// Initialize storage manager if persistence is enabled
|
||||
if (config.enablePersistence) {
|
||||
this.storageManager = new VaultStorageManager(config);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the vault with WASM module
|
||||
*/
|
||||
async initialize(wasmPath?: string, accountAddress?: string): Promise<void> {
|
||||
// Initialize storage first if account address is provided and persistence is enabled
|
||||
// This ensures storage works even if WASM loading fails
|
||||
if (accountAddress && this.config.enablePersistence && this.storageManager) {
|
||||
this.accountAddress = accountAddress;
|
||||
this.database = await this.storageManager.getDatabase(accountAddress);
|
||||
await this.loadPersistedState();
|
||||
}
|
||||
|
||||
try {
|
||||
// Load WASM module
|
||||
if (wasmPath) {
|
||||
// Load from provided path
|
||||
const response = await fetch(wasmPath);
|
||||
this.wasmModule = await response.arrayBuffer();
|
||||
} else {
|
||||
// Load from default location
|
||||
const response = await fetch('/plugin.wasm');
|
||||
this.wasmModule = await response.arrayBuffer();
|
||||
}
|
||||
|
||||
// Create Extism plugin with configuration
|
||||
const pluginConfig = {
|
||||
wasm: [{ data: new Uint8Array(this.wasmModule) }],
|
||||
config: this.prepareConfig(),
|
||||
};
|
||||
|
||||
this.plugin = await createPlugin(pluginConfig, {
|
||||
useWasi: true,
|
||||
});
|
||||
|
||||
} catch (error) {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.WASM_NOT_LOADED,
|
||||
`Failed to initialize vault: ${error}`,
|
||||
error
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare configuration for the plugin
|
||||
*/
|
||||
private prepareConfig(): Record<string, string> {
|
||||
const config: Record<string, string> = {};
|
||||
|
||||
if (this.config.chainId) {
|
||||
config.chain_id = this.config.chainId;
|
||||
}
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensure plugin is initialized
|
||||
*/
|
||||
private ensureInitialized(): void {
|
||||
if (!this.plugin) {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.NOT_INITIALIZED,
|
||||
'Vault client not initialized. Call initialize() first.'
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert JavaScript object to JSON for plugin input
|
||||
*/
|
||||
private toPluginInput(data: any): Uint8Array {
|
||||
const json = JSON.stringify(data);
|
||||
return new TextEncoder().encode(json);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse plugin output as JSON
|
||||
*/
|
||||
private parsePluginOutput<T>(output: any): T {
|
||||
if (!output) {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
'No output from plugin'
|
||||
);
|
||||
}
|
||||
|
||||
// Handle both Uint8Array and PluginOutput types
|
||||
let text: string;
|
||||
if (output instanceof Uint8Array) {
|
||||
text = new TextDecoder().decode(output);
|
||||
} else if (output.bytes) {
|
||||
// PluginOutput type from Extism
|
||||
text = new TextDecoder().decode(output.bytes());
|
||||
} else if (output.text) {
|
||||
text = output.text();
|
||||
} else {
|
||||
text = output.toString();
|
||||
}
|
||||
|
||||
return JSON.parse(text) as T;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new origin UCAN token
|
||||
*/
|
||||
async newOriginToken(request: NewOriginTokenRequest): Promise<UCANTokenResponse> {
|
||||
this.ensureInitialized();
|
||||
|
||||
try {
|
||||
const input = this.toPluginInput(request);
|
||||
const output = await this.plugin!.call('new_origin_token', input);
|
||||
const response = this.parsePluginOutput<UCANTokenResponse>(output);
|
||||
|
||||
if (response.error) {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
response.error
|
||||
);
|
||||
}
|
||||
|
||||
// Save token if persistence is enabled
|
||||
if (this.config.enablePersistence && this.database) {
|
||||
await this.saveToken(response);
|
||||
}
|
||||
|
||||
return response;
|
||||
} catch (error) {
|
||||
if (error instanceof VaultError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
`Failed to create origin token: ${error}`,
|
||||
error
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new attenuated UCAN token
|
||||
*/
|
||||
async newAttenuatedToken(request: NewAttenuatedTokenRequest): Promise<UCANTokenResponse> {
|
||||
this.ensureInitialized();
|
||||
|
||||
try {
|
||||
const input = this.toPluginInput(request);
|
||||
const output = await this.plugin!.call('new_attenuated_token', input);
|
||||
const response = this.parsePluginOutput<UCANTokenResponse>(output);
|
||||
|
||||
if (response.error) {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
response.error
|
||||
);
|
||||
}
|
||||
|
||||
// Save token if persistence is enabled
|
||||
if (this.config.enablePersistence && this.database) {
|
||||
await this.saveToken(response);
|
||||
}
|
||||
|
||||
return response;
|
||||
} catch (error) {
|
||||
if (error instanceof VaultError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
`Failed to create attenuated token: ${error}`,
|
||||
error
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sign data with the vault's MPC enclave
|
||||
*/
|
||||
async signData(request: SignDataRequest): Promise<SignDataResponse> {
|
||||
this.ensureInitialized();
|
||||
|
||||
try {
|
||||
const input = this.toPluginInput({
|
||||
data: Array.from(request.data),
|
||||
});
|
||||
const output = await this.plugin!.call('sign_data', input);
|
||||
const response = this.parsePluginOutput<any>(output);
|
||||
|
||||
if (response.error) {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
response.error
|
||||
);
|
||||
}
|
||||
|
||||
return {
|
||||
signature: new Uint8Array(response.signature),
|
||||
error: response.error,
|
||||
};
|
||||
} catch (error) {
|
||||
if (error instanceof VaultError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
`Failed to sign data: ${error}`,
|
||||
error
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify a signature with the vault's MPC enclave
|
||||
*/
|
||||
async verifyData(request: VerifyDataRequest): Promise<VerifyDataResponse> {
|
||||
this.ensureInitialized();
|
||||
|
||||
try {
|
||||
const input = this.toPluginInput({
|
||||
data: Array.from(request.data),
|
||||
signature: Array.from(request.signature),
|
||||
});
|
||||
const output = await this.plugin!.call('verify_data', input);
|
||||
const response = this.parsePluginOutput<VerifyDataResponse>(output);
|
||||
|
||||
if (response.error) {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
response.error
|
||||
);
|
||||
}
|
||||
|
||||
return response;
|
||||
} catch (error) {
|
||||
if (error instanceof VaultError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
`Failed to verify data: ${error}`,
|
||||
error
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the issuer DID and address from the vault
|
||||
*/
|
||||
async getIssuerDID(): Promise<GetIssuerDIDResponse> {
|
||||
this.ensureInitialized();
|
||||
|
||||
try {
|
||||
const output = await this.plugin!.call('get_issuer_did', new Uint8Array());
|
||||
const response = this.parsePluginOutput<GetIssuerDIDResponse>(output);
|
||||
|
||||
if (response.error) {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
response.error
|
||||
);
|
||||
}
|
||||
|
||||
return response;
|
||||
} catch (error) {
|
||||
if (error instanceof VaultError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultError(
|
||||
VaultErrorCode.OPERATION_FAILED,
|
||||
`Failed to get issuer DID: ${error}`,
|
||||
error
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the vault is ready
|
||||
*/
|
||||
isReady(): boolean {
|
||||
return this.plugin !== null;
|
||||
}
|
||||
|
||||
// ============= Storage Management Methods =============
|
||||
|
||||
/**
|
||||
* Persist current vault state
|
||||
*/
|
||||
async persistState(): Promise<void> {
|
||||
if (!this.database || !this.accountAddress) return;
|
||||
|
||||
const state: StoredVaultState = {
|
||||
id: 'current',
|
||||
accountAddress: this.accountAddress,
|
||||
isInitialized: this.isReady(),
|
||||
enclave: this.config.enclave ? JSON.stringify(this.config.enclave) : undefined,
|
||||
lastAccessed: Date.now(),
|
||||
createdAt: Date.now(),
|
||||
};
|
||||
|
||||
await this.database.state.put(state);
|
||||
}
|
||||
|
||||
/**
|
||||
* Load persisted vault state
|
||||
*/
|
||||
async loadPersistedState(): Promise<StoredVaultState | null> {
|
||||
if (!this.database) return null;
|
||||
|
||||
const state = await this.database.state.get('current');
|
||||
if (state && state.enclave) {
|
||||
// Restore enclave configuration if present
|
||||
this.config.enclave = JSON.parse(state.enclave);
|
||||
}
|
||||
return state || null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear persisted vault state
|
||||
*/
|
||||
async clearPersistedState(): Promise<void> {
|
||||
if (!this.database) return;
|
||||
|
||||
await this.database.state.clear();
|
||||
await this.database.tokens.clear();
|
||||
await this.database.sessions.clear();
|
||||
await this.database.metadata.clear();
|
||||
}
|
||||
|
||||
// ============= Token Management Methods =============
|
||||
|
||||
/**
|
||||
* Save UCAN token to storage
|
||||
*/
|
||||
async saveToken(token: UCANTokenResponse): Promise<void> {
|
||||
if (!this.database) return;
|
||||
|
||||
const storedToken: StoredUCANToken = {
|
||||
id: `${Date.now()}_${Math.random()}`,
|
||||
token: token.token,
|
||||
type: 'origin', // Default to origin, can be enhanced
|
||||
issuer: token.issuer,
|
||||
audience: token.address,
|
||||
createdAt: Date.now(),
|
||||
};
|
||||
|
||||
await this.database.tokens.put(storedToken);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all persisted tokens
|
||||
*/
|
||||
async getPersistedTokens(): Promise<StoredUCANToken[]> {
|
||||
if (!this.database) return [];
|
||||
|
||||
const tokens = await this.database.tokens.toArray();
|
||||
return tokens || [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove expired tokens
|
||||
*/
|
||||
async removeExpiredTokens(): Promise<void> {
|
||||
if (!this.database) return;
|
||||
|
||||
const now = Date.now();
|
||||
await this.database.tokens
|
||||
.where('expiresAt')
|
||||
.below(now)
|
||||
.delete();
|
||||
}
|
||||
|
||||
// ============= Account Management Methods =============
|
||||
|
||||
/**
|
||||
* Switch to a different account
|
||||
*/
|
||||
async switchAccount(newAccountAddress: string): Promise<void> {
|
||||
if (!this.storageManager) {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.NOT_INITIALIZED,
|
||||
'Storage manager not initialized'
|
||||
);
|
||||
}
|
||||
|
||||
// Save current state before switching
|
||||
if (this.accountAddress && this.database) {
|
||||
await this.persistState();
|
||||
}
|
||||
|
||||
// Switch to new account database
|
||||
this.accountAddress = newAccountAddress;
|
||||
this.database = await this.storageManager.getDatabase(newAccountAddress);
|
||||
|
||||
// Load new account state
|
||||
await this.loadPersistedState();
|
||||
}
|
||||
|
||||
/**
|
||||
* List all persisted accounts
|
||||
*/
|
||||
async listPersistedAccounts(): Promise<string[]> {
|
||||
if (!this.storageManager) return [];
|
||||
|
||||
return await this.storageManager.listPersistedAccounts();
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove an account and its data
|
||||
*/
|
||||
async removeAccount(accountAddress: string): Promise<void> {
|
||||
if (!this.storageManager) return;
|
||||
|
||||
// If removing current account, clear local references
|
||||
if (accountAddress === this.accountAddress) {
|
||||
this.accountAddress = null;
|
||||
this.database = null;
|
||||
}
|
||||
|
||||
await this.storageManager.removeDatabase(accountAddress);
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleanup and release resources
|
||||
*/
|
||||
async cleanup(): Promise<void> {
|
||||
// Save current state before cleanup
|
||||
if (this.database && this.accountAddress) {
|
||||
await this.persistState();
|
||||
}
|
||||
|
||||
if (this.plugin) {
|
||||
await this.plugin.close();
|
||||
this.plugin = null;
|
||||
}
|
||||
|
||||
if (this.storageManager) {
|
||||
await this.storageManager.closeAll();
|
||||
}
|
||||
|
||||
this.wasmModule = null;
|
||||
this.database = null;
|
||||
this.accountAddress = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new vault client instance
|
||||
*/
|
||||
export function createVaultClient(config?: VaultConfigWithStorage): VaultClient {
|
||||
return new VaultClient(config);
|
||||
}
|
||||
|
||||
/**
|
||||
* Default vault client instance
|
||||
*/
|
||||
let defaultClient: VaultClient | null = null;
|
||||
|
||||
/**
|
||||
* Get or create the default vault client
|
||||
*/
|
||||
export async function getDefaultVaultClient(config?: VaultConfigWithStorage): Promise<VaultClient> {
|
||||
if (!defaultClient) {
|
||||
defaultClient = createVaultClient(config);
|
||||
await defaultClient.initialize();
|
||||
}
|
||||
return defaultClient;
|
||||
}
|
||||
|
||||
/**
|
||||
* Export error class for convenience
|
||||
*/
|
||||
export { VaultError, VaultErrorCode } from './types';
|
||||
@@ -0,0 +1,398 @@
|
||||
/**
|
||||
* MPC Enclave manager for IPFS-based vault data operations
|
||||
*/
|
||||
|
||||
import type { IPFSClient } from '../client/services/ipfs'
|
||||
import { EnclaveData } from './types'
|
||||
|
||||
/**
|
||||
* Extended enclave data with CID reference
|
||||
*/
|
||||
export interface EnclaveDataWithCID extends EnclaveData {
|
||||
/** IPFS CID for the encrypted enclave data */
|
||||
cid?: string
|
||||
/** Encryption metadata for consensus-based encryption */
|
||||
encryptionMetadata?: EncryptionMetadata
|
||||
}
|
||||
|
||||
/**
|
||||
* Encryption metadata for consensus-based encryption
|
||||
*/
|
||||
export interface EncryptionMetadata {
|
||||
/** Encryption algorithm used */
|
||||
algorithm: string
|
||||
/** Version of the encryption key */
|
||||
keyVersion: number
|
||||
/** Consensus height at encryption time */
|
||||
consensusHeight: number
|
||||
/** Nonce for encryption */
|
||||
nonce: string
|
||||
}
|
||||
|
||||
/**
|
||||
* Configuration for enclave storage operations
|
||||
*/
|
||||
export interface EnclaveStorageConfig {
|
||||
/** Whether encryption is required for all enclave data */
|
||||
encryptionRequired: boolean
|
||||
/** Enable automatic pinning of enclave data */
|
||||
pinningEnabled: boolean
|
||||
/** Number of redundant copies to maintain */
|
||||
redundancy: number
|
||||
/** Maximum retry attempts for failed operations */
|
||||
maxRetries: number
|
||||
/** Timeout for operations in milliseconds */
|
||||
operationTimeout?: number
|
||||
}
|
||||
|
||||
/**
|
||||
* Result of enclave storage operation
|
||||
*/
|
||||
export interface EnclaveStorageResult {
|
||||
/** CID of stored data */
|
||||
cid: string
|
||||
/** Whether data was pinned */
|
||||
isPinned: boolean
|
||||
/** Size of stored data */
|
||||
size: number
|
||||
/** Timestamp of storage */
|
||||
timestamp: number
|
||||
}
|
||||
|
||||
/**
|
||||
* Manages MPC enclave data operations with IPFS
|
||||
*/
|
||||
export class EnclaveIPFSManager {
|
||||
private ipfsClient: IPFSClient
|
||||
private config: EnclaveStorageConfig
|
||||
|
||||
constructor(
|
||||
ipfsClient: IPFSClient,
|
||||
config: Partial<EnclaveStorageConfig> = {}
|
||||
) {
|
||||
this.ipfsClient = ipfsClient
|
||||
this.config = {
|
||||
encryptionRequired: true,
|
||||
pinningEnabled: true,
|
||||
redundancy: 3,
|
||||
maxRetries: 3,
|
||||
operationTimeout: 30000,
|
||||
...config
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Store encrypted enclave data to IPFS
|
||||
*/
|
||||
async storeEnclaveData(
|
||||
enclaveData: EnclaveDataWithCID,
|
||||
encryptedPayload: Uint8Array
|
||||
): Promise<EnclaveStorageResult> {
|
||||
// Validate encryption requirement
|
||||
if (this.config.encryptionRequired && !enclaveData.encryptionMetadata) {
|
||||
throw new Error('Encryption metadata required for enclave data storage')
|
||||
}
|
||||
|
||||
// Validate enclave data structure
|
||||
this.validateEnclaveData(enclaveData)
|
||||
|
||||
// Store with retry logic
|
||||
let lastError: Error | null = null
|
||||
let result: EnclaveStorageResult | null = null
|
||||
|
||||
for (let attempt = 0; attempt < this.config.maxRetries; attempt++) {
|
||||
try {
|
||||
// Store encrypted data to IPFS
|
||||
const { cid, size, timestamp } = await this.ipfsClient.addEnclaveData(encryptedPayload)
|
||||
|
||||
// Pin the content if enabled
|
||||
let isPinned = false
|
||||
if (this.config.pinningEnabled) {
|
||||
await this.ipfsClient.pin(cid)
|
||||
isPinned = true
|
||||
}
|
||||
|
||||
result = {
|
||||
cid,
|
||||
isPinned,
|
||||
size,
|
||||
timestamp
|
||||
}
|
||||
|
||||
break
|
||||
} catch (error) {
|
||||
lastError = error as Error
|
||||
console.warn(`Attempt ${attempt + 1} failed:`, error)
|
||||
|
||||
// Exponential backoff
|
||||
if (attempt < this.config.maxRetries - 1) {
|
||||
await this.delay(Math.pow(2, attempt) * 1000)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!result) {
|
||||
throw new Error(
|
||||
`Failed to store enclave data after ${this.config.maxRetries} attempts: ${lastError?.message}`
|
||||
)
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve encrypted enclave data from IPFS
|
||||
*/
|
||||
async retrieveEnclaveData(cid: string): Promise<Uint8Array> {
|
||||
let lastError: Error | null = null
|
||||
|
||||
for (let attempt = 0; attempt < this.config.maxRetries; attempt++) {
|
||||
try {
|
||||
// Create a race between operation and timeout
|
||||
const timeoutPromise = this.createTimeoutPromise()
|
||||
const dataPromise = this.ipfsClient.getEnclaveData(cid)
|
||||
|
||||
const data = await Promise.race([dataPromise, timeoutPromise])
|
||||
|
||||
if (data === null) {
|
||||
throw new Error('Operation timed out')
|
||||
}
|
||||
|
||||
return data as Uint8Array
|
||||
} catch (error) {
|
||||
lastError = error as Error
|
||||
console.warn(`Retrieval attempt ${attempt + 1} failed:`, error)
|
||||
|
||||
// Exponential backoff
|
||||
if (attempt < this.config.maxRetries - 1) {
|
||||
await this.delay(Math.pow(2, attempt) * 1000)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
throw new Error(
|
||||
`Failed to retrieve enclave data after ${this.config.maxRetries} attempts: ${lastError?.message}`
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify enclave data integrity by comparing CID
|
||||
*/
|
||||
async verifyEnclaveDataIntegrity(
|
||||
cid: string,
|
||||
expectedData: Uint8Array
|
||||
): Promise<boolean> {
|
||||
try {
|
||||
const retrievedData = await this.retrieveEnclaveData(cid)
|
||||
|
||||
// Compare byte arrays
|
||||
if (retrievedData.length !== expectedData.length) {
|
||||
return false
|
||||
}
|
||||
|
||||
for (let i = 0; i < retrievedData.length; i++) {
|
||||
if (retrievedData[i] !== expectedData[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
} catch (error) {
|
||||
console.error('Failed to verify enclave data integrity:', error)
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Store enclave data with metadata
|
||||
*/
|
||||
async storeEnclaveWithMetadata(
|
||||
enclaveData: EnclaveDataWithCID,
|
||||
privateKeyShares: Uint8Array[],
|
||||
encryptionKey: Uint8Array
|
||||
): Promise<EnclaveStorageResult> {
|
||||
// Prepare the complete enclave payload
|
||||
const payload = this.prepareEnclavePayload(enclaveData, privateKeyShares)
|
||||
|
||||
// Encrypt the payload
|
||||
const encryptedPayload = await this.encryptPayload(payload, encryptionKey)
|
||||
|
||||
// Store to IPFS
|
||||
return await this.storeEnclaveData(enclaveData, encryptedPayload)
|
||||
}
|
||||
|
||||
/**
|
||||
* Batch store multiple enclave data
|
||||
*/
|
||||
async batchStoreEnclaves(
|
||||
enclaves: Array<{
|
||||
data: EnclaveDataWithCID
|
||||
payload: Uint8Array
|
||||
}>
|
||||
): Promise<EnclaveStorageResult[]> {
|
||||
const results: EnclaveStorageResult[] = []
|
||||
|
||||
for (const enclave of enclaves) {
|
||||
try {
|
||||
const result = await this.storeEnclaveData(enclave.data, enclave.payload)
|
||||
results.push(result)
|
||||
} catch (error) {
|
||||
console.error('Failed to store enclave:', error)
|
||||
// Continue with other enclaves even if one fails
|
||||
}
|
||||
}
|
||||
|
||||
return results
|
||||
}
|
||||
|
||||
/**
|
||||
* List all pinned enclave CIDs
|
||||
*/
|
||||
async listPinnedEnclaves(): Promise<string[]> {
|
||||
return await this.ipfsClient.listPins()
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove enclave data from IPFS (unpin)
|
||||
*/
|
||||
async removeEnclaveData(cid: string): Promise<void> {
|
||||
try {
|
||||
// Check if pinned before unpinning
|
||||
const isPinned = await this.ipfsClient.isPinned(cid)
|
||||
if (isPinned) {
|
||||
await this.ipfsClient.unpin(cid)
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Failed to remove enclave data:', error)
|
||||
throw error
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get enclave storage status
|
||||
*/
|
||||
async getEnclaveStatus(cid: string): Promise<{
|
||||
exists: boolean
|
||||
isPinned: boolean
|
||||
size?: number
|
||||
}> {
|
||||
try {
|
||||
const isPinned = await this.ipfsClient.isPinned(cid)
|
||||
|
||||
// Try to retrieve to check existence
|
||||
let exists = false
|
||||
let size: number | undefined
|
||||
|
||||
try {
|
||||
const data = await this.retrieveEnclaveData(cid)
|
||||
exists = true
|
||||
size = data.length
|
||||
} catch {
|
||||
// Data doesn't exist or is not accessible
|
||||
}
|
||||
|
||||
return {
|
||||
exists,
|
||||
isPinned,
|
||||
size
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Failed to get enclave status:', error)
|
||||
return {
|
||||
exists: false,
|
||||
isPinned: false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate enclave data structure
|
||||
*/
|
||||
private validateEnclaveData(data: EnclaveDataWithCID): void {
|
||||
if (!data.publicKey) {
|
||||
throw new Error('Public key is required for enclave data')
|
||||
}
|
||||
|
||||
if (!data.privateKeyShares || data.privateKeyShares.length === 0) {
|
||||
throw new Error('Private key shares are required for enclave data')
|
||||
}
|
||||
|
||||
if (data.threshold < 1 || data.threshold > data.parties) {
|
||||
throw new Error('Invalid threshold value')
|
||||
}
|
||||
|
||||
if (data.parties !== data.privateKeyShares.length) {
|
||||
throw new Error('Number of parties must match number of key shares')
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare enclave payload for storage
|
||||
*/
|
||||
private prepareEnclavePayload(
|
||||
enclaveData: EnclaveDataWithCID,
|
||||
privateKeyShares: Uint8Array[]
|
||||
): Uint8Array {
|
||||
// Create JSON representation
|
||||
const payload = {
|
||||
publicKey: enclaveData.publicKey,
|
||||
privateKeyShares: privateKeyShares.map(share =>
|
||||
Buffer.from(share).toString('base64')
|
||||
),
|
||||
threshold: enclaveData.threshold,
|
||||
parties: enclaveData.parties,
|
||||
encryptionMetadata: enclaveData.encryptionMetadata
|
||||
}
|
||||
|
||||
// Convert to bytes
|
||||
const jsonString = JSON.stringify(payload)
|
||||
return new TextEncoder().encode(jsonString)
|
||||
}
|
||||
|
||||
/**
|
||||
* Encrypt payload (placeholder - actual implementation would use consensus keys)
|
||||
*/
|
||||
private async encryptPayload(
|
||||
payload: Uint8Array,
|
||||
encryptionKey: Uint8Array
|
||||
): Promise<Uint8Array> {
|
||||
// TODO: Implement actual consensus-based encryption
|
||||
// For now, return the payload as-is
|
||||
// In production, this would use the consensus encryption key
|
||||
return payload
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a timeout promise
|
||||
*/
|
||||
private createTimeoutPromise(): Promise<null> {
|
||||
if (!this.config.operationTimeout) {
|
||||
return new Promise(() => {}) // Never resolves
|
||||
}
|
||||
|
||||
return new Promise((resolve) => {
|
||||
setTimeout(() => resolve(null), this.config.operationTimeout)
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Delay helper for retry logic
|
||||
*/
|
||||
private delay(ms: number): Promise<void> {
|
||||
return new Promise(resolve => setTimeout(resolve, ms))
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Factory function to create an enclave manager
|
||||
*/
|
||||
export async function createEnclaveIPFSManager(
|
||||
ipfsClient: IPFSClient,
|
||||
config?: Partial<EnclaveStorageConfig>
|
||||
): Promise<EnclaveIPFSManager> {
|
||||
if (!ipfsClient.isInitialized()) {
|
||||
throw new Error('IPFS client must be initialized before creating enclave manager')
|
||||
}
|
||||
|
||||
return new EnclaveIPFSManager(ipfsClient, config)
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
/**
|
||||
* Vault client module for interacting with the MPC-based vault WASM module
|
||||
*
|
||||
* This module provides secure key management and cryptographic operations
|
||||
* through a WebAssembly-based vault that uses Multi-Party Computation (MPC)
|
||||
* for enhanced security.
|
||||
*
|
||||
* Now includes IPFS integration for distributed enclave data storage.
|
||||
*/
|
||||
|
||||
export * from './types';
|
||||
export * from './client';
|
||||
export * from './loader';
|
||||
export * from './storage';
|
||||
|
||||
// IPFS-enhanced components
|
||||
export * from './client-ipfs';
|
||||
export * from './enclave';
|
||||
@@ -0,0 +1,201 @@
|
||||
/**
|
||||
* WASM loader utilities for the vault module
|
||||
*/
|
||||
|
||||
import { VaultError, VaultErrorCode } from './types';
|
||||
|
||||
/**
|
||||
* Options for loading WASM module
|
||||
*/
|
||||
export interface WASMLoadOptions {
|
||||
/** URL to load WASM from */
|
||||
url?: string;
|
||||
/** Use CDN for loading (jsDelivr) */
|
||||
useCDN?: boolean;
|
||||
/** Package version for CDN loading */
|
||||
version?: string;
|
||||
/** Timeout for loading in milliseconds */
|
||||
timeout?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Default CDN configuration
|
||||
*/
|
||||
const CDN_BASE = 'https://cdn.jsdelivr.net/npm/@sonr.io/es';
|
||||
const DEFAULT_TIMEOUT = 30000; // 30 seconds
|
||||
|
||||
/**
|
||||
* Load vault WASM module
|
||||
*/
|
||||
export async function loadVaultWASM(options: WASMLoadOptions = {}): Promise<ArrayBuffer> {
|
||||
const {
|
||||
url,
|
||||
useCDN = false,
|
||||
version = 'latest',
|
||||
timeout = DEFAULT_TIMEOUT,
|
||||
} = options;
|
||||
|
||||
let wasmUrl: string;
|
||||
|
||||
if (url) {
|
||||
// Use provided URL
|
||||
wasmUrl = url;
|
||||
} else if (useCDN) {
|
||||
// Use jsDelivr CDN
|
||||
wasmUrl = `${CDN_BASE}@${version}/dist/plugins/vault/plugin.wasm`;
|
||||
} else {
|
||||
// Use local path
|
||||
wasmUrl = '/plugin.wasm';
|
||||
}
|
||||
|
||||
try {
|
||||
const controller = new AbortController();
|
||||
const timeoutId = setTimeout(() => controller.abort(), timeout);
|
||||
|
||||
const response = await fetch(wasmUrl, {
|
||||
signal: controller.signal,
|
||||
headers: {
|
||||
'Accept': 'application/wasm',
|
||||
},
|
||||
});
|
||||
|
||||
clearTimeout(timeoutId);
|
||||
|
||||
if (!response.ok) {
|
||||
throw new Error(`Failed to load WASM: ${response.status} ${response.statusText}`);
|
||||
}
|
||||
|
||||
const contentType = response.headers.get('content-type');
|
||||
if (contentType && !contentType.includes('wasm') && !contentType.includes('octet-stream')) {
|
||||
console.warn(`Unexpected content type for WASM: ${contentType}`);
|
||||
}
|
||||
|
||||
return await response.arrayBuffer();
|
||||
} catch (error: any) {
|
||||
if (error.name === 'AbortError') {
|
||||
throw new VaultError(
|
||||
VaultErrorCode.TIMEOUT,
|
||||
`WASM loading timed out after ${timeout}ms`,
|
||||
{ url: wasmUrl }
|
||||
);
|
||||
}
|
||||
|
||||
throw new VaultError(
|
||||
VaultErrorCode.WASM_NOT_LOADED,
|
||||
`Failed to load WASM from ${wasmUrl}: ${error.message}`,
|
||||
error
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify WASM module is valid
|
||||
*/
|
||||
export async function verifyWASM(wasmBuffer: ArrayBuffer): Promise<boolean> {
|
||||
try {
|
||||
// Check WASM magic number (0x00 0x61 0x73 0x6D)
|
||||
const view = new DataView(wasmBuffer);
|
||||
const magic = view.getUint32(0, true);
|
||||
|
||||
if (magic !== 0x6D736100) {
|
||||
throw new Error('Invalid WASM magic number');
|
||||
}
|
||||
|
||||
// Try to compile the module
|
||||
await WebAssembly.compile(wasmBuffer);
|
||||
|
||||
return true;
|
||||
} catch (error) {
|
||||
console.error('WASM verification failed:', error);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get WASM module info
|
||||
*/
|
||||
export async function getWASMInfo(wasmBuffer: ArrayBuffer): Promise<{
|
||||
size: number;
|
||||
exports: string[];
|
||||
imports: string[];
|
||||
}> {
|
||||
const module = await WebAssembly.compile(wasmBuffer);
|
||||
|
||||
const exports = WebAssembly.Module.exports(module).map(exp => exp.name);
|
||||
const imports = WebAssembly.Module.imports(module).map(imp => `${imp.module}.${imp.name}`);
|
||||
|
||||
return {
|
||||
size: wasmBuffer.byteLength,
|
||||
exports,
|
||||
imports,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Cache for loaded WASM modules
|
||||
*/
|
||||
class WASMCache {
|
||||
private cache = new Map<string, ArrayBuffer>();
|
||||
|
||||
set(key: string, buffer: ArrayBuffer): void {
|
||||
this.cache.set(key, buffer);
|
||||
}
|
||||
|
||||
get(key: string): ArrayBuffer | undefined {
|
||||
return this.cache.get(key);
|
||||
}
|
||||
|
||||
has(key: string): boolean {
|
||||
return this.cache.has(key);
|
||||
}
|
||||
|
||||
clear(): void {
|
||||
this.cache.clear();
|
||||
}
|
||||
|
||||
remove(key: string): boolean {
|
||||
return this.cache.delete(key);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Global WASM cache instance
|
||||
*/
|
||||
export const wasmCache = new WASMCache();
|
||||
|
||||
/**
|
||||
* Load WASM with caching
|
||||
*/
|
||||
export async function loadVaultWASMCached(
|
||||
cacheKey: string,
|
||||
options: WASMLoadOptions = {}
|
||||
): Promise<ArrayBuffer> {
|
||||
// Check cache first
|
||||
if (wasmCache.has(cacheKey)) {
|
||||
const cached = wasmCache.get(cacheKey);
|
||||
if (cached) {
|
||||
return cached;
|
||||
}
|
||||
}
|
||||
|
||||
// Load WASM
|
||||
const wasmBuffer = await loadVaultWASM(options);
|
||||
|
||||
// Verify and cache
|
||||
if (await verifyWASM(wasmBuffer)) {
|
||||
wasmCache.set(cacheKey, wasmBuffer);
|
||||
}
|
||||
|
||||
return wasmBuffer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Preload vault WASM module for faster initialization
|
||||
*/
|
||||
export async function preloadVaultWASM(options: WASMLoadOptions = {}): Promise<void> {
|
||||
try {
|
||||
await loadVaultWASMCached('vault-default', options);
|
||||
} catch (error) {
|
||||
console.error('Failed to preload vault WASM:', error);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,586 @@
|
||||
/**
|
||||
* End-to-end tests for Dexie.js integration with VaultClient
|
||||
* Tests real IndexedDB functionality without mocks
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, beforeAll, afterAll, vi } from 'vitest';
|
||||
|
||||
// Setup fake IndexedDB for Node.js environment BEFORE importing Dexie
|
||||
import 'fake-indexeddb/auto';
|
||||
import FDBFactory from 'fake-indexeddb/lib/FDBFactory';
|
||||
import FDBKeyRange from 'fake-indexeddb/lib/FDBKeyRange';
|
||||
|
||||
// Set up globals before Dexie import
|
||||
globalThis.indexedDB = new FDBFactory();
|
||||
globalThis.IDBKeyRange = FDBKeyRange;
|
||||
|
||||
import Dexie from 'dexie';
|
||||
import { VaultStorageManager, AccountVaultDatabase } from './storage';
|
||||
import { VaultClient, createVaultClient } from './client';
|
||||
import type { StoredVaultState, StoredUCANToken, VaultStorageConfig } from './types';
|
||||
|
||||
describe('VaultClient with Dexie.js Storage - End to End', () => {
|
||||
let storageManager: VaultStorageManager;
|
||||
let vaultClient: VaultClient;
|
||||
const testAccount1 = 'sonr1testaccount123';
|
||||
const testAccount2 = 'sonr1testaccount456';
|
||||
|
||||
beforeAll(async () => {
|
||||
// Clean up any existing test databases
|
||||
const dbs = await Dexie.getDatabaseNames();
|
||||
for (const dbName of dbs) {
|
||||
if (dbName.startsWith('vault_')) {
|
||||
await Dexie.delete(dbName);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Final cleanup
|
||||
const dbs = await Dexie.getDatabaseNames();
|
||||
for (const dbName of dbs) {
|
||||
if (dbName.startsWith('vault_')) {
|
||||
await Dexie.delete(dbName);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
describe('Storage Manager Initialization', () => {
|
||||
it('should create storage manager with default config', () => {
|
||||
const manager = new VaultStorageManager();
|
||||
expect(manager).toBeInstanceOf(VaultStorageManager);
|
||||
});
|
||||
|
||||
it('should create storage manager with custom config', () => {
|
||||
const config: VaultStorageConfig = {
|
||||
enablePersistence: true,
|
||||
autoCleanup: false,
|
||||
cleanupInterval: 5000,
|
||||
};
|
||||
const manager = new VaultStorageManager(config);
|
||||
expect(manager).toBeInstanceOf(VaultStorageManager);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Database Lifecycle', () => {
|
||||
beforeEach(() => {
|
||||
storageManager = new VaultStorageManager({
|
||||
autoCleanup: false, // Disable for predictable tests
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await storageManager.closeAll();
|
||||
});
|
||||
|
||||
it('should create a new database for an account', async () => {
|
||||
const db = await storageManager.getDatabase(testAccount1);
|
||||
|
||||
expect(db).toBeInstanceOf(AccountVaultDatabase);
|
||||
expect(db.name).toBe(`vault_${testAccount1}`);
|
||||
expect(db.isOpen()).toBe(true);
|
||||
});
|
||||
|
||||
it('should reuse existing database for same account', async () => {
|
||||
const db1 = await storageManager.getDatabase(testAccount1);
|
||||
const db2 = await storageManager.getDatabase(testAccount1);
|
||||
|
||||
expect(db1).toBe(db2);
|
||||
expect(db1.isOpen()).toBe(true);
|
||||
});
|
||||
|
||||
it('should create separate databases for different accounts', async () => {
|
||||
const db1 = await storageManager.getDatabase(testAccount1);
|
||||
const db2 = await storageManager.getDatabase(testAccount2);
|
||||
|
||||
expect(db1).not.toBe(db2);
|
||||
expect(db1.name).toBe(`vault_${testAccount1}`);
|
||||
expect(db2.name).toBe(`vault_${testAccount2}`);
|
||||
});
|
||||
|
||||
it('should list all persisted accounts', async () => {
|
||||
await storageManager.getDatabase(testAccount1);
|
||||
await storageManager.getDatabase(testAccount2);
|
||||
|
||||
const accounts = await storageManager.listPersistedAccounts();
|
||||
|
||||
expect(accounts).toContain(testAccount1);
|
||||
expect(accounts).toContain(testAccount2);
|
||||
});
|
||||
|
||||
it('should remove database for an account', async () => {
|
||||
await storageManager.getDatabase(testAccount1);
|
||||
|
||||
let accounts = await storageManager.listPersistedAccounts();
|
||||
expect(accounts).toContain(testAccount1);
|
||||
|
||||
await storageManager.removeDatabase(testAccount1);
|
||||
|
||||
accounts = await storageManager.listPersistedAccounts();
|
||||
expect(accounts).not.toContain(testAccount1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('VaultClient Integration', () => {
|
||||
beforeEach(async () => {
|
||||
// Clean up any existing databases before each test
|
||||
const dbs = await Dexie.getDatabaseNames();
|
||||
for (const dbName of dbs) {
|
||||
if (dbName.startsWith('vault_')) {
|
||||
await Dexie.delete(dbName);
|
||||
}
|
||||
}
|
||||
|
||||
vaultClient = createVaultClient({
|
||||
enablePersistence: true,
|
||||
autoCleanup: false,
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await vaultClient.cleanup();
|
||||
|
||||
// Clean up databases after each test
|
||||
const dbs = await Dexie.getDatabaseNames();
|
||||
for (const dbName of dbs) {
|
||||
if (dbName.startsWith('vault_')) {
|
||||
await Dexie.delete(dbName);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should initialize vault with persistence enabled', async () => {
|
||||
// Initialize without WASM (will fail but storage should work)
|
||||
try {
|
||||
await vaultClient.initialize('/fake/path.wasm', testAccount1);
|
||||
} catch (error) {
|
||||
// Expected to fail due to missing WASM
|
||||
}
|
||||
|
||||
// Storage should still be initialized
|
||||
const accounts = await vaultClient.listPersistedAccounts();
|
||||
expect(accounts).toContain(testAccount1);
|
||||
});
|
||||
|
||||
it('should persist and load vault state', async () => {
|
||||
try {
|
||||
await vaultClient.initialize('/fake/path.wasm', testAccount1);
|
||||
} catch (error) {
|
||||
// Expected
|
||||
}
|
||||
|
||||
// Persist state
|
||||
await vaultClient.persistState();
|
||||
|
||||
// Load state
|
||||
const state = await vaultClient.loadPersistedState();
|
||||
expect(state).toBeDefined();
|
||||
expect(state?.accountAddress).toBe(testAccount1);
|
||||
expect(state?.isInitialized).toBe(false); // WASM not loaded
|
||||
});
|
||||
|
||||
it('should save and retrieve tokens', async () => {
|
||||
try {
|
||||
await vaultClient.initialize('/fake/path.wasm', testAccount1);
|
||||
} catch (error) {
|
||||
// Expected
|
||||
}
|
||||
|
||||
// Save a mock token
|
||||
const mockToken = {
|
||||
token: 'eyJ0eXAiOiJKV1QiLCJhbGciOiJFZERTQSJ9...',
|
||||
issuer: 'did:sonr:123',
|
||||
address: testAccount1,
|
||||
};
|
||||
|
||||
await vaultClient.saveToken(mockToken);
|
||||
|
||||
// Retrieve tokens
|
||||
const tokens = await vaultClient.getPersistedTokens();
|
||||
expect(tokens).toHaveLength(1);
|
||||
expect(tokens[0].token).toBe(mockToken.token);
|
||||
expect(tokens[0].issuer).toBe(mockToken.issuer);
|
||||
});
|
||||
|
||||
it('should clear persisted state', async () => {
|
||||
try {
|
||||
await vaultClient.initialize('/fake/path.wasm', testAccount1);
|
||||
} catch (error) {
|
||||
// Expected
|
||||
}
|
||||
|
||||
// Add some data
|
||||
await vaultClient.persistState();
|
||||
await vaultClient.saveToken({
|
||||
token: 'test-token',
|
||||
issuer: 'did:test',
|
||||
address: testAccount1,
|
||||
});
|
||||
|
||||
// Verify data exists
|
||||
let state = await vaultClient.loadPersistedState();
|
||||
let tokens = await vaultClient.getPersistedTokens();
|
||||
expect(state).toBeDefined();
|
||||
expect(tokens).toHaveLength(1);
|
||||
|
||||
// Clear all data
|
||||
await vaultClient.clearPersistedState();
|
||||
|
||||
// Verify data is cleared
|
||||
state = await vaultClient.loadPersistedState();
|
||||
tokens = await vaultClient.getPersistedTokens();
|
||||
expect(state).toBeNull();
|
||||
expect(tokens).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Multi-Account Support', () => {
|
||||
beforeEach(async () => {
|
||||
// Clean up any existing databases before each test
|
||||
const dbs = await Dexie.getDatabaseNames();
|
||||
for (const dbName of dbs) {
|
||||
if (dbName.startsWith('vault_')) {
|
||||
await Dexie.delete(dbName);
|
||||
}
|
||||
}
|
||||
|
||||
vaultClient = createVaultClient({
|
||||
enablePersistence: true,
|
||||
autoCleanup: false,
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await vaultClient.cleanup();
|
||||
|
||||
// Clean up databases after each test
|
||||
const dbs = await Dexie.getDatabaseNames();
|
||||
for (const dbName of dbs) {
|
||||
if (dbName.startsWith('vault_')) {
|
||||
await Dexie.delete(dbName);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should switch between accounts', async () => {
|
||||
// Initialize with account 1
|
||||
try {
|
||||
await vaultClient.initialize('/fake/path.wasm', testAccount1);
|
||||
} catch (error) {
|
||||
// Expected
|
||||
}
|
||||
|
||||
// Save token for account 1
|
||||
await vaultClient.saveToken({
|
||||
token: 'token-account1',
|
||||
issuer: 'did:account1',
|
||||
address: testAccount1,
|
||||
});
|
||||
|
||||
// Switch to account 2
|
||||
await vaultClient.switchAccount(testAccount2);
|
||||
|
||||
// Save token for account 2
|
||||
await vaultClient.saveToken({
|
||||
token: 'token-account2',
|
||||
issuer: 'did:account2',
|
||||
address: testAccount2,
|
||||
});
|
||||
|
||||
// Verify account 2 has its own token
|
||||
let tokens = await vaultClient.getPersistedTokens();
|
||||
expect(tokens).toHaveLength(1);
|
||||
expect(tokens[0].token).toBe('token-account2');
|
||||
|
||||
// Switch back to account 1
|
||||
await vaultClient.switchAccount(testAccount1);
|
||||
|
||||
// Verify account 1 still has its token
|
||||
tokens = await vaultClient.getPersistedTokens();
|
||||
expect(tokens).toHaveLength(1);
|
||||
expect(tokens[0].token).toBe('token-account1');
|
||||
});
|
||||
|
||||
it('should maintain separate databases for each account', async () => {
|
||||
// Initialize with account 1
|
||||
try {
|
||||
await vaultClient.initialize('/fake/path.wasm', testAccount1);
|
||||
} catch (error) {
|
||||
// Expected
|
||||
}
|
||||
|
||||
await vaultClient.persistState();
|
||||
await vaultClient.saveToken({
|
||||
token: 'account1-token',
|
||||
issuer: 'did:1',
|
||||
address: testAccount1,
|
||||
});
|
||||
|
||||
// Switch to account 2
|
||||
await vaultClient.switchAccount(testAccount2);
|
||||
await vaultClient.persistState();
|
||||
await vaultClient.saveToken({
|
||||
token: 'account2-token',
|
||||
issuer: 'did:2',
|
||||
address: testAccount2,
|
||||
});
|
||||
|
||||
// List all accounts
|
||||
const accounts = await vaultClient.listPersistedAccounts();
|
||||
expect(accounts).toContain(testAccount1);
|
||||
expect(accounts).toContain(testAccount2);
|
||||
|
||||
// Remove account 1
|
||||
await vaultClient.removeAccount(testAccount1);
|
||||
|
||||
// Verify account 1 is removed but account 2 remains
|
||||
const remainingAccounts = await vaultClient.listPersistedAccounts();
|
||||
expect(remainingAccounts).not.toContain(testAccount1);
|
||||
expect(remainingAccounts).toContain(testAccount2);
|
||||
|
||||
// Account 2 data should still be accessible
|
||||
const tokens = await vaultClient.getPersistedTokens();
|
||||
expect(tokens).toHaveLength(1);
|
||||
expect(tokens[0].token).toBe('account2-token');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Token Expiration and Cleanup', () => {
|
||||
let db: AccountVaultDatabase;
|
||||
|
||||
beforeEach(async () => {
|
||||
storageManager = new VaultStorageManager({
|
||||
autoCleanup: false,
|
||||
});
|
||||
db = await storageManager.getDatabase(testAccount1);
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await storageManager.closeAll();
|
||||
});
|
||||
|
||||
it('should store tokens with expiration', async () => {
|
||||
const now = Date.now();
|
||||
const expiredToken: StoredUCANToken = {
|
||||
id: 'token1',
|
||||
token: 'expired-token',
|
||||
type: 'origin',
|
||||
issuer: 'did:expired',
|
||||
audience: testAccount1,
|
||||
expiresAt: now - 1000, // Expired 1 second ago
|
||||
createdAt: now - 10000,
|
||||
};
|
||||
|
||||
const validToken: StoredUCANToken = {
|
||||
id: 'token2',
|
||||
token: 'valid-token',
|
||||
type: 'origin',
|
||||
issuer: 'did:valid',
|
||||
audience: testAccount1,
|
||||
expiresAt: now + 10000, // Expires in 10 seconds
|
||||
createdAt: now,
|
||||
};
|
||||
|
||||
await db.tokens.bulkAdd([expiredToken, validToken]);
|
||||
|
||||
// Verify both tokens are stored
|
||||
let tokens = await db.tokens.toArray();
|
||||
expect(tokens).toHaveLength(2);
|
||||
|
||||
// Clean up expired tokens
|
||||
await storageManager.cleanupExpiredData();
|
||||
|
||||
// Verify only valid token remains
|
||||
tokens = await db.tokens.toArray();
|
||||
expect(tokens).toHaveLength(1);
|
||||
expect(tokens[0].id).toBe('token2');
|
||||
});
|
||||
|
||||
it('should clean up expired sessions', async () => {
|
||||
const now = Date.now();
|
||||
|
||||
await db.sessions.add({
|
||||
id: 'session1',
|
||||
accountAddress: testAccount1,
|
||||
sessionData: 'expired-session',
|
||||
expiresAt: now - 1000,
|
||||
createdAt: now - 10000,
|
||||
});
|
||||
|
||||
await db.sessions.add({
|
||||
id: 'session2',
|
||||
accountAddress: testAccount1,
|
||||
sessionData: 'valid-session',
|
||||
expiresAt: now + 10000,
|
||||
createdAt: now,
|
||||
});
|
||||
|
||||
// Verify both sessions are stored
|
||||
let sessions = await db.sessions.toArray();
|
||||
expect(sessions).toHaveLength(2);
|
||||
|
||||
// Clean up expired sessions
|
||||
await storageManager.cleanupExpiredData();
|
||||
|
||||
// Verify only valid session remains
|
||||
sessions = await db.sessions.toArray();
|
||||
expect(sessions).toHaveLength(1);
|
||||
expect(sessions[0].id).toBe('session2');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Storage Persistence API', () => {
|
||||
beforeEach(() => {
|
||||
storageManager = new VaultStorageManager({
|
||||
enablePersistence: true,
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await storageManager.closeAll();
|
||||
});
|
||||
|
||||
it('should handle storage persistence status', async () => {
|
||||
// In test environment, these will return false/never
|
||||
const isPersisted = await storageManager.isStoragePersisted();
|
||||
expect(typeof isPersisted).toBe('boolean');
|
||||
|
||||
const status = await storageManager.tryPersistWithoutPromptingUser();
|
||||
expect(['persisted', 'prompt', 'never']).toContain(status);
|
||||
});
|
||||
|
||||
it('should handle storage estimate', async () => {
|
||||
const estimate = await storageManager.getStorageEstimate();
|
||||
// In test environment, this might return null
|
||||
if (estimate) {
|
||||
expect(estimate).toHaveProperty('usage');
|
||||
expect(estimate).toHaveProperty('quota');
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Database Schema and Tables', () => {
|
||||
let db: AccountVaultDatabase;
|
||||
|
||||
beforeEach(async () => {
|
||||
db = new AccountVaultDatabase(testAccount1);
|
||||
await db.open();
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await db.close();
|
||||
await db.delete();
|
||||
});
|
||||
|
||||
it('should have correct table structure', () => {
|
||||
expect(db.state).toBeDefined();
|
||||
expect(db.tokens).toBeDefined();
|
||||
expect(db.sessions).toBeDefined();
|
||||
expect(db.metadata).toBeDefined();
|
||||
});
|
||||
|
||||
it('should store and retrieve state', async () => {
|
||||
const state: StoredVaultState = {
|
||||
id: 'current',
|
||||
accountAddress: testAccount1,
|
||||
isInitialized: true,
|
||||
enclave: JSON.stringify({ test: 'data' }),
|
||||
lastAccessed: Date.now(),
|
||||
createdAt: Date.now(),
|
||||
};
|
||||
|
||||
await db.state.put(state);
|
||||
const retrieved = await db.state.get('current');
|
||||
|
||||
expect(retrieved).toBeDefined();
|
||||
expect(retrieved?.accountAddress).toBe(testAccount1);
|
||||
expect(retrieved?.isInitialized).toBe(true);
|
||||
});
|
||||
|
||||
it('should store and retrieve metadata', async () => {
|
||||
await db.metadata.add({
|
||||
id: 'meta1',
|
||||
accountAddress: testAccount1,
|
||||
key: 'theme',
|
||||
value: 'dark',
|
||||
updatedAt: Date.now(),
|
||||
});
|
||||
|
||||
const metadata = await db.metadata.toArray();
|
||||
expect(metadata).toHaveLength(1);
|
||||
expect(metadata[0].key).toBe('theme');
|
||||
expect(metadata[0].value).toBe('dark');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Error Handling', () => {
|
||||
beforeEach(() => {
|
||||
storageManager = new VaultStorageManager();
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await storageManager.closeAll();
|
||||
});
|
||||
|
||||
it('should handle invalid account address', async () => {
|
||||
await expect(storageManager.getDatabase('')).rejects.toThrow('Account address is required');
|
||||
await expect(storageManager.getDatabase(null as any)).rejects.toThrow('Account address is required');
|
||||
});
|
||||
|
||||
it('should handle database errors gracefully', async () => {
|
||||
const db = await storageManager.getDatabase(testAccount1);
|
||||
|
||||
// Close the database
|
||||
await db.close();
|
||||
|
||||
// Try to perform operations on closed database
|
||||
try {
|
||||
await db.state.toArray();
|
||||
} catch (error: any) {
|
||||
expect(error).toBeDefined();
|
||||
expect(error.message).toContain('closed');
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Backward Compatibility', () => {
|
||||
it('should work without persistence enabled', () => {
|
||||
const client = createVaultClient({
|
||||
enablePersistence: false,
|
||||
});
|
||||
|
||||
expect(client).toBeInstanceOf(VaultClient);
|
||||
expect(client.isReady()).toBe(false);
|
||||
});
|
||||
|
||||
it('should work with default configuration', () => {
|
||||
const client = createVaultClient();
|
||||
|
||||
expect(client).toBeInstanceOf(VaultClient);
|
||||
expect(client.isReady()).toBe(false);
|
||||
});
|
||||
|
||||
it('should not persist when disabled', async () => {
|
||||
const client = createVaultClient({
|
||||
enablePersistence: false,
|
||||
});
|
||||
|
||||
try {
|
||||
await client.initialize('/fake/path.wasm');
|
||||
} catch (error) {
|
||||
// Expected
|
||||
}
|
||||
|
||||
// These methods should return empty/null when persistence is disabled
|
||||
const state = await client.loadPersistedState();
|
||||
const tokens = await client.getPersistedTokens();
|
||||
const accounts = await client.listPersistedAccounts();
|
||||
|
||||
expect(state).toBeNull();
|
||||
expect(tokens).toHaveLength(0);
|
||||
expect(accounts).toHaveLength(0);
|
||||
|
||||
await client.cleanup();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,234 @@
|
||||
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
||||
import { VaultStorageManager, AccountVaultDatabase } from './storage';
|
||||
import type { StoredVaultState, StoredUCANToken, VaultStorageConfig } from './types';
|
||||
import Dexie from 'dexie';
|
||||
|
||||
describe('VaultStorageManager', () => {
|
||||
let storageManager: VaultStorageManager;
|
||||
const testAccountAddress = 'sonr1test123abc';
|
||||
|
||||
beforeEach(() => {
|
||||
storageManager = new VaultStorageManager({
|
||||
enablePersistence: true,
|
||||
autoCleanup: false, // Disable auto cleanup for tests
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await storageManager.closeAll();
|
||||
});
|
||||
|
||||
describe('Database Management', () => {
|
||||
it('should create a database for an account', async () => {
|
||||
const db = await storageManager.getDatabase(testAccountAddress);
|
||||
expect(db).toBeDefined();
|
||||
expect(db).toBeInstanceOf(AccountVaultDatabase);
|
||||
});
|
||||
|
||||
it('should reuse existing database for the same account', async () => {
|
||||
const db1 = await storageManager.getDatabase(testAccountAddress);
|
||||
const db2 = await storageManager.getDatabase(testAccountAddress);
|
||||
expect(db1).toBe(db2);
|
||||
});
|
||||
|
||||
it('should create separate databases for different accounts', async () => {
|
||||
const account1 = 'sonr1account1';
|
||||
const account2 = 'sonr1account2';
|
||||
|
||||
const db1 = await storageManager.getDatabase(account1);
|
||||
const db2 = await storageManager.getDatabase(account2);
|
||||
|
||||
expect(db1).not.toBe(db2);
|
||||
});
|
||||
|
||||
it('should throw error when account address is not provided', async () => {
|
||||
await expect(storageManager.getDatabase('')).rejects.toThrow('Account address is required');
|
||||
});
|
||||
|
||||
it('should remove a database for an account', async () => {
|
||||
const db = await storageManager.getDatabase(testAccountAddress);
|
||||
expect(db).toBeDefined();
|
||||
|
||||
await storageManager.removeDatabase(testAccountAddress);
|
||||
|
||||
// Getting the database again should create a new instance
|
||||
const newDb = await storageManager.getDatabase(testAccountAddress);
|
||||
expect(newDb).not.toBe(db);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Storage Persistence', () => {
|
||||
it('should request persistent storage when enabled', async () => {
|
||||
const mockPersist = vi.fn().mockResolvedValue(true);
|
||||
Object.defineProperty(global, 'navigator', {
|
||||
value: {
|
||||
storage: {
|
||||
persist: mockPersist,
|
||||
},
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
const result = await storageManager.requestPersistentStorage();
|
||||
expect(result).toBe(true);
|
||||
expect(mockPersist).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should handle missing storage API gracefully', async () => {
|
||||
Object.defineProperty(global, 'navigator', {
|
||||
value: {},
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
const result = await storageManager.requestPersistentStorage();
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
|
||||
it('should check if storage is persisted', async () => {
|
||||
const mockPersisted = vi.fn().mockResolvedValue(true);
|
||||
Object.defineProperty(global, 'navigator', {
|
||||
value: {
|
||||
storage: {
|
||||
persisted: mockPersisted,
|
||||
},
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
const result = await storageManager.isStoragePersisted();
|
||||
expect(result).toBe(true);
|
||||
expect(mockPersisted).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should get storage estimate', async () => {
|
||||
const mockEstimate = {
|
||||
usage: 1024 * 1024 * 10, // 10MB
|
||||
quota: 1024 * 1024 * 100, // 100MB
|
||||
};
|
||||
|
||||
Object.defineProperty(global, 'navigator', {
|
||||
value: {
|
||||
storage: {
|
||||
estimate: vi.fn().mockResolvedValue(mockEstimate),
|
||||
},
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
const estimate = await storageManager.getStorageEstimate();
|
||||
expect(estimate).toEqual(mockEstimate);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Cleanup Operations', () => {
|
||||
it('should clean up expired data', async () => {
|
||||
const db = await storageManager.getDatabase(testAccountAddress);
|
||||
|
||||
// Mock the database tables
|
||||
const mockTokensDelete = vi.fn().mockResolvedValue(2);
|
||||
const mockSessionsDelete = vi.fn().mockResolvedValue(1);
|
||||
const mockStateModify = vi.fn().mockResolvedValue(1);
|
||||
|
||||
db.tokens = {
|
||||
where: vi.fn().mockReturnThis(),
|
||||
below: vi.fn().mockReturnThis(),
|
||||
delete: mockTokensDelete,
|
||||
} as any;
|
||||
|
||||
db.sessions = {
|
||||
where: vi.fn().mockReturnThis(),
|
||||
below: vi.fn().mockReturnThis(),
|
||||
delete: mockSessionsDelete,
|
||||
} as any;
|
||||
|
||||
db.state = {
|
||||
where: vi.fn().mockReturnThis(),
|
||||
equals: vi.fn().mockReturnThis(),
|
||||
modify: mockStateModify,
|
||||
} as any;
|
||||
|
||||
await storageManager.cleanupExpiredData();
|
||||
|
||||
expect(mockTokensDelete).toHaveBeenCalled();
|
||||
expect(mockSessionsDelete).toHaveBeenCalled();
|
||||
expect(mockStateModify).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should close all databases', async () => {
|
||||
const db1 = await storageManager.getDatabase('account1');
|
||||
const db2 = await storageManager.getDatabase('account2');
|
||||
|
||||
const mockClose1 = vi.fn();
|
||||
const mockClose2 = vi.fn();
|
||||
|
||||
db1.close = mockClose1;
|
||||
db2.close = mockClose2;
|
||||
|
||||
await storageManager.closeAll();
|
||||
|
||||
expect(mockClose1).toHaveBeenCalled();
|
||||
expect(mockClose2).toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Persistence Status', () => {
|
||||
it('should return "persisted" when storage is already persisted', async () => {
|
||||
Object.defineProperty(global, 'navigator', {
|
||||
value: {
|
||||
storage: {
|
||||
persisted: vi.fn().mockResolvedValue(true),
|
||||
persist: vi.fn().mockResolvedValue(true),
|
||||
},
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
const status = await storageManager.tryPersistWithoutPromptingUser();
|
||||
expect(status).toBe('persisted');
|
||||
});
|
||||
|
||||
it('should return "prompt" when persistence requires user interaction', async () => {
|
||||
Object.defineProperty(global, 'navigator', {
|
||||
value: {
|
||||
storage: {
|
||||
persisted: vi.fn().mockResolvedValue(false),
|
||||
persist: vi.fn().mockResolvedValue(false),
|
||||
},
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
const status = await storageManager.tryPersistWithoutPromptingUser();
|
||||
expect(status).toBe('prompt');
|
||||
});
|
||||
|
||||
it('should return "never" when storage API is not available', async () => {
|
||||
Object.defineProperty(global, 'navigator', {
|
||||
value: {},
|
||||
configurable: true,
|
||||
});
|
||||
|
||||
const status = await storageManager.tryPersistWithoutPromptingUser();
|
||||
expect(status).toBe('never');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('AccountVaultDatabase', () => {
|
||||
const testAccountAddress = 'sonr1test123abc';
|
||||
|
||||
it('should create database with correct name', () => {
|
||||
const db = new AccountVaultDatabase(testAccountAddress);
|
||||
expect(db.name).toBe(`vault_${testAccountAddress}`);
|
||||
});
|
||||
|
||||
it('should have correct table definitions', () => {
|
||||
const db = new AccountVaultDatabase(testAccountAddress);
|
||||
|
||||
// Verify table properties exist
|
||||
expect(db).toHaveProperty('state');
|
||||
expect(db).toHaveProperty('tokens');
|
||||
expect(db).toHaveProperty('sessions');
|
||||
expect(db).toHaveProperty('metadata');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,264 @@
|
||||
import Dexie, { type Table } from 'dexie';
|
||||
import type {
|
||||
StoredVaultState,
|
||||
StoredUCANToken,
|
||||
VaultStorageConfig
|
||||
} from './types';
|
||||
|
||||
/**
|
||||
* Session data stored in IndexedDB
|
||||
*/
|
||||
export interface StoredSession {
|
||||
id: string;
|
||||
accountAddress: string;
|
||||
sessionData: string;
|
||||
expiresAt: number;
|
||||
createdAt: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Metadata stored in IndexedDB
|
||||
*/
|
||||
export interface StoredMetadata {
|
||||
id: string;
|
||||
accountAddress: string;
|
||||
key: string;
|
||||
value: string;
|
||||
updatedAt: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Account-specific vault database
|
||||
*/
|
||||
export class AccountVaultDatabase extends Dexie {
|
||||
state!: Table<StoredVaultState>;
|
||||
tokens!: Table<StoredUCANToken>;
|
||||
sessions!: Table<StoredSession>;
|
||||
metadata!: Table<StoredMetadata>;
|
||||
|
||||
constructor(accountAddress: string) {
|
||||
super(`vault_${accountAddress}`);
|
||||
|
||||
// Define schema version 1
|
||||
this.version(1).stores({
|
||||
state: 'id, accountAddress, lastAccessed',
|
||||
tokens: 'id, type, issuer, audience, expiresAt, createdAt',
|
||||
sessions: 'id, accountAddress, expiresAt, createdAt',
|
||||
metadata: 'id, accountAddress, key, updatedAt'
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Manages vault storage for multiple accounts
|
||||
*/
|
||||
export class VaultStorageManager {
|
||||
private databases: Map<string, AccountVaultDatabase> = new Map();
|
||||
private config: VaultStorageConfig;
|
||||
private cleanupTimer?: NodeJS.Timeout;
|
||||
|
||||
constructor(config: VaultStorageConfig = {}) {
|
||||
this.config = {
|
||||
enablePersistence: false,
|
||||
autoCleanup: true,
|
||||
cleanupInterval: 3600000, // 1 hour
|
||||
...config
|
||||
};
|
||||
|
||||
if (this.config.autoCleanup) {
|
||||
this.startCleanupTimer();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get or create database for account
|
||||
*/
|
||||
async getDatabase(accountAddress: string): Promise<AccountVaultDatabase> {
|
||||
if (!accountAddress) {
|
||||
throw new Error('Account address is required');
|
||||
}
|
||||
|
||||
// Return existing database if available
|
||||
let db = this.databases.get(accountAddress);
|
||||
if (db) {
|
||||
return db;
|
||||
}
|
||||
|
||||
// Create new database for account
|
||||
db = new AccountVaultDatabase(accountAddress);
|
||||
await db.open();
|
||||
|
||||
this.databases.set(accountAddress, db);
|
||||
|
||||
// Request persistent storage if configured
|
||||
if (this.config.enablePersistence) {
|
||||
await this.requestPersistentStorage();
|
||||
}
|
||||
|
||||
return db;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove database for account
|
||||
*/
|
||||
async removeDatabase(accountAddress: string): Promise<void> {
|
||||
const db = this.databases.get(accountAddress);
|
||||
if (db) {
|
||||
await db.close();
|
||||
await db.delete();
|
||||
this.databases.delete(accountAddress);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* List all persisted accounts
|
||||
*/
|
||||
async listPersistedAccounts(): Promise<string[]> {
|
||||
const databases = await Dexie.getDatabaseNames();
|
||||
return databases
|
||||
.filter(name => name.startsWith('vault_'))
|
||||
.map(name => name.replace('vault_', ''));
|
||||
}
|
||||
|
||||
/**
|
||||
* Request persistent storage from browser
|
||||
*/
|
||||
async requestPersistentStorage(): Promise<boolean> {
|
||||
if ('storage' in navigator && 'persist' in navigator.storage) {
|
||||
try {
|
||||
return await navigator.storage.persist();
|
||||
} catch (error) {
|
||||
console.warn('Failed to request persistent storage:', error);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if storage is persisted
|
||||
*/
|
||||
async isStoragePersisted(): Promise<boolean> {
|
||||
if ('storage' in navigator && 'persisted' in navigator.storage) {
|
||||
try {
|
||||
return await navigator.storage.persisted();
|
||||
} catch (error) {
|
||||
console.warn('Failed to check storage persistence:', error);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get storage estimate
|
||||
*/
|
||||
async getStorageEstimate(): Promise<StorageEstimate | null> {
|
||||
if ('storage' in navigator && 'estimate' in navigator.storage) {
|
||||
try {
|
||||
return await navigator.storage.estimate();
|
||||
} catch (error) {
|
||||
console.warn('Failed to get storage estimate:', error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clean up expired tokens and sessions
|
||||
*/
|
||||
async cleanupExpiredData(): Promise<void> {
|
||||
const now = Date.now();
|
||||
|
||||
for (const [accountAddress, db] of this.databases.entries()) {
|
||||
try {
|
||||
// Remove expired tokens
|
||||
await db.tokens
|
||||
.where('expiresAt')
|
||||
.below(now)
|
||||
.delete();
|
||||
|
||||
// Remove expired sessions
|
||||
await db.sessions
|
||||
.where('expiresAt')
|
||||
.below(now)
|
||||
.delete();
|
||||
|
||||
// Update last accessed time for state
|
||||
await db.state.where('accountAddress').equals(accountAddress).modify({
|
||||
lastAccessed: now
|
||||
});
|
||||
} catch (error) {
|
||||
console.error(`Cleanup failed for account ${accountAddress}:`, error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Start automatic cleanup timer
|
||||
*/
|
||||
private startCleanupTimer(): void {
|
||||
if (this.cleanupTimer) {
|
||||
clearInterval(this.cleanupTimer);
|
||||
}
|
||||
|
||||
this.cleanupTimer = setInterval(async () => {
|
||||
await this.cleanupExpiredData();
|
||||
}, this.config.cleanupInterval!);
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop cleanup timer
|
||||
*/
|
||||
stopCleanupTimer(): void {
|
||||
if (this.cleanupTimer) {
|
||||
clearInterval(this.cleanupTimer);
|
||||
this.cleanupTimer = undefined;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Close all databases
|
||||
*/
|
||||
async closeAll(): Promise<void> {
|
||||
this.stopCleanupTimer();
|
||||
|
||||
for (const db of this.databases.values()) {
|
||||
await db.close();
|
||||
}
|
||||
|
||||
this.databases.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Try to persist storage without user prompt
|
||||
*/
|
||||
async tryPersistWithoutPromptingUser(): Promise<string> {
|
||||
if (!('storage' in navigator) || !('persist' in navigator.storage)) {
|
||||
return 'never';
|
||||
}
|
||||
|
||||
// Check if already persisted
|
||||
const persisted = await navigator.storage.persisted();
|
||||
if (persisted) {
|
||||
return 'persisted';
|
||||
}
|
||||
|
||||
// Try to persist without prompt
|
||||
const result = await navigator.storage.persist();
|
||||
if (result) {
|
||||
return 'persisted';
|
||||
}
|
||||
|
||||
return 'prompt';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Default storage manager instance
|
||||
*/
|
||||
export const defaultStorageManager = new VaultStorageManager({
|
||||
enablePersistence: true,
|
||||
autoCleanup: true
|
||||
});
|
||||
@@ -0,0 +1,264 @@
|
||||
/**
|
||||
* Type definitions for Vault WASM module
|
||||
* Mirrors the Go plugin interface from cmd/vault
|
||||
*/
|
||||
|
||||
/**
|
||||
* MPC Enclave data for vault initialization
|
||||
*/
|
||||
export interface EnclaveData {
|
||||
publicKey: string;
|
||||
privateKeyShares: string[];
|
||||
threshold: number;
|
||||
parties: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vault configuration options
|
||||
*/
|
||||
export interface VaultConfig {
|
||||
chainId?: string;
|
||||
enclave?: EnclaveData;
|
||||
[key: string]: any;
|
||||
}
|
||||
|
||||
/**
|
||||
* Request for creating a new origin UCAN token
|
||||
*/
|
||||
export interface NewOriginTokenRequest {
|
||||
audience_did: string;
|
||||
attenuations?: Record<string, any>[];
|
||||
facts?: string[];
|
||||
not_before?: number;
|
||||
expires_at?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Request for creating a new attenuated UCAN token
|
||||
*/
|
||||
export interface NewAttenuatedTokenRequest {
|
||||
parent_token: string;
|
||||
audience_did: string;
|
||||
attenuations?: Record<string, any>[];
|
||||
facts?: string[];
|
||||
not_before?: number;
|
||||
expires_at?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* UCAN token response
|
||||
*/
|
||||
export interface UCANTokenResponse {
|
||||
token: string;
|
||||
issuer: string;
|
||||
address: string;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Request for signing data
|
||||
*/
|
||||
export interface SignDataRequest {
|
||||
data: Uint8Array;
|
||||
}
|
||||
|
||||
/**
|
||||
* Response from signing data
|
||||
*/
|
||||
export interface SignDataResponse {
|
||||
signature: Uint8Array;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Request for verifying data
|
||||
*/
|
||||
export interface VerifyDataRequest {
|
||||
data: Uint8Array;
|
||||
signature: Uint8Array;
|
||||
}
|
||||
|
||||
/**
|
||||
* Response from verifying data
|
||||
*/
|
||||
export interface VerifyDataResponse {
|
||||
valid: boolean;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Response for getting issuer DID
|
||||
*/
|
||||
export interface GetIssuerDIDResponse {
|
||||
issuer_did: string;
|
||||
address: string;
|
||||
chain_code: string;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vault plugin interface matching the WASM exports
|
||||
*/
|
||||
export interface VaultPlugin {
|
||||
newOriginToken(request: NewOriginTokenRequest): Promise<UCANTokenResponse>;
|
||||
newAttenuatedToken(request: NewAttenuatedTokenRequest): Promise<UCANTokenResponse>;
|
||||
signData(request: SignDataRequest): Promise<SignDataResponse>;
|
||||
verifyData(request: VerifyDataRequest): Promise<VerifyDataResponse>;
|
||||
getIssuerDID(): Promise<GetIssuerDIDResponse>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Error codes for vault operations
|
||||
*/
|
||||
export enum VaultErrorCode {
|
||||
NOT_INITIALIZED = 'VAULT_NOT_INITIALIZED',
|
||||
ALREADY_INITIALIZED = 'VAULT_ALREADY_INITIALIZED',
|
||||
LOCKED = 'VAULT_LOCKED',
|
||||
KEY_NOT_FOUND = 'KEY_NOT_FOUND',
|
||||
INVALID_KEY_TYPE = 'INVALID_KEY_TYPE',
|
||||
OPERATION_FAILED = 'OPERATION_FAILED',
|
||||
INVALID_PASSPHRASE = 'INVALID_PASSPHRASE',
|
||||
WASM_NOT_LOADED = 'WASM_NOT_LOADED',
|
||||
TIMEOUT = 'TIMEOUT',
|
||||
}
|
||||
|
||||
/**
|
||||
* Vault error class
|
||||
*/
|
||||
export class VaultError extends Error {
|
||||
constructor(
|
||||
public code: VaultErrorCode,
|
||||
message: string,
|
||||
public details?: any
|
||||
) {
|
||||
super(message);
|
||||
this.name = 'VaultError';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Vault event types
|
||||
*/
|
||||
export enum VaultEventType {
|
||||
INITIALIZED = 'vault:initialized',
|
||||
LOCKED = 'vault:locked',
|
||||
UNLOCKED = 'vault:unlocked',
|
||||
KEY_GENERATED = 'vault:key_generated',
|
||||
KEY_DELETED = 'vault:key_deleted',
|
||||
EXPORTED = 'vault:exported',
|
||||
IMPORTED = 'vault:imported',
|
||||
ERROR = 'vault:error',
|
||||
}
|
||||
|
||||
/**
|
||||
* Vault event
|
||||
*/
|
||||
export interface VaultEvent {
|
||||
type: VaultEventType;
|
||||
timestamp: number;
|
||||
data?: any;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vault event listener
|
||||
*/
|
||||
export type VaultEventListener = (event: VaultEvent) => void;
|
||||
|
||||
/**
|
||||
* Storage configuration for vault
|
||||
*/
|
||||
export interface VaultStorageConfig {
|
||||
enablePersistence?: boolean;
|
||||
storageQuotaRequest?: number;
|
||||
autoCleanup?: boolean;
|
||||
cleanupInterval?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enhanced vault configuration with storage options
|
||||
*/
|
||||
export interface VaultConfigWithStorage extends VaultConfig, VaultStorageConfig {}
|
||||
|
||||
/**
|
||||
* Stored vault state in IndexedDB
|
||||
*/
|
||||
export interface StoredVaultState {
|
||||
id: string;
|
||||
accountAddress: string;
|
||||
isInitialized: boolean;
|
||||
enclave?: string;
|
||||
lastAccessed: number;
|
||||
createdAt: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Stored UCAN token in IndexedDB
|
||||
*/
|
||||
export interface StoredUCANToken {
|
||||
id: string;
|
||||
token: string;
|
||||
type: 'origin' | 'attenuated';
|
||||
issuer: string;
|
||||
audience: string;
|
||||
capabilities?: string;
|
||||
expiresAt?: number;
|
||||
createdAt: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Storage persistence status
|
||||
*/
|
||||
export type StoragePersistenceStatus = 'persisted' | 'prompt' | 'never';
|
||||
|
||||
/**
|
||||
* Storage statistics
|
||||
*/
|
||||
export interface StorageStats {
|
||||
accountCount: number;
|
||||
tokenCount: number;
|
||||
sessionCount: number;
|
||||
storageUsed?: number;
|
||||
storageQuota?: number;
|
||||
isPersisted: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* IPFS-specific vault configuration
|
||||
*/
|
||||
export interface VaultIPFSConfig {
|
||||
/** IPFS gateway URLs for fallback */
|
||||
ipfsGateways?: string[];
|
||||
/** Enable IPFS persistence */
|
||||
enableIPFSPersistence?: boolean;
|
||||
/** Custom IPFS node configuration */
|
||||
ipfsNodeConfig?: any;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enhanced vault configuration with IPFS support
|
||||
*/
|
||||
export interface VaultConfigWithIPFS extends VaultConfigWithStorage, VaultIPFSConfig {}
|
||||
|
||||
/**
|
||||
* IPFS-stored enclave reference
|
||||
*/
|
||||
export interface IPFSEnclaveReference {
|
||||
/** CID of the encrypted enclave data */
|
||||
cid: string;
|
||||
/** Timestamp when stored */
|
||||
storedAt: number;
|
||||
/** Whether the data is pinned */
|
||||
isPinned: boolean;
|
||||
/** Size of the encrypted data */
|
||||
size: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vault state with IPFS references
|
||||
*/
|
||||
export interface VaultStateWithIPFS extends StoredVaultState {
|
||||
/** IPFS CID references for enclave data */
|
||||
ipfsReferences?: IPFSEnclaveReference[];
|
||||
/** Last IPFS sync timestamp */
|
||||
lastIPFSSync?: number;
|
||||
}
|
||||
@@ -0,0 +1,248 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/app/runtime/v1alpha1/module.proto (package cosmos.app.runtime.v1alpha1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* Module is the config object for the runtime module.
|
||||
*
|
||||
* @generated from message cosmos.app.runtime.v1alpha1.Module
|
||||
*/
|
||||
export class Module extends Message<Module> {
|
||||
/**
|
||||
* app_name is the name of the app.
|
||||
*
|
||||
* @generated from field: string app_name = 1;
|
||||
*/
|
||||
appName = '';
|
||||
|
||||
/**
|
||||
* begin_blockers specifies the module names of begin blockers
|
||||
* to call in the order in which they should be called. If this is left empty
|
||||
* no begin blocker will be registered.
|
||||
*
|
||||
* @generated from field: repeated string begin_blockers = 2;
|
||||
*/
|
||||
beginBlockers: string[] = [];
|
||||
|
||||
/**
|
||||
* end_blockers specifies the module names of the end blockers
|
||||
* to call in the order in which they should be called. If this is left empty
|
||||
* no end blocker will be registered.
|
||||
*
|
||||
* @generated from field: repeated string end_blockers = 3;
|
||||
*/
|
||||
endBlockers: string[] = [];
|
||||
|
||||
/**
|
||||
* init_genesis specifies the module names of init genesis functions
|
||||
* to call in the order in which they should be called. If this is left empty
|
||||
* no init genesis function will be registered.
|
||||
*
|
||||
* @generated from field: repeated string init_genesis = 4;
|
||||
*/
|
||||
initGenesis: string[] = [];
|
||||
|
||||
/**
|
||||
* export_genesis specifies the order in which to export module genesis data.
|
||||
* If this is left empty, the init_genesis order will be used for export genesis
|
||||
* if it is specified.
|
||||
*
|
||||
* @generated from field: repeated string export_genesis = 5;
|
||||
*/
|
||||
exportGenesis: string[] = [];
|
||||
|
||||
/**
|
||||
* override_store_keys is an optional list of overrides for the module store keys
|
||||
* to be used in keeper construction.
|
||||
*
|
||||
* @generated from field: repeated cosmos.app.runtime.v1alpha1.StoreKeyConfig override_store_keys = 6;
|
||||
*/
|
||||
overrideStoreKeys: StoreKeyConfig[] = [];
|
||||
|
||||
/**
|
||||
* order_migrations defines the order in which module migrations are performed.
|
||||
* If this is left empty, it uses the default migration order.
|
||||
* https://pkg.go.dev/github.com/cosmos/cosmos-sdk@v0.47.0-alpha2/types/module#DefaultMigrationsOrder
|
||||
*
|
||||
* @generated from field: repeated string order_migrations = 7;
|
||||
*/
|
||||
orderMigrations: string[] = [];
|
||||
|
||||
/**
|
||||
* precommiters specifies the module names of the precommiters
|
||||
* to call in the order in which they should be called. If this is left empty
|
||||
* no precommit function will be registered.
|
||||
*
|
||||
* @generated from field: repeated string precommiters = 8;
|
||||
*/
|
||||
precommiters: string[] = [];
|
||||
|
||||
/**
|
||||
* prepare_check_staters specifies the module names of the prepare_check_staters
|
||||
* to call in the order in which they should be called. If this is left empty
|
||||
* no preparecheckstate function will be registered.
|
||||
*
|
||||
* @generated from field: repeated string prepare_check_staters = 9;
|
||||
*/
|
||||
prepareCheckStaters: string[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<Module>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.runtime.v1alpha1.Module';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'app_name', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{
|
||||
no: 2,
|
||||
name: 'begin_blockers',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 3,
|
||||
name: 'end_blockers',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 4,
|
||||
name: 'init_genesis',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 5,
|
||||
name: 'export_genesis',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 6,
|
||||
name: 'override_store_keys',
|
||||
kind: 'message',
|
||||
T: StoreKeyConfig,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 7,
|
||||
name: 'order_migrations',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 8,
|
||||
name: 'precommiters',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 9,
|
||||
name: 'prepare_check_staters',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Module {
|
||||
return new Module().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Module {
|
||||
return new Module().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Module {
|
||||
return new Module().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Module | PlainMessage<Module> | undefined,
|
||||
b: Module | PlainMessage<Module> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Module, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* StoreKeyConfig may be supplied to override the default module store key, which
|
||||
* is the module name.
|
||||
*
|
||||
* @generated from message cosmos.app.runtime.v1alpha1.StoreKeyConfig
|
||||
*/
|
||||
export class StoreKeyConfig extends Message<StoreKeyConfig> {
|
||||
/**
|
||||
* name of the module to override the store key of
|
||||
*
|
||||
* @generated from field: string module_name = 1;
|
||||
*/
|
||||
moduleName = '';
|
||||
|
||||
/**
|
||||
* the kv store key to use instead of the module name.
|
||||
*
|
||||
* @generated from field: string kv_store_key = 2;
|
||||
*/
|
||||
kvStoreKey = '';
|
||||
|
||||
constructor(data?: PartialMessage<StoreKeyConfig>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.runtime.v1alpha1.StoreKeyConfig';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'module_name',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
{
|
||||
no: 2,
|
||||
name: 'kv_store_key',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StoreKeyConfig {
|
||||
return new StoreKeyConfig().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StoreKeyConfig {
|
||||
return new StoreKeyConfig().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StoreKeyConfig {
|
||||
return new StoreKeyConfig().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: StoreKeyConfig | PlainMessage<StoreKeyConfig> | undefined,
|
||||
b: StoreKeyConfig | PlainMessage<StoreKeyConfig> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(StoreKeyConfig, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,226 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/app/v1alpha1/config.proto (package cosmos.app.v1alpha1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Any, Message, proto3 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* Config represents the configuration for a Cosmos SDK ABCI app.
|
||||
* It is intended that all state machine logic including the version of
|
||||
* baseapp and tx handlers (and possibly even Tendermint) that an app needs
|
||||
* can be described in a config object. For compatibility, the framework should
|
||||
* allow a mixture of declarative and imperative app wiring, however, apps
|
||||
* that strive for the maximum ease of maintainability should be able to describe
|
||||
* their state machine with a config object alone.
|
||||
*
|
||||
* @generated from message cosmos.app.v1alpha1.Config
|
||||
*/
|
||||
export class Config extends Message<Config> {
|
||||
/**
|
||||
* modules are the module configurations for the app.
|
||||
*
|
||||
* @generated from field: repeated cosmos.app.v1alpha1.ModuleConfig modules = 1;
|
||||
*/
|
||||
modules: ModuleConfig[] = [];
|
||||
|
||||
/**
|
||||
* golang_bindings specifies explicit interface to implementation type bindings which
|
||||
* depinject uses to resolve interface inputs to provider functions. The scope of this
|
||||
* field's configuration is global (not module specific).
|
||||
*
|
||||
* @generated from field: repeated cosmos.app.v1alpha1.GolangBinding golang_bindings = 2;
|
||||
*/
|
||||
golangBindings: GolangBinding[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<Config>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.v1alpha1.Config';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'modules',
|
||||
kind: 'message',
|
||||
T: ModuleConfig,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 2,
|
||||
name: 'golang_bindings',
|
||||
kind: 'message',
|
||||
T: GolangBinding,
|
||||
repeated: true,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Config {
|
||||
return new Config().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Config {
|
||||
return new Config().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Config {
|
||||
return new Config().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Config | PlainMessage<Config> | undefined,
|
||||
b: Config | PlainMessage<Config> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Config, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ModuleConfig is a module configuration for an app.
|
||||
*
|
||||
* @generated from message cosmos.app.v1alpha1.ModuleConfig
|
||||
*/
|
||||
export class ModuleConfig extends Message<ModuleConfig> {
|
||||
/**
|
||||
* name is the unique name of the module within the app. It should be a name
|
||||
* that persists between different versions of a module so that modules
|
||||
* can be smoothly upgraded to new versions.
|
||||
*
|
||||
* For example, for the module cosmos.bank.module.v1.Module, we may chose
|
||||
* to simply name the module "bank" in the app. When we upgrade to
|
||||
* cosmos.bank.module.v2.Module, the app-specific name "bank" stays the same
|
||||
* and the framework knows that the v2 module should receive all the same state
|
||||
* that the v1 module had. Note: modules should provide info on which versions
|
||||
* they can migrate from in the ModuleDescriptor.can_migration_from field.
|
||||
*
|
||||
* @generated from field: string name = 1;
|
||||
*/
|
||||
name = '';
|
||||
|
||||
/**
|
||||
* config is the config object for the module. Module config messages should
|
||||
* define a ModuleDescriptor using the cosmos.app.v1alpha1.is_module extension.
|
||||
*
|
||||
* @generated from field: google.protobuf.Any config = 2;
|
||||
*/
|
||||
config?: Any;
|
||||
|
||||
/**
|
||||
* golang_bindings specifies explicit interface to implementation type bindings which
|
||||
* depinject uses to resolve interface inputs to provider functions. The scope of this
|
||||
* field's configuration is module specific.
|
||||
*
|
||||
* @generated from field: repeated cosmos.app.v1alpha1.GolangBinding golang_bindings = 3;
|
||||
*/
|
||||
golangBindings: GolangBinding[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<ModuleConfig>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.v1alpha1.ModuleConfig';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'name', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 2, name: 'config', kind: 'message', T: Any },
|
||||
{
|
||||
no: 3,
|
||||
name: 'golang_bindings',
|
||||
kind: 'message',
|
||||
T: GolangBinding,
|
||||
repeated: true,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ModuleConfig {
|
||||
return new ModuleConfig().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ModuleConfig {
|
||||
return new ModuleConfig().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ModuleConfig {
|
||||
return new ModuleConfig().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ModuleConfig | PlainMessage<ModuleConfig> | undefined,
|
||||
b: ModuleConfig | PlainMessage<ModuleConfig> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ModuleConfig, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* GolangBinding is an explicit interface type to implementing type binding for dependency injection.
|
||||
*
|
||||
* @generated from message cosmos.app.v1alpha1.GolangBinding
|
||||
*/
|
||||
export class GolangBinding extends Message<GolangBinding> {
|
||||
/**
|
||||
* interface_type is the interface type which will be bound to a specific implementation type
|
||||
*
|
||||
* @generated from field: string interface_type = 1;
|
||||
*/
|
||||
interfaceType = '';
|
||||
|
||||
/**
|
||||
* implementation is the implementing type which will be supplied when an input of type interface is requested
|
||||
*
|
||||
* @generated from field: string implementation = 2;
|
||||
*/
|
||||
implementation = '';
|
||||
|
||||
constructor(data?: PartialMessage<GolangBinding>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.v1alpha1.GolangBinding';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'interface_type',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
{
|
||||
no: 2,
|
||||
name: 'implementation',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GolangBinding {
|
||||
return new GolangBinding().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GolangBinding {
|
||||
return new GolangBinding().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GolangBinding {
|
||||
return new GolangBinding().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: GolangBinding | PlainMessage<GolangBinding> | undefined,
|
||||
b: GolangBinding | PlainMessage<GolangBinding> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(GolangBinding, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,229 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/app/v1alpha1/module.proto (package cosmos.app.v1alpha1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* ModuleDescriptor describes an app module.
|
||||
*
|
||||
* @generated from message cosmos.app.v1alpha1.ModuleDescriptor
|
||||
*/
|
||||
export class ModuleDescriptor extends Message<ModuleDescriptor> {
|
||||
/**
|
||||
* go_import names the package that should be imported by an app to load the
|
||||
* module in the runtime module registry. It is required to make debugging
|
||||
* of configuration errors easier for users.
|
||||
*
|
||||
* @generated from field: string go_import = 1;
|
||||
*/
|
||||
goImport = '';
|
||||
|
||||
/**
|
||||
* use_package refers to a protobuf package that this module
|
||||
* uses and exposes to the world. In an app, only one module should "use"
|
||||
* or own a single protobuf package. It is assumed that the module uses
|
||||
* all of the .proto files in a single package.
|
||||
*
|
||||
* @generated from field: repeated cosmos.app.v1alpha1.PackageReference use_package = 2;
|
||||
*/
|
||||
usePackage: PackageReference[] = [];
|
||||
|
||||
/**
|
||||
* can_migrate_from defines which module versions this module can migrate
|
||||
* state from. The framework will check that one module version is able to
|
||||
* migrate from a previous module version before attempting to update its
|
||||
* config. It is assumed that modules can transitively migrate from earlier
|
||||
* versions. For instance if v3 declares it can migrate from v2, and v2
|
||||
* declares it can migrate from v1, the framework knows how to migrate
|
||||
* from v1 to v3, assuming all 3 module versions are registered at runtime.
|
||||
*
|
||||
* @generated from field: repeated cosmos.app.v1alpha1.MigrateFromInfo can_migrate_from = 3;
|
||||
*/
|
||||
canMigrateFrom: MigrateFromInfo[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<ModuleDescriptor>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.v1alpha1.ModuleDescriptor';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'go_import', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{
|
||||
no: 2,
|
||||
name: 'use_package',
|
||||
kind: 'message',
|
||||
T: PackageReference,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 3,
|
||||
name: 'can_migrate_from',
|
||||
kind: 'message',
|
||||
T: MigrateFromInfo,
|
||||
repeated: true,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ModuleDescriptor {
|
||||
return new ModuleDescriptor().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ModuleDescriptor {
|
||||
return new ModuleDescriptor().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ModuleDescriptor {
|
||||
return new ModuleDescriptor().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ModuleDescriptor | PlainMessage<ModuleDescriptor> | undefined,
|
||||
b: ModuleDescriptor | PlainMessage<ModuleDescriptor> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ModuleDescriptor, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* PackageReference is a reference to a protobuf package used by a module.
|
||||
*
|
||||
* @generated from message cosmos.app.v1alpha1.PackageReference
|
||||
*/
|
||||
export class PackageReference extends Message<PackageReference> {
|
||||
/**
|
||||
* name is the fully-qualified name of the package.
|
||||
*
|
||||
* @generated from field: string name = 1;
|
||||
*/
|
||||
name = '';
|
||||
|
||||
/**
|
||||
* revision is the optional revision of the package that is being used.
|
||||
* Protobuf packages used in Cosmos should generally have a major version
|
||||
* as the last part of the package name, ex. foo.bar.baz.v1.
|
||||
* The revision of a package can be thought of as the minor version of a
|
||||
* package which has additional backwards compatible definitions that weren't
|
||||
* present in a previous version.
|
||||
*
|
||||
* A package should indicate its revision with a source code comment
|
||||
* above the package declaration in one of its files containing the
|
||||
* text "Revision N" where N is an integer revision. All packages start
|
||||
* at revision 0 the first time they are released in a module.
|
||||
*
|
||||
* When a new version of a module is released and items are added to existing
|
||||
* .proto files, these definitions should contain comments of the form
|
||||
* "Since: Revision N" where N is an integer revision.
|
||||
*
|
||||
* When the module runtime starts up, it will check the pinned proto
|
||||
* image and panic if there are runtime protobuf definitions that are not
|
||||
* in the pinned descriptor which do not have
|
||||
* a "Since Revision N" comment or have a "Since Revision N" comment where
|
||||
* N is <= to the revision specified here. This indicates that the protobuf
|
||||
* files have been updated, but the pinned file descriptor hasn't.
|
||||
*
|
||||
* If there are items in the pinned file descriptor with a revision
|
||||
* greater than the value indicated here, this will also cause a panic
|
||||
* as it may mean that the pinned descriptor for a legacy module has been
|
||||
* improperly updated or that there is some other versioning discrepancy.
|
||||
* Runtime protobuf definitions will also be checked for compatibility
|
||||
* with pinned file descriptors to make sure there are no incompatible changes.
|
||||
*
|
||||
* This behavior ensures that:
|
||||
* * pinned proto images are up-to-date
|
||||
* * protobuf files are carefully annotated with revision comments which
|
||||
* are important good client UX
|
||||
* * protobuf files are changed in backwards and forwards compatible ways
|
||||
*
|
||||
* @generated from field: uint32 revision = 2;
|
||||
*/
|
||||
revision = 0;
|
||||
|
||||
constructor(data?: PartialMessage<PackageReference>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.v1alpha1.PackageReference';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'name', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 2, name: 'revision', kind: 'scalar', T: 13 /* ScalarType.UINT32 */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PackageReference {
|
||||
return new PackageReference().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PackageReference {
|
||||
return new PackageReference().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PackageReference {
|
||||
return new PackageReference().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: PackageReference | PlainMessage<PackageReference> | undefined,
|
||||
b: PackageReference | PlainMessage<PackageReference> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(PackageReference, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* MigrateFromInfo is information on a module version that a newer module
|
||||
* can migrate from.
|
||||
*
|
||||
* @generated from message cosmos.app.v1alpha1.MigrateFromInfo
|
||||
*/
|
||||
export class MigrateFromInfo extends Message<MigrateFromInfo> {
|
||||
/**
|
||||
* module is the fully-qualified protobuf name of the module config object
|
||||
* for the previous module version, ex: "cosmos.group.module.v1.Module".
|
||||
*
|
||||
* @generated from field: string module = 1;
|
||||
*/
|
||||
module = '';
|
||||
|
||||
constructor(data?: PartialMessage<MigrateFromInfo>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.v1alpha1.MigrateFromInfo';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'module', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MigrateFromInfo {
|
||||
return new MigrateFromInfo().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MigrateFromInfo {
|
||||
return new MigrateFromInfo().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MigrateFromInfo {
|
||||
return new MigrateFromInfo().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: MigrateFromInfo | PlainMessage<MigrateFromInfo> | undefined,
|
||||
b: MigrateFromInfo | PlainMessage<MigrateFromInfo> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(MigrateFromInfo, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
|
||||
// @generated from file cosmos/app/v1alpha1/query.proto (package cosmos.app.v1alpha1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import { QueryConfigRequest, QueryConfigResponse } from './query_pb.js';
|
||||
|
||||
const TYPE_NAME = 'cosmos.app.v1alpha1.Query';
|
||||
|
||||
/**
|
||||
* Config returns the current app config.
|
||||
*
|
||||
* @generated from rpc cosmos.app.v1alpha1.Query.Config
|
||||
*/
|
||||
export const QueryConfigService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'Config',
|
||||
Request: QueryConfigRequest,
|
||||
Response: QueryConfigResponse,
|
||||
} as const;
|
||||
@@ -0,0 +1,100 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/app/v1alpha1/query.proto (package cosmos.app.v1alpha1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3 } from '@bufbuild/protobuf';
|
||||
import { Config } from './config_pb.js';
|
||||
|
||||
/**
|
||||
* QueryConfigRequest is the Query/Config request type.
|
||||
*
|
||||
* @generated from message cosmos.app.v1alpha1.QueryConfigRequest
|
||||
*/
|
||||
export class QueryConfigRequest extends Message<QueryConfigRequest> {
|
||||
constructor(data?: PartialMessage<QueryConfigRequest>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.v1alpha1.QueryConfigRequest';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => []);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConfigRequest {
|
||||
return new QueryConfigRequest().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConfigRequest {
|
||||
return new QueryConfigRequest().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): QueryConfigRequest {
|
||||
return new QueryConfigRequest().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: QueryConfigRequest | PlainMessage<QueryConfigRequest> | undefined,
|
||||
b: QueryConfigRequest | PlainMessage<QueryConfigRequest> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(QueryConfigRequest, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* QueryConfigRequest is the Query/Config response type.
|
||||
*
|
||||
* @generated from message cosmos.app.v1alpha1.QueryConfigResponse
|
||||
*/
|
||||
export class QueryConfigResponse extends Message<QueryConfigResponse> {
|
||||
/**
|
||||
* config is the current app config.
|
||||
*
|
||||
* @generated from field: cosmos.app.v1alpha1.Config config = 1;
|
||||
*/
|
||||
config?: Config;
|
||||
|
||||
constructor(data?: PartialMessage<QueryConfigResponse>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.app.v1alpha1.QueryConfigResponse';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'config', kind: 'message', T: Config },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConfigResponse {
|
||||
return new QueryConfigResponse().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConfigResponse {
|
||||
return new QueryConfigResponse().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): QueryConfigResponse {
|
||||
return new QueryConfigResponse().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: QueryConfigResponse | PlainMessage<QueryConfigResponse> | undefined,
|
||||
b: QueryConfigResponse | PlainMessage<QueryConfigResponse> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(QueryConfigResponse, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,495 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/autocli/v1/options.proto (package cosmos.autocli.v1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* ModuleOptions describes the CLI options for a Cosmos SDK module.
|
||||
*
|
||||
* @generated from message cosmos.autocli.v1.ModuleOptions
|
||||
*/
|
||||
export class ModuleOptions extends Message<ModuleOptions> {
|
||||
/**
|
||||
* tx describes the tx commands for the module.
|
||||
*
|
||||
* @generated from field: cosmos.autocli.v1.ServiceCommandDescriptor tx = 1;
|
||||
*/
|
||||
tx?: ServiceCommandDescriptor;
|
||||
|
||||
/**
|
||||
* query describes the queries commands for the module.
|
||||
*
|
||||
* @generated from field: cosmos.autocli.v1.ServiceCommandDescriptor query = 2;
|
||||
*/
|
||||
query?: ServiceCommandDescriptor;
|
||||
|
||||
constructor(data?: PartialMessage<ModuleOptions>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.autocli.v1.ModuleOptions';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'tx', kind: 'message', T: ServiceCommandDescriptor },
|
||||
{ no: 2, name: 'query', kind: 'message', T: ServiceCommandDescriptor },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ModuleOptions {
|
||||
return new ModuleOptions().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ModuleOptions {
|
||||
return new ModuleOptions().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ModuleOptions {
|
||||
return new ModuleOptions().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ModuleOptions | PlainMessage<ModuleOptions> | undefined,
|
||||
b: ModuleOptions | PlainMessage<ModuleOptions> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ModuleOptions, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ServiceCommandDescriptor describes a CLI command based on a protobuf service.
|
||||
*
|
||||
* @generated from message cosmos.autocli.v1.ServiceCommandDescriptor
|
||||
*/
|
||||
export class ServiceCommandDescriptor extends Message<ServiceCommandDescriptor> {
|
||||
/**
|
||||
* service is the fully qualified name of the protobuf service to build
|
||||
* the command from. It can be left empty if sub_commands are used instead
|
||||
* which may be the case if a module provides multiple tx and/or query services.
|
||||
*
|
||||
* @generated from field: string service = 1;
|
||||
*/
|
||||
service = '';
|
||||
|
||||
/**
|
||||
* rpc_command_options are options for commands generated from rpc methods.
|
||||
* If no options are specified for a given rpc method on the service, a
|
||||
* command will be generated for that method with the default options.
|
||||
*
|
||||
* @generated from field: repeated cosmos.autocli.v1.RpcCommandOptions rpc_command_options = 2;
|
||||
*/
|
||||
rpcCommandOptions: RpcCommandOptions[] = [];
|
||||
|
||||
/**
|
||||
* sub_commands is a map of optional sub-commands for this command based on
|
||||
* different protobuf services. The map key is used as the name of the
|
||||
* sub-command.
|
||||
*
|
||||
* @generated from field: map<string, cosmos.autocli.v1.ServiceCommandDescriptor> sub_commands = 3;
|
||||
*/
|
||||
subCommands: { [key: string]: ServiceCommandDescriptor } = {};
|
||||
|
||||
constructor(data?: PartialMessage<ServiceCommandDescriptor>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.autocli.v1.ServiceCommandDescriptor';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'service', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{
|
||||
no: 2,
|
||||
name: 'rpc_command_options',
|
||||
kind: 'message',
|
||||
T: RpcCommandOptions,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 3,
|
||||
name: 'sub_commands',
|
||||
kind: 'map',
|
||||
K: 9 /* ScalarType.STRING */,
|
||||
V: { kind: 'message', T: ServiceCommandDescriptor },
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(
|
||||
bytes: Uint8Array,
|
||||
options?: Partial<BinaryReadOptions>
|
||||
): ServiceCommandDescriptor {
|
||||
return new ServiceCommandDescriptor().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(
|
||||
jsonValue: JsonValue,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ServiceCommandDescriptor {
|
||||
return new ServiceCommandDescriptor().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ServiceCommandDescriptor {
|
||||
return new ServiceCommandDescriptor().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ServiceCommandDescriptor | PlainMessage<ServiceCommandDescriptor> | undefined,
|
||||
b: ServiceCommandDescriptor | PlainMessage<ServiceCommandDescriptor> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ServiceCommandDescriptor, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* RpcCommandOptions specifies options for commands generated from protobuf
|
||||
* rpc methods.
|
||||
*
|
||||
* @generated from message cosmos.autocli.v1.RpcCommandOptions
|
||||
*/
|
||||
export class RpcCommandOptions extends Message<RpcCommandOptions> {
|
||||
/**
|
||||
* rpc_method is short name of the protobuf rpc method that this command is
|
||||
* generated from.
|
||||
*
|
||||
* @generated from field: string rpc_method = 1;
|
||||
*/
|
||||
rpcMethod = '';
|
||||
|
||||
/**
|
||||
* use is the one-line usage method. It also allows specifying an alternate
|
||||
* name for the command as the first word of the usage text.
|
||||
*
|
||||
* By default the name of an rpc command is the kebab-case short name of the
|
||||
* rpc method.
|
||||
*
|
||||
* @generated from field: string use = 2;
|
||||
*/
|
||||
use = '';
|
||||
|
||||
/**
|
||||
* long is the long message shown in the 'help <this-command>' output.
|
||||
*
|
||||
* @generated from field: string long = 3;
|
||||
*/
|
||||
long = '';
|
||||
|
||||
/**
|
||||
* short is the short description shown in the 'help' output.
|
||||
*
|
||||
* @generated from field: string short = 4;
|
||||
*/
|
||||
short = '';
|
||||
|
||||
/**
|
||||
* example is examples of how to use the command.
|
||||
*
|
||||
* @generated from field: string example = 5;
|
||||
*/
|
||||
example = '';
|
||||
|
||||
/**
|
||||
* alias is an array of aliases that can be used instead of the first word in Use.
|
||||
*
|
||||
* @generated from field: repeated string alias = 6;
|
||||
*/
|
||||
alias: string[] = [];
|
||||
|
||||
/**
|
||||
* suggest_for is an array of command names for which this command will be suggested -
|
||||
* similar to aliases but only suggests.
|
||||
*
|
||||
* @generated from field: repeated string suggest_for = 7;
|
||||
*/
|
||||
suggestFor: string[] = [];
|
||||
|
||||
/**
|
||||
* deprecated defines, if this command is deprecated and should print this string when used.
|
||||
*
|
||||
* @generated from field: string deprecated = 8;
|
||||
*/
|
||||
deprecated = '';
|
||||
|
||||
/**
|
||||
* version defines the version for this command. If this value is non-empty and the command does not
|
||||
* define a "version" flag, a "version" boolean flag will be added to the command and, if specified,
|
||||
* will print content of the "Version" variable. A shorthand "v" flag will also be added if the
|
||||
* command does not define one.
|
||||
*
|
||||
* @generated from field: string version = 9;
|
||||
*/
|
||||
version = '';
|
||||
|
||||
/**
|
||||
* flag_options are options for flags generated from rpc request fields.
|
||||
* By default all request fields are configured as flags. They can
|
||||
* also be configured as positional args instead using positional_args.
|
||||
*
|
||||
* @generated from field: map<string, cosmos.autocli.v1.FlagOptions> flag_options = 10;
|
||||
*/
|
||||
flagOptions: { [key: string]: FlagOptions } = {};
|
||||
|
||||
/**
|
||||
* positional_args specifies positional arguments for the command.
|
||||
*
|
||||
* @generated from field: repeated cosmos.autocli.v1.PositionalArgDescriptor positional_args = 11;
|
||||
*/
|
||||
positionalArgs: PositionalArgDescriptor[] = [];
|
||||
|
||||
/**
|
||||
* skip specifies whether to skip this rpc method when generating commands.
|
||||
*
|
||||
* @generated from field: bool skip = 12;
|
||||
*/
|
||||
skip = false;
|
||||
|
||||
constructor(data?: PartialMessage<RpcCommandOptions>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.autocli.v1.RpcCommandOptions';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'rpc_method', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 2, name: 'use', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 3, name: 'long', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 4, name: 'short', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 5, name: 'example', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{
|
||||
no: 6,
|
||||
name: 'alias',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
{
|
||||
no: 7,
|
||||
name: 'suggest_for',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
{ no: 8, name: 'deprecated', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 9, name: 'version', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{
|
||||
no: 10,
|
||||
name: 'flag_options',
|
||||
kind: 'map',
|
||||
K: 9 /* ScalarType.STRING */,
|
||||
V: { kind: 'message', T: FlagOptions },
|
||||
},
|
||||
{
|
||||
no: 11,
|
||||
name: 'positional_args',
|
||||
kind: 'message',
|
||||
T: PositionalArgDescriptor,
|
||||
repeated: true,
|
||||
},
|
||||
{ no: 12, name: 'skip', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RpcCommandOptions {
|
||||
return new RpcCommandOptions().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RpcCommandOptions {
|
||||
return new RpcCommandOptions().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RpcCommandOptions {
|
||||
return new RpcCommandOptions().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: RpcCommandOptions | PlainMessage<RpcCommandOptions> | undefined,
|
||||
b: RpcCommandOptions | PlainMessage<RpcCommandOptions> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(RpcCommandOptions, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* FlagOptions are options for flags generated from rpc request fields.
|
||||
* By default, all request fields are configured as flags based on the
|
||||
* kebab-case name of the field. Fields can be turned into positional arguments
|
||||
* instead by using RpcCommandOptions.positional_args.
|
||||
*
|
||||
* @generated from message cosmos.autocli.v1.FlagOptions
|
||||
*/
|
||||
export class FlagOptions extends Message<FlagOptions> {
|
||||
/**
|
||||
* name is an alternate name to use for the field flag.
|
||||
*
|
||||
* @generated from field: string name = 1;
|
||||
*/
|
||||
name = '';
|
||||
|
||||
/**
|
||||
* shorthand is a one-letter abbreviated flag.
|
||||
*
|
||||
* @generated from field: string shorthand = 2;
|
||||
*/
|
||||
shorthand = '';
|
||||
|
||||
/**
|
||||
* usage is the help message.
|
||||
*
|
||||
* @generated from field: string usage = 3;
|
||||
*/
|
||||
usage = '';
|
||||
|
||||
/**
|
||||
* default_value is the default value as text.
|
||||
*
|
||||
* @generated from field: string default_value = 4;
|
||||
*/
|
||||
defaultValue = '';
|
||||
|
||||
/**
|
||||
* deprecated is the usage text to show if this flag is deprecated.
|
||||
*
|
||||
* @generated from field: string deprecated = 6;
|
||||
*/
|
||||
deprecated = '';
|
||||
|
||||
/**
|
||||
* shorthand_deprecated is the usage text to show if the shorthand of this flag is deprecated.
|
||||
*
|
||||
* @generated from field: string shorthand_deprecated = 7;
|
||||
*/
|
||||
shorthandDeprecated = '';
|
||||
|
||||
/**
|
||||
* hidden hides the flag from help/usage text
|
||||
*
|
||||
* @generated from field: bool hidden = 8;
|
||||
*/
|
||||
hidden = false;
|
||||
|
||||
constructor(data?: PartialMessage<FlagOptions>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.autocli.v1.FlagOptions';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'name', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 2, name: 'shorthand', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 3, name: 'usage', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{
|
||||
no: 4,
|
||||
name: 'default_value',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
{ no: 6, name: 'deprecated', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{
|
||||
no: 7,
|
||||
name: 'shorthand_deprecated',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
{ no: 8, name: 'hidden', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FlagOptions {
|
||||
return new FlagOptions().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FlagOptions {
|
||||
return new FlagOptions().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FlagOptions {
|
||||
return new FlagOptions().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: FlagOptions | PlainMessage<FlagOptions> | undefined,
|
||||
b: FlagOptions | PlainMessage<FlagOptions> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(FlagOptions, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* PositionalArgDescriptor describes a positional argument.
|
||||
*
|
||||
* @generated from message cosmos.autocli.v1.PositionalArgDescriptor
|
||||
*/
|
||||
export class PositionalArgDescriptor extends Message<PositionalArgDescriptor> {
|
||||
/**
|
||||
* proto_field specifies the proto field to use as the positional arg. Any
|
||||
* fields used as positional args will not have a flag generated.
|
||||
*
|
||||
* @generated from field: string proto_field = 1;
|
||||
*/
|
||||
protoField = '';
|
||||
|
||||
/**
|
||||
* varargs makes a positional parameter a varargs parameter. This can only be
|
||||
* applied to last positional parameter and the proto_field must a repeated
|
||||
* field.
|
||||
*
|
||||
* @generated from field: bool varargs = 2;
|
||||
*/
|
||||
varargs = false;
|
||||
|
||||
constructor(data?: PartialMessage<PositionalArgDescriptor>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.autocli.v1.PositionalArgDescriptor';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'proto_field',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
{ no: 2, name: 'varargs', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
|
||||
]);
|
||||
|
||||
static fromBinary(
|
||||
bytes: Uint8Array,
|
||||
options?: Partial<BinaryReadOptions>
|
||||
): PositionalArgDescriptor {
|
||||
return new PositionalArgDescriptor().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(
|
||||
jsonValue: JsonValue,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): PositionalArgDescriptor {
|
||||
return new PositionalArgDescriptor().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): PositionalArgDescriptor {
|
||||
return new PositionalArgDescriptor().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: PositionalArgDescriptor | PlainMessage<PositionalArgDescriptor> | undefined,
|
||||
b: PositionalArgDescriptor | PlainMessage<PositionalArgDescriptor> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(PositionalArgDescriptor, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
|
||||
// @generated from file cosmos/autocli/v1/query.proto (package cosmos.autocli.v1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import { AppOptionsRequest, AppOptionsResponse } from './query_pb.js';
|
||||
|
||||
const TYPE_NAME = 'cosmos.autocli.v1.Query';
|
||||
|
||||
/**
|
||||
* AppOptions returns the autocli options for all of the modules in an app.
|
||||
*
|
||||
* @generated from rpc cosmos.autocli.v1.Query.AppOptions
|
||||
*/
|
||||
export const QueryAppOptionsService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'AppOptions',
|
||||
Request: AppOptionsRequest,
|
||||
Response: AppOptionsResponse,
|
||||
} as const;
|
||||
@@ -0,0 +1,103 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/autocli/v1/query.proto (package cosmos.autocli.v1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3 } from '@bufbuild/protobuf';
|
||||
import { ModuleOptions } from './options_pb.js';
|
||||
|
||||
/**
|
||||
* AppOptionsRequest is the RemoteInfoService/AppOptions request type.
|
||||
*
|
||||
* @generated from message cosmos.autocli.v1.AppOptionsRequest
|
||||
*/
|
||||
export class AppOptionsRequest extends Message<AppOptionsRequest> {
|
||||
constructor(data?: PartialMessage<AppOptionsRequest>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.autocli.v1.AppOptionsRequest';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => []);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AppOptionsRequest {
|
||||
return new AppOptionsRequest().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AppOptionsRequest {
|
||||
return new AppOptionsRequest().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AppOptionsRequest {
|
||||
return new AppOptionsRequest().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: AppOptionsRequest | PlainMessage<AppOptionsRequest> | undefined,
|
||||
b: AppOptionsRequest | PlainMessage<AppOptionsRequest> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(AppOptionsRequest, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* AppOptionsResponse is the RemoteInfoService/AppOptions response type.
|
||||
*
|
||||
* @generated from message cosmos.autocli.v1.AppOptionsResponse
|
||||
*/
|
||||
export class AppOptionsResponse extends Message<AppOptionsResponse> {
|
||||
/**
|
||||
* module_options is a map of module name to autocli module options.
|
||||
*
|
||||
* @generated from field: map<string, cosmos.autocli.v1.ModuleOptions> module_options = 1;
|
||||
*/
|
||||
moduleOptions: { [key: string]: ModuleOptions } = {};
|
||||
|
||||
constructor(data?: PartialMessage<AppOptionsResponse>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.autocli.v1.AppOptionsResponse';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'module_options',
|
||||
kind: 'map',
|
||||
K: 9 /* ScalarType.STRING */,
|
||||
V: { kind: 'message', T: ModuleOptions },
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AppOptionsResponse {
|
||||
return new AppOptionsResponse().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AppOptionsResponse {
|
||||
return new AppOptionsResponse().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): AppOptionsResponse {
|
||||
return new AppOptionsResponse().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: AppOptionsResponse | PlainMessage<AppOptionsResponse> | undefined,
|
||||
b: AppOptionsResponse | PlainMessage<AppOptionsResponse> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(AppOptionsResponse, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,792 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/abci/v1beta1/abci.proto (package cosmos.base.abci.v1beta1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Any, Message, proto3, protoInt64 } from '@bufbuild/protobuf';
|
||||
import { Event } from '../../../../tendermint/abci/types_pb.js';
|
||||
import { Block } from '../../../../tendermint/types/block_pb.js';
|
||||
|
||||
/**
|
||||
* TxResponse defines a structure containing relevant tx data and metadata. The
|
||||
* tags are stringified and the log is JSON decoded.
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.TxResponse
|
||||
*/
|
||||
export class TxResponse extends Message<TxResponse> {
|
||||
/**
|
||||
* The block height
|
||||
*
|
||||
* @generated from field: int64 height = 1;
|
||||
*/
|
||||
height = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* The transaction hash.
|
||||
*
|
||||
* @generated from field: string txhash = 2;
|
||||
*/
|
||||
txhash = '';
|
||||
|
||||
/**
|
||||
* Namespace for the Code
|
||||
*
|
||||
* @generated from field: string codespace = 3;
|
||||
*/
|
||||
codespace = '';
|
||||
|
||||
/**
|
||||
* Response code.
|
||||
*
|
||||
* @generated from field: uint32 code = 4;
|
||||
*/
|
||||
code = 0;
|
||||
|
||||
/**
|
||||
* Result bytes, if any.
|
||||
*
|
||||
* @generated from field: string data = 5;
|
||||
*/
|
||||
data = '';
|
||||
|
||||
/**
|
||||
* The output of the application's logger (raw string). May be
|
||||
* non-deterministic.
|
||||
*
|
||||
* @generated from field: string raw_log = 6;
|
||||
*/
|
||||
rawLog = '';
|
||||
|
||||
/**
|
||||
* The output of the application's logger (typed). May be non-deterministic.
|
||||
*
|
||||
* @generated from field: repeated cosmos.base.abci.v1beta1.ABCIMessageLog logs = 7;
|
||||
*/
|
||||
logs: ABCIMessageLog[] = [];
|
||||
|
||||
/**
|
||||
* Additional information. May be non-deterministic.
|
||||
*
|
||||
* @generated from field: string info = 8;
|
||||
*/
|
||||
info = '';
|
||||
|
||||
/**
|
||||
* Amount of gas requested for transaction.
|
||||
*
|
||||
* @generated from field: int64 gas_wanted = 9;
|
||||
*/
|
||||
gasWanted = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* Amount of gas consumed by transaction.
|
||||
*
|
||||
* @generated from field: int64 gas_used = 10;
|
||||
*/
|
||||
gasUsed = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* The request transaction bytes.
|
||||
*
|
||||
* @generated from field: google.protobuf.Any tx = 11;
|
||||
*/
|
||||
tx?: Any;
|
||||
|
||||
/**
|
||||
* Time of the previous block. For heights > 1, it's the weighted median of
|
||||
* the timestamps of the valid votes in the block.LastCommit. For height == 1,
|
||||
* it's genesis time.
|
||||
*
|
||||
* @generated from field: string timestamp = 12;
|
||||
*/
|
||||
timestamp = '';
|
||||
|
||||
/**
|
||||
* Events defines all the events emitted by processing a transaction. Note,
|
||||
* these events include those emitted by processing all the messages and those
|
||||
* emitted from the ante. Whereas Logs contains the events, with
|
||||
* additional metadata, emitted only by processing the messages.
|
||||
*
|
||||
* Since: cosmos-sdk 0.42.11, 0.44.5, 0.45
|
||||
*
|
||||
* @generated from field: repeated tendermint.abci.Event events = 13;
|
||||
*/
|
||||
events: Event[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<TxResponse>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.TxResponse';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'height', kind: 'scalar', T: 3 /* ScalarType.INT64 */ },
|
||||
{ no: 2, name: 'txhash', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 3, name: 'codespace', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 4, name: 'code', kind: 'scalar', T: 13 /* ScalarType.UINT32 */ },
|
||||
{ no: 5, name: 'data', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 6, name: 'raw_log', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 7, name: 'logs', kind: 'message', T: ABCIMessageLog, repeated: true },
|
||||
{ no: 8, name: 'info', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 9, name: 'gas_wanted', kind: 'scalar', T: 3 /* ScalarType.INT64 */ },
|
||||
{ no: 10, name: 'gas_used', kind: 'scalar', T: 3 /* ScalarType.INT64 */ },
|
||||
{ no: 11, name: 'tx', kind: 'message', T: Any },
|
||||
{ no: 12, name: 'timestamp', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 13, name: 'events', kind: 'message', T: Event, repeated: true },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TxResponse {
|
||||
return new TxResponse().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TxResponse {
|
||||
return new TxResponse().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TxResponse {
|
||||
return new TxResponse().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: TxResponse | PlainMessage<TxResponse> | undefined,
|
||||
b: TxResponse | PlainMessage<TxResponse> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(TxResponse, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ABCIMessageLog defines a structure containing an indexed tx ABCI message log.
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.ABCIMessageLog
|
||||
*/
|
||||
export class ABCIMessageLog extends Message<ABCIMessageLog> {
|
||||
/**
|
||||
* @generated from field: uint32 msg_index = 1;
|
||||
*/
|
||||
msgIndex = 0;
|
||||
|
||||
/**
|
||||
* @generated from field: string log = 2;
|
||||
*/
|
||||
log = '';
|
||||
|
||||
/**
|
||||
* Events contains a slice of Event objects that were emitted during some
|
||||
* execution.
|
||||
*
|
||||
* @generated from field: repeated cosmos.base.abci.v1beta1.StringEvent events = 3;
|
||||
*/
|
||||
events: StringEvent[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<ABCIMessageLog>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.ABCIMessageLog';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'msg_index', kind: 'scalar', T: 13 /* ScalarType.UINT32 */ },
|
||||
{ no: 2, name: 'log', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 3, name: 'events', kind: 'message', T: StringEvent, repeated: true },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ABCIMessageLog {
|
||||
return new ABCIMessageLog().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ABCIMessageLog {
|
||||
return new ABCIMessageLog().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ABCIMessageLog {
|
||||
return new ABCIMessageLog().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ABCIMessageLog | PlainMessage<ABCIMessageLog> | undefined,
|
||||
b: ABCIMessageLog | PlainMessage<ABCIMessageLog> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ABCIMessageLog, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* StringEvent defines en Event object wrapper where all the attributes
|
||||
* contain key/value pairs that are strings instead of raw bytes.
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.StringEvent
|
||||
*/
|
||||
export class StringEvent extends Message<StringEvent> {
|
||||
/**
|
||||
* @generated from field: string type = 1;
|
||||
*/
|
||||
type = '';
|
||||
|
||||
/**
|
||||
* @generated from field: repeated cosmos.base.abci.v1beta1.Attribute attributes = 2;
|
||||
*/
|
||||
attributes: Attribute[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<StringEvent>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.StringEvent';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'type', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{
|
||||
no: 2,
|
||||
name: 'attributes',
|
||||
kind: 'message',
|
||||
T: Attribute,
|
||||
repeated: true,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StringEvent {
|
||||
return new StringEvent().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StringEvent {
|
||||
return new StringEvent().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StringEvent {
|
||||
return new StringEvent().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: StringEvent | PlainMessage<StringEvent> | undefined,
|
||||
b: StringEvent | PlainMessage<StringEvent> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(StringEvent, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Attribute defines an attribute wrapper where the key and value are
|
||||
* strings instead of raw bytes.
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.Attribute
|
||||
*/
|
||||
export class Attribute extends Message<Attribute> {
|
||||
/**
|
||||
* @generated from field: string key = 1;
|
||||
*/
|
||||
key = '';
|
||||
|
||||
/**
|
||||
* @generated from field: string value = 2;
|
||||
*/
|
||||
value = '';
|
||||
|
||||
constructor(data?: PartialMessage<Attribute>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.Attribute';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'key', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 2, name: 'value', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Attribute {
|
||||
return new Attribute().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Attribute {
|
||||
return new Attribute().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Attribute {
|
||||
return new Attribute().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Attribute | PlainMessage<Attribute> | undefined,
|
||||
b: Attribute | PlainMessage<Attribute> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Attribute, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* GasInfo defines tx execution gas context.
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.GasInfo
|
||||
*/
|
||||
export class GasInfo extends Message<GasInfo> {
|
||||
/**
|
||||
* GasWanted is the maximum units of work we allow this tx to perform.
|
||||
*
|
||||
* @generated from field: uint64 gas_wanted = 1;
|
||||
*/
|
||||
gasWanted = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* GasUsed is the amount of gas actually consumed.
|
||||
*
|
||||
* @generated from field: uint64 gas_used = 2;
|
||||
*/
|
||||
gasUsed = protoInt64.zero;
|
||||
|
||||
constructor(data?: PartialMessage<GasInfo>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.GasInfo';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'gas_wanted', kind: 'scalar', T: 4 /* ScalarType.UINT64 */ },
|
||||
{ no: 2, name: 'gas_used', kind: 'scalar', T: 4 /* ScalarType.UINT64 */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GasInfo {
|
||||
return new GasInfo().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GasInfo {
|
||||
return new GasInfo().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GasInfo {
|
||||
return new GasInfo().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: GasInfo | PlainMessage<GasInfo> | undefined,
|
||||
b: GasInfo | PlainMessage<GasInfo> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(GasInfo, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Result is the union of ResponseFormat and ResponseCheckTx.
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.Result
|
||||
*/
|
||||
export class Result extends Message<Result> {
|
||||
/**
|
||||
* Data is any data returned from message or handler execution. It MUST be
|
||||
* length prefixed in order to separate data from multiple message executions.
|
||||
* Deprecated. This field is still populated, but prefer msg_response instead
|
||||
* because it also contains the Msg response typeURL.
|
||||
*
|
||||
* @generated from field: bytes data = 1 [deprecated = true];
|
||||
* @deprecated
|
||||
*/
|
||||
data = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* Log contains the log information from message or handler execution.
|
||||
*
|
||||
* @generated from field: string log = 2;
|
||||
*/
|
||||
log = '';
|
||||
|
||||
/**
|
||||
* Events contains a slice of Event objects that were emitted during message
|
||||
* or handler execution.
|
||||
*
|
||||
* @generated from field: repeated tendermint.abci.Event events = 3;
|
||||
*/
|
||||
events: Event[] = [];
|
||||
|
||||
/**
|
||||
* msg_responses contains the Msg handler responses type packed in Anys.
|
||||
*
|
||||
* Since: cosmos-sdk 0.46
|
||||
*
|
||||
* @generated from field: repeated google.protobuf.Any msg_responses = 4;
|
||||
*/
|
||||
msgResponses: Any[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<Result>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.Result';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'data', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
|
||||
{ no: 2, name: 'log', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 3, name: 'events', kind: 'message', T: Event, repeated: true },
|
||||
{ no: 4, name: 'msg_responses', kind: 'message', T: Any, repeated: true },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Result {
|
||||
return new Result().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Result {
|
||||
return new Result().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Result {
|
||||
return new Result().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Result | PlainMessage<Result> | undefined,
|
||||
b: Result | PlainMessage<Result> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Result, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* SimulationResponse defines the response generated when a transaction is
|
||||
* successfully simulated.
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.SimulationResponse
|
||||
*/
|
||||
export class SimulationResponse extends Message<SimulationResponse> {
|
||||
/**
|
||||
* @generated from field: cosmos.base.abci.v1beta1.GasInfo gas_info = 1;
|
||||
*/
|
||||
gasInfo?: GasInfo;
|
||||
|
||||
/**
|
||||
* @generated from field: cosmos.base.abci.v1beta1.Result result = 2;
|
||||
*/
|
||||
result?: Result;
|
||||
|
||||
constructor(data?: PartialMessage<SimulationResponse>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.SimulationResponse';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'gas_info', kind: 'message', T: GasInfo },
|
||||
{ no: 2, name: 'result', kind: 'message', T: Result },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SimulationResponse {
|
||||
return new SimulationResponse().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SimulationResponse {
|
||||
return new SimulationResponse().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): SimulationResponse {
|
||||
return new SimulationResponse().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: SimulationResponse | PlainMessage<SimulationResponse> | undefined,
|
||||
b: SimulationResponse | PlainMessage<SimulationResponse> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(SimulationResponse, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* MsgData defines the data returned in a Result object during message
|
||||
* execution.
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.MsgData
|
||||
* @deprecated
|
||||
*/
|
||||
export class MsgData extends Message<MsgData> {
|
||||
/**
|
||||
* @generated from field: string msg_type = 1;
|
||||
*/
|
||||
msgType = '';
|
||||
|
||||
/**
|
||||
* @generated from field: bytes data = 2;
|
||||
*/
|
||||
data = new Uint8Array(0);
|
||||
|
||||
constructor(data?: PartialMessage<MsgData>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.MsgData';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'msg_type', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 2, name: 'data', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgData {
|
||||
return new MsgData().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgData {
|
||||
return new MsgData().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgData {
|
||||
return new MsgData().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: MsgData | PlainMessage<MsgData> | undefined,
|
||||
b: MsgData | PlainMessage<MsgData> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(MsgData, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* TxMsgData defines a list of MsgData. A transaction will have a MsgData object
|
||||
* for each message.
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.TxMsgData
|
||||
*/
|
||||
export class TxMsgData extends Message<TxMsgData> {
|
||||
/**
|
||||
* data field is deprecated and not populated.
|
||||
*
|
||||
* @generated from field: repeated cosmos.base.abci.v1beta1.MsgData data = 1 [deprecated = true];
|
||||
* @deprecated
|
||||
*/
|
||||
data: MsgData[] = [];
|
||||
|
||||
/**
|
||||
* msg_responses contains the Msg handler responses packed into Anys.
|
||||
*
|
||||
* Since: cosmos-sdk 0.46
|
||||
*
|
||||
* @generated from field: repeated google.protobuf.Any msg_responses = 2;
|
||||
*/
|
||||
msgResponses: Any[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<TxMsgData>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.TxMsgData';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'data', kind: 'message', T: MsgData, repeated: true },
|
||||
{ no: 2, name: 'msg_responses', kind: 'message', T: Any, repeated: true },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TxMsgData {
|
||||
return new TxMsgData().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TxMsgData {
|
||||
return new TxMsgData().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TxMsgData {
|
||||
return new TxMsgData().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: TxMsgData | PlainMessage<TxMsgData> | undefined,
|
||||
b: TxMsgData | PlainMessage<TxMsgData> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(TxMsgData, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* SearchTxsResult defines a structure for querying txs pageable
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.SearchTxsResult
|
||||
*/
|
||||
export class SearchTxsResult extends Message<SearchTxsResult> {
|
||||
/**
|
||||
* Count of all txs
|
||||
*
|
||||
* @generated from field: uint64 total_count = 1;
|
||||
*/
|
||||
totalCount = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* Count of txs in current page
|
||||
*
|
||||
* @generated from field: uint64 count = 2;
|
||||
*/
|
||||
count = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* Index of current page, start from 1
|
||||
*
|
||||
* @generated from field: uint64 page_number = 3;
|
||||
*/
|
||||
pageNumber = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* Count of total pages
|
||||
*
|
||||
* @generated from field: uint64 page_total = 4;
|
||||
*/
|
||||
pageTotal = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* Max count txs per page
|
||||
*
|
||||
* @generated from field: uint64 limit = 5;
|
||||
*/
|
||||
limit = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* List of txs in current page
|
||||
*
|
||||
* @generated from field: repeated cosmos.base.abci.v1beta1.TxResponse txs = 6;
|
||||
*/
|
||||
txs: TxResponse[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<SearchTxsResult>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.SearchTxsResult';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'total_count',
|
||||
kind: 'scalar',
|
||||
T: 4 /* ScalarType.UINT64 */,
|
||||
},
|
||||
{ no: 2, name: 'count', kind: 'scalar', T: 4 /* ScalarType.UINT64 */ },
|
||||
{
|
||||
no: 3,
|
||||
name: 'page_number',
|
||||
kind: 'scalar',
|
||||
T: 4 /* ScalarType.UINT64 */,
|
||||
},
|
||||
{ no: 4, name: 'page_total', kind: 'scalar', T: 4 /* ScalarType.UINT64 */ },
|
||||
{ no: 5, name: 'limit', kind: 'scalar', T: 4 /* ScalarType.UINT64 */ },
|
||||
{ no: 6, name: 'txs', kind: 'message', T: TxResponse, repeated: true },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SearchTxsResult {
|
||||
return new SearchTxsResult().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SearchTxsResult {
|
||||
return new SearchTxsResult().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SearchTxsResult {
|
||||
return new SearchTxsResult().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: SearchTxsResult | PlainMessage<SearchTxsResult> | undefined,
|
||||
b: SearchTxsResult | PlainMessage<SearchTxsResult> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(SearchTxsResult, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* SearchBlocksResult defines a structure for querying blocks pageable
|
||||
*
|
||||
* @generated from message cosmos.base.abci.v1beta1.SearchBlocksResult
|
||||
*/
|
||||
export class SearchBlocksResult extends Message<SearchBlocksResult> {
|
||||
/**
|
||||
* Count of all blocks
|
||||
*
|
||||
* @generated from field: int64 total_count = 1;
|
||||
*/
|
||||
totalCount = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* Count of blocks in current page
|
||||
*
|
||||
* @generated from field: int64 count = 2;
|
||||
*/
|
||||
count = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* Index of current page, start from 1
|
||||
*
|
||||
* @generated from field: int64 page_number = 3;
|
||||
*/
|
||||
pageNumber = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* Count of total pages
|
||||
*
|
||||
* @generated from field: int64 page_total = 4;
|
||||
*/
|
||||
pageTotal = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* Max count blocks per page
|
||||
*
|
||||
* @generated from field: int64 limit = 5;
|
||||
*/
|
||||
limit = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* List of blocks in current page
|
||||
*
|
||||
* @generated from field: repeated tendermint.types.Block blocks = 6;
|
||||
*/
|
||||
blocks: Block[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<SearchBlocksResult>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.abci.v1beta1.SearchBlocksResult';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'total_count', kind: 'scalar', T: 3 /* ScalarType.INT64 */ },
|
||||
{ no: 2, name: 'count', kind: 'scalar', T: 3 /* ScalarType.INT64 */ },
|
||||
{ no: 3, name: 'page_number', kind: 'scalar', T: 3 /* ScalarType.INT64 */ },
|
||||
{ no: 4, name: 'page_total', kind: 'scalar', T: 3 /* ScalarType.INT64 */ },
|
||||
{ no: 5, name: 'limit', kind: 'scalar', T: 3 /* ScalarType.INT64 */ },
|
||||
{ no: 6, name: 'blocks', kind: 'message', T: Block, repeated: true },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SearchBlocksResult {
|
||||
return new SearchBlocksResult().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SearchBlocksResult {
|
||||
return new SearchBlocksResult().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): SearchBlocksResult {
|
||||
return new SearchBlocksResult().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: SearchBlocksResult | PlainMessage<SearchBlocksResult> | undefined,
|
||||
b: SearchBlocksResult | PlainMessage<SearchBlocksResult> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(SearchBlocksResult, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/node/v1beta1/query.proto (package cosmos.base.node.v1beta1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import { ConfigRequest, ConfigResponse, StatusRequest, StatusResponse } from './query_pb.js';
|
||||
|
||||
const TYPE_NAME = 'cosmos.base.node.v1beta1.Service';
|
||||
|
||||
/**
|
||||
* Config queries for the operator configuration.
|
||||
*
|
||||
* @generated from rpc cosmos.base.node.v1beta1.Service.Config
|
||||
*/
|
||||
export const ServiceConfigService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'Config',
|
||||
Request: ConfigRequest,
|
||||
Response: ConfigResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Status queries for the node status.
|
||||
*
|
||||
* @generated from rpc cosmos.base.node.v1beta1.Service.Status
|
||||
*/
|
||||
export const ServiceStatusService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'Status',
|
||||
Request: StatusRequest,
|
||||
Response: StatusResponse,
|
||||
} as const;
|
||||
@@ -0,0 +1,250 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/node/v1beta1/query.proto (package cosmos.base.node.v1beta1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, Timestamp, proto3, protoInt64 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* ConfigRequest defines the request structure for the Config gRPC query.
|
||||
*
|
||||
* @generated from message cosmos.base.node.v1beta1.ConfigRequest
|
||||
*/
|
||||
export class ConfigRequest extends Message<ConfigRequest> {
|
||||
constructor(data?: PartialMessage<ConfigRequest>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.node.v1beta1.ConfigRequest';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => []);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConfigRequest {
|
||||
return new ConfigRequest().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConfigRequest {
|
||||
return new ConfigRequest().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConfigRequest {
|
||||
return new ConfigRequest().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ConfigRequest | PlainMessage<ConfigRequest> | undefined,
|
||||
b: ConfigRequest | PlainMessage<ConfigRequest> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ConfigRequest, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ConfigResponse defines the response structure for the Config gRPC query.
|
||||
*
|
||||
* @generated from message cosmos.base.node.v1beta1.ConfigResponse
|
||||
*/
|
||||
export class ConfigResponse extends Message<ConfigResponse> {
|
||||
/**
|
||||
* @generated from field: string minimum_gas_price = 1;
|
||||
*/
|
||||
minimumGasPrice = '';
|
||||
|
||||
/**
|
||||
* @generated from field: string pruning_keep_recent = 2;
|
||||
*/
|
||||
pruningKeepRecent = '';
|
||||
|
||||
/**
|
||||
* @generated from field: string pruning_interval = 3;
|
||||
*/
|
||||
pruningInterval = '';
|
||||
|
||||
/**
|
||||
* @generated from field: uint64 halt_height = 4;
|
||||
*/
|
||||
haltHeight = protoInt64.zero;
|
||||
|
||||
constructor(data?: PartialMessage<ConfigResponse>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.node.v1beta1.ConfigResponse';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'minimum_gas_price',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
{
|
||||
no: 2,
|
||||
name: 'pruning_keep_recent',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
{
|
||||
no: 3,
|
||||
name: 'pruning_interval',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
{
|
||||
no: 4,
|
||||
name: 'halt_height',
|
||||
kind: 'scalar',
|
||||
T: 4 /* ScalarType.UINT64 */,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConfigResponse {
|
||||
return new ConfigResponse().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConfigResponse {
|
||||
return new ConfigResponse().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConfigResponse {
|
||||
return new ConfigResponse().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ConfigResponse | PlainMessage<ConfigResponse> | undefined,
|
||||
b: ConfigResponse | PlainMessage<ConfigResponse> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ConfigResponse, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* StateRequest defines the request structure for the status of a node.
|
||||
*
|
||||
* @generated from message cosmos.base.node.v1beta1.StatusRequest
|
||||
*/
|
||||
export class StatusRequest extends Message<StatusRequest> {
|
||||
constructor(data?: PartialMessage<StatusRequest>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.node.v1beta1.StatusRequest';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => []);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StatusRequest {
|
||||
return new StatusRequest().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StatusRequest {
|
||||
return new StatusRequest().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StatusRequest {
|
||||
return new StatusRequest().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: StatusRequest | PlainMessage<StatusRequest> | undefined,
|
||||
b: StatusRequest | PlainMessage<StatusRequest> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(StatusRequest, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* StateResponse defines the response structure for the status of a node.
|
||||
*
|
||||
* @generated from message cosmos.base.node.v1beta1.StatusResponse
|
||||
*/
|
||||
export class StatusResponse extends Message<StatusResponse> {
|
||||
/**
|
||||
* earliest block height available in the store
|
||||
*
|
||||
* @generated from field: uint64 earliest_store_height = 1;
|
||||
*/
|
||||
earliestStoreHeight = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* current block height
|
||||
*
|
||||
* @generated from field: uint64 height = 2;
|
||||
*/
|
||||
height = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* block height timestamp
|
||||
*
|
||||
* @generated from field: google.protobuf.Timestamp timestamp = 3;
|
||||
*/
|
||||
timestamp?: Timestamp;
|
||||
|
||||
/**
|
||||
* app hash of the current block
|
||||
*
|
||||
* @generated from field: bytes app_hash = 4;
|
||||
*/
|
||||
appHash = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* validator hash provided by the consensus header
|
||||
*
|
||||
* @generated from field: bytes validator_hash = 5;
|
||||
*/
|
||||
validatorHash = new Uint8Array(0);
|
||||
|
||||
constructor(data?: PartialMessage<StatusResponse>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.node.v1beta1.StatusResponse';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'earliest_store_height',
|
||||
kind: 'scalar',
|
||||
T: 4 /* ScalarType.UINT64 */,
|
||||
},
|
||||
{ no: 2, name: 'height', kind: 'scalar', T: 4 /* ScalarType.UINT64 */ },
|
||||
{ no: 3, name: 'timestamp', kind: 'message', T: Timestamp },
|
||||
{ no: 4, name: 'app_hash', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
|
||||
{
|
||||
no: 5,
|
||||
name: 'validator_hash',
|
||||
kind: 'scalar',
|
||||
T: 12 /* ScalarType.BYTES */,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StatusResponse {
|
||||
return new StatusResponse().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StatusResponse {
|
||||
return new StatusResponse().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StatusResponse {
|
||||
return new StatusResponse().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: StatusResponse | PlainMessage<StatusResponse> | undefined,
|
||||
b: StatusResponse | PlainMessage<StatusResponse> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(StatusResponse, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,167 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/query/v1beta1/pagination.proto (package cosmos.base.query.v1beta1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3, protoInt64 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* PageRequest is to be embedded in gRPC request messages for efficient
|
||||
* pagination. Ex:
|
||||
*
|
||||
* message SomeRequest {
|
||||
* Foo some_parameter = 1;
|
||||
* PageRequest pagination = 2;
|
||||
* }
|
||||
*
|
||||
* @generated from message cosmos.base.query.v1beta1.PageRequest
|
||||
*/
|
||||
export class PageRequest extends Message<PageRequest> {
|
||||
/**
|
||||
* key is a value returned in PageResponse.next_key to begin
|
||||
* querying the next page most efficiently. Only one of offset or key
|
||||
* should be set.
|
||||
*
|
||||
* @generated from field: bytes key = 1;
|
||||
*/
|
||||
key = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* offset is a numeric offset that can be used when key is unavailable.
|
||||
* It is less efficient than using key. Only one of offset or key should
|
||||
* be set.
|
||||
*
|
||||
* @generated from field: uint64 offset = 2;
|
||||
*/
|
||||
offset = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* limit is the total number of results to be returned in the result page.
|
||||
* If left empty it will default to a value to be set by each app.
|
||||
*
|
||||
* @generated from field: uint64 limit = 3;
|
||||
*/
|
||||
limit = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* count_total is set to true to indicate that the result set should include
|
||||
* a count of the total number of items available for pagination in UIs.
|
||||
* count_total is only respected when offset is used. It is ignored when key
|
||||
* is set.
|
||||
*
|
||||
* @generated from field: bool count_total = 4;
|
||||
*/
|
||||
countTotal = false;
|
||||
|
||||
/**
|
||||
* reverse is set to true if results are to be returned in the descending order.
|
||||
*
|
||||
* Since: cosmos-sdk 0.43
|
||||
*
|
||||
* @generated from field: bool reverse = 5;
|
||||
*/
|
||||
reverse = false;
|
||||
|
||||
constructor(data?: PartialMessage<PageRequest>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.query.v1beta1.PageRequest';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'key', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
|
||||
{ no: 2, name: 'offset', kind: 'scalar', T: 4 /* ScalarType.UINT64 */ },
|
||||
{ no: 3, name: 'limit', kind: 'scalar', T: 4 /* ScalarType.UINT64 */ },
|
||||
{ no: 4, name: 'count_total', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
|
||||
{ no: 5, name: 'reverse', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PageRequest {
|
||||
return new PageRequest().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PageRequest {
|
||||
return new PageRequest().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PageRequest {
|
||||
return new PageRequest().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: PageRequest | PlainMessage<PageRequest> | undefined,
|
||||
b: PageRequest | PlainMessage<PageRequest> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(PageRequest, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* PageResponse is to be embedded in gRPC response messages where the
|
||||
* corresponding request message has used PageRequest.
|
||||
*
|
||||
* message SomeResponse {
|
||||
* repeated Bar results = 1;
|
||||
* PageResponse page = 2;
|
||||
* }
|
||||
*
|
||||
* @generated from message cosmos.base.query.v1beta1.PageResponse
|
||||
*/
|
||||
export class PageResponse extends Message<PageResponse> {
|
||||
/**
|
||||
* next_key is the key to be passed to PageRequest.key to
|
||||
* query the next page most efficiently. It will be empty if
|
||||
* there are no more results.
|
||||
*
|
||||
* @generated from field: bytes next_key = 1;
|
||||
*/
|
||||
nextKey = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* total is total number of results available if PageRequest.count_total
|
||||
* was set, its value is undefined otherwise
|
||||
*
|
||||
* @generated from field: uint64 total = 2;
|
||||
*/
|
||||
total = protoInt64.zero;
|
||||
|
||||
constructor(data?: PartialMessage<PageResponse>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.query.v1beta1.PageResponse';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'next_key', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
|
||||
{ no: 2, name: 'total', kind: 'scalar', T: 4 /* ScalarType.UINT64 */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PageResponse {
|
||||
return new PageResponse().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PageResponse {
|
||||
return new PageResponse().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PageResponse {
|
||||
return new PageResponse().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: PageResponse | PlainMessage<PageResponse> | undefined,
|
||||
b: PageResponse | PlainMessage<PageResponse> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(PageResponse, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/reflection/v1beta1/reflection.proto (package cosmos.base.reflection.v1beta1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import {
|
||||
ListAllInterfacesRequest,
|
||||
ListAllInterfacesResponse,
|
||||
ListImplementationsRequest,
|
||||
ListImplementationsResponse,
|
||||
} from './reflection_pb.js';
|
||||
|
||||
const TYPE_NAME = 'cosmos.base.reflection.v1beta1.ReflectionService';
|
||||
|
||||
/**
|
||||
* ListAllInterfaces lists all the interfaces registered in the interface
|
||||
* registry.
|
||||
*
|
||||
* @generated from rpc cosmos.base.reflection.v1beta1.ReflectionService.ListAllInterfaces
|
||||
*/
|
||||
export const ReflectionServiceListAllInterfacesService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'ListAllInterfaces',
|
||||
Request: ListAllInterfacesRequest,
|
||||
Response: ListAllInterfacesResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* ListImplementations list all the concrete types that implement a given
|
||||
* interface.
|
||||
*
|
||||
* @generated from rpc cosmos.base.reflection.v1beta1.ReflectionService.ListImplementations
|
||||
*/
|
||||
export const ReflectionServiceListImplementationsService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'ListImplementations',
|
||||
Request: ListImplementationsRequest,
|
||||
Response: ListImplementationsResponse,
|
||||
} as const;
|
||||
@@ -0,0 +1,234 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/reflection/v1beta1/reflection.proto (package cosmos.base.reflection.v1beta1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* ListAllInterfacesRequest is the request type of the ListAllInterfaces RPC.
|
||||
*
|
||||
* @generated from message cosmos.base.reflection.v1beta1.ListAllInterfacesRequest
|
||||
*/
|
||||
export class ListAllInterfacesRequest extends Message<ListAllInterfacesRequest> {
|
||||
constructor(data?: PartialMessage<ListAllInterfacesRequest>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.reflection.v1beta1.ListAllInterfacesRequest';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => []);
|
||||
|
||||
static fromBinary(
|
||||
bytes: Uint8Array,
|
||||
options?: Partial<BinaryReadOptions>
|
||||
): ListAllInterfacesRequest {
|
||||
return new ListAllInterfacesRequest().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(
|
||||
jsonValue: JsonValue,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ListAllInterfacesRequest {
|
||||
return new ListAllInterfacesRequest().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ListAllInterfacesRequest {
|
||||
return new ListAllInterfacesRequest().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ListAllInterfacesRequest | PlainMessage<ListAllInterfacesRequest> | undefined,
|
||||
b: ListAllInterfacesRequest | PlainMessage<ListAllInterfacesRequest> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ListAllInterfacesRequest, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ListAllInterfacesResponse is the response type of the ListAllInterfaces RPC.
|
||||
*
|
||||
* @generated from message cosmos.base.reflection.v1beta1.ListAllInterfacesResponse
|
||||
*/
|
||||
export class ListAllInterfacesResponse extends Message<ListAllInterfacesResponse> {
|
||||
/**
|
||||
* interface_names is an array of all the registered interfaces.
|
||||
*
|
||||
* @generated from field: repeated string interface_names = 1;
|
||||
*/
|
||||
interfaceNames: string[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<ListAllInterfacesResponse>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.reflection.v1beta1.ListAllInterfacesResponse';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'interface_names',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(
|
||||
bytes: Uint8Array,
|
||||
options?: Partial<BinaryReadOptions>
|
||||
): ListAllInterfacesResponse {
|
||||
return new ListAllInterfacesResponse().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(
|
||||
jsonValue: JsonValue,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ListAllInterfacesResponse {
|
||||
return new ListAllInterfacesResponse().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ListAllInterfacesResponse {
|
||||
return new ListAllInterfacesResponse().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ListAllInterfacesResponse | PlainMessage<ListAllInterfacesResponse> | undefined,
|
||||
b: ListAllInterfacesResponse | PlainMessage<ListAllInterfacesResponse> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ListAllInterfacesResponse, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ListImplementationsRequest is the request type of the ListImplementations
|
||||
* RPC.
|
||||
*
|
||||
* @generated from message cosmos.base.reflection.v1beta1.ListImplementationsRequest
|
||||
*/
|
||||
export class ListImplementationsRequest extends Message<ListImplementationsRequest> {
|
||||
/**
|
||||
* interface_name defines the interface to query the implementations for.
|
||||
*
|
||||
* @generated from field: string interface_name = 1;
|
||||
*/
|
||||
interfaceName = '';
|
||||
|
||||
constructor(data?: PartialMessage<ListImplementationsRequest>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.reflection.v1beta1.ListImplementationsRequest';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'interface_name',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(
|
||||
bytes: Uint8Array,
|
||||
options?: Partial<BinaryReadOptions>
|
||||
): ListImplementationsRequest {
|
||||
return new ListImplementationsRequest().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(
|
||||
jsonValue: JsonValue,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ListImplementationsRequest {
|
||||
return new ListImplementationsRequest().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ListImplementationsRequest {
|
||||
return new ListImplementationsRequest().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ListImplementationsRequest | PlainMessage<ListImplementationsRequest> | undefined,
|
||||
b: ListImplementationsRequest | PlainMessage<ListImplementationsRequest> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ListImplementationsRequest, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ListImplementationsResponse is the response type of the ListImplementations
|
||||
* RPC.
|
||||
*
|
||||
* @generated from message cosmos.base.reflection.v1beta1.ListImplementationsResponse
|
||||
*/
|
||||
export class ListImplementationsResponse extends Message<ListImplementationsResponse> {
|
||||
/**
|
||||
* @generated from field: repeated string implementation_message_names = 1;
|
||||
*/
|
||||
implementationMessageNames: string[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<ListImplementationsResponse>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.reflection.v1beta1.ListImplementationsResponse';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{
|
||||
no: 1,
|
||||
name: 'implementation_message_names',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
repeated: true,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(
|
||||
bytes: Uint8Array,
|
||||
options?: Partial<BinaryReadOptions>
|
||||
): ListImplementationsResponse {
|
||||
return new ListImplementationsResponse().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(
|
||||
jsonValue: JsonValue,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ListImplementationsResponse {
|
||||
return new ListImplementationsResponse().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(
|
||||
jsonString: string,
|
||||
options?: Partial<JsonReadOptions>
|
||||
): ListImplementationsResponse {
|
||||
return new ListImplementationsResponse().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: ListImplementationsResponse | PlainMessage<ListImplementationsResponse> | undefined,
|
||||
b: ListImplementationsResponse | PlainMessage<ListImplementationsResponse> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(ListImplementationsResponse, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
// Since: cosmos-sdk 0.43
|
||||
|
||||
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/reflection/v2alpha1/reflection.proto (package cosmos.base.reflection.v2alpha1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import {
|
||||
GetAuthnDescriptorRequest,
|
||||
GetAuthnDescriptorResponse,
|
||||
GetChainDescriptorRequest,
|
||||
GetChainDescriptorResponse,
|
||||
GetCodecDescriptorRequest,
|
||||
GetCodecDescriptorResponse,
|
||||
GetConfigurationDescriptorRequest,
|
||||
GetConfigurationDescriptorResponse,
|
||||
GetQueryServicesDescriptorRequest,
|
||||
GetQueryServicesDescriptorResponse,
|
||||
GetTxDescriptorRequest,
|
||||
GetTxDescriptorResponse,
|
||||
} from './reflection_pb.js';
|
||||
|
||||
const TYPE_NAME = 'cosmos.base.reflection.v2alpha1.ReflectionService';
|
||||
|
||||
/**
|
||||
* GetAuthnDescriptor returns information on how to authenticate transactions in the application
|
||||
* NOTE: this RPC is still experimental and might be subject to breaking changes or removal in
|
||||
* future releases of the cosmos-sdk.
|
||||
*
|
||||
* @generated from rpc cosmos.base.reflection.v2alpha1.ReflectionService.GetAuthnDescriptor
|
||||
*/
|
||||
export const ReflectionServiceGetAuthnDescriptorService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetAuthnDescriptor',
|
||||
Request: GetAuthnDescriptorRequest,
|
||||
Response: GetAuthnDescriptorResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetChainDescriptor returns the description of the chain
|
||||
*
|
||||
* @generated from rpc cosmos.base.reflection.v2alpha1.ReflectionService.GetChainDescriptor
|
||||
*/
|
||||
export const ReflectionServiceGetChainDescriptorService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetChainDescriptor',
|
||||
Request: GetChainDescriptorRequest,
|
||||
Response: GetChainDescriptorResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetCodecDescriptor returns the descriptor of the codec of the application
|
||||
*
|
||||
* @generated from rpc cosmos.base.reflection.v2alpha1.ReflectionService.GetCodecDescriptor
|
||||
*/
|
||||
export const ReflectionServiceGetCodecDescriptorService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetCodecDescriptor',
|
||||
Request: GetCodecDescriptorRequest,
|
||||
Response: GetCodecDescriptorResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetConfigurationDescriptor returns the descriptor for the sdk.Config of the application
|
||||
*
|
||||
* @generated from rpc cosmos.base.reflection.v2alpha1.ReflectionService.GetConfigurationDescriptor
|
||||
*/
|
||||
export const ReflectionServiceGetConfigurationDescriptorService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetConfigurationDescriptor',
|
||||
Request: GetConfigurationDescriptorRequest,
|
||||
Response: GetConfigurationDescriptorResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetQueryServicesDescriptor returns the available gRPC queryable services of the application
|
||||
*
|
||||
* @generated from rpc cosmos.base.reflection.v2alpha1.ReflectionService.GetQueryServicesDescriptor
|
||||
*/
|
||||
export const ReflectionServiceGetQueryServicesDescriptorService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetQueryServicesDescriptor',
|
||||
Request: GetQueryServicesDescriptorRequest,
|
||||
Response: GetQueryServicesDescriptorResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetTxDescriptor returns information on the used transaction object and available msgs that can be used
|
||||
*
|
||||
* @generated from rpc cosmos.base.reflection.v2alpha1.ReflectionService.GetTxDescriptor
|
||||
*/
|
||||
export const ReflectionServiceGetTxDescriptorService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetTxDescriptor',
|
||||
Request: GetTxDescriptorRequest,
|
||||
Response: GetTxDescriptorResponse,
|
||||
} as const;
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,111 @@
|
||||
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/tendermint/v1beta1/query.proto (package cosmos.base.tendermint.v1beta1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import {
|
||||
ABCIQueryRequest,
|
||||
ABCIQueryResponse,
|
||||
GetBlockByHeightRequest,
|
||||
GetBlockByHeightResponse,
|
||||
GetLatestBlockRequest,
|
||||
GetLatestBlockResponse,
|
||||
GetLatestValidatorSetRequest,
|
||||
GetLatestValidatorSetResponse,
|
||||
GetNodeInfoRequest,
|
||||
GetNodeInfoResponse,
|
||||
GetSyncingRequest,
|
||||
GetSyncingResponse,
|
||||
GetValidatorSetByHeightRequest,
|
||||
GetValidatorSetByHeightResponse,
|
||||
} from './query_pb.js';
|
||||
|
||||
const TYPE_NAME = 'cosmos.base.tendermint.v1beta1.Service';
|
||||
|
||||
/**
|
||||
* GetNodeInfo queries the current node info.
|
||||
*
|
||||
* @generated from rpc cosmos.base.tendermint.v1beta1.Service.GetNodeInfo
|
||||
*/
|
||||
export const ServiceGetNodeInfoService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetNodeInfo',
|
||||
Request: GetNodeInfoRequest,
|
||||
Response: GetNodeInfoResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetSyncing queries node syncing.
|
||||
*
|
||||
* @generated from rpc cosmos.base.tendermint.v1beta1.Service.GetSyncing
|
||||
*/
|
||||
export const ServiceGetSyncingService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetSyncing',
|
||||
Request: GetSyncingRequest,
|
||||
Response: GetSyncingResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetLatestBlock returns the latest block.
|
||||
*
|
||||
* @generated from rpc cosmos.base.tendermint.v1beta1.Service.GetLatestBlock
|
||||
*/
|
||||
export const ServiceGetLatestBlockService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetLatestBlock',
|
||||
Request: GetLatestBlockRequest,
|
||||
Response: GetLatestBlockResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetBlockByHeight queries block for given height.
|
||||
*
|
||||
* @generated from rpc cosmos.base.tendermint.v1beta1.Service.GetBlockByHeight
|
||||
*/
|
||||
export const ServiceGetBlockByHeightService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetBlockByHeight',
|
||||
Request: GetBlockByHeightRequest,
|
||||
Response: GetBlockByHeightResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetLatestValidatorSet queries latest validator-set.
|
||||
*
|
||||
* @generated from rpc cosmos.base.tendermint.v1beta1.Service.GetLatestValidatorSet
|
||||
*/
|
||||
export const ServiceGetLatestValidatorSetService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetLatestValidatorSet',
|
||||
Request: GetLatestValidatorSetRequest,
|
||||
Response: GetLatestValidatorSetResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* GetValidatorSetByHeight queries validator-set at a given height.
|
||||
*
|
||||
* @generated from rpc cosmos.base.tendermint.v1beta1.Service.GetValidatorSetByHeight
|
||||
*/
|
||||
export const ServiceGetValidatorSetByHeightService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'GetValidatorSetByHeight',
|
||||
Request: GetValidatorSetByHeightRequest,
|
||||
Response: GetValidatorSetByHeightResponse,
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* ABCIQuery defines a query handler that supports ABCI queries directly to the
|
||||
* application, bypassing Tendermint completely. The ABCI query must contain
|
||||
* a valid and supported path, including app, custom, p2p, and store.
|
||||
*
|
||||
* Since: cosmos-sdk 0.46
|
||||
*
|
||||
* @generated from rpc cosmos.base.tendermint.v1beta1.Service.ABCIQuery
|
||||
*/
|
||||
export const ServiceABCIQueryService = {
|
||||
typeName: TYPE_NAME,
|
||||
method: 'ABCIQuery',
|
||||
Request: ABCIQueryRequest,
|
||||
Response: ABCIQueryResponse,
|
||||
} as const;
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,265 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/tendermint/v1beta1/types.proto (package cosmos.base.tendermint.v1beta1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, Timestamp, proto3, protoInt64 } from '@bufbuild/protobuf';
|
||||
import { EvidenceList } from '../../../../tendermint/types/evidence_pb.js';
|
||||
import { BlockID, Commit, Data } from '../../../../tendermint/types/types_pb.js';
|
||||
import { Consensus } from '../../../../tendermint/version/types_pb.js';
|
||||
|
||||
/**
|
||||
* Block is tendermint type Block, with the Header proposer address
|
||||
* field converted to bech32 string.
|
||||
*
|
||||
* @generated from message cosmos.base.tendermint.v1beta1.Block
|
||||
*/
|
||||
export class Block extends Message<Block> {
|
||||
/**
|
||||
* @generated from field: cosmos.base.tendermint.v1beta1.Header header = 1;
|
||||
*/
|
||||
header?: Header;
|
||||
|
||||
/**
|
||||
* @generated from field: tendermint.types.Data data = 2;
|
||||
*/
|
||||
data?: Data;
|
||||
|
||||
/**
|
||||
* @generated from field: tendermint.types.EvidenceList evidence = 3;
|
||||
*/
|
||||
evidence?: EvidenceList;
|
||||
|
||||
/**
|
||||
* @generated from field: tendermint.types.Commit last_commit = 4;
|
||||
*/
|
||||
lastCommit?: Commit;
|
||||
|
||||
constructor(data?: PartialMessage<Block>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.tendermint.v1beta1.Block';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'header', kind: 'message', T: Header },
|
||||
{ no: 2, name: 'data', kind: 'message', T: Data },
|
||||
{ no: 3, name: 'evidence', kind: 'message', T: EvidenceList },
|
||||
{ no: 4, name: 'last_commit', kind: 'message', T: Commit },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Block {
|
||||
return new Block().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Block {
|
||||
return new Block().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Block {
|
||||
return new Block().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Block | PlainMessage<Block> | undefined,
|
||||
b: Block | PlainMessage<Block> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Block, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Header defines the structure of a Tendermint block header.
|
||||
*
|
||||
* @generated from message cosmos.base.tendermint.v1beta1.Header
|
||||
*/
|
||||
export class Header extends Message<Header> {
|
||||
/**
|
||||
* basic block info
|
||||
*
|
||||
* @generated from field: tendermint.version.Consensus version = 1;
|
||||
*/
|
||||
version?: Consensus;
|
||||
|
||||
/**
|
||||
* @generated from field: string chain_id = 2;
|
||||
*/
|
||||
chainId = '';
|
||||
|
||||
/**
|
||||
* @generated from field: int64 height = 3;
|
||||
*/
|
||||
height = protoInt64.zero;
|
||||
|
||||
/**
|
||||
* @generated from field: google.protobuf.Timestamp time = 4;
|
||||
*/
|
||||
time?: Timestamp;
|
||||
|
||||
/**
|
||||
* prev block info
|
||||
*
|
||||
* @generated from field: tendermint.types.BlockID last_block_id = 5;
|
||||
*/
|
||||
lastBlockId?: BlockID;
|
||||
|
||||
/**
|
||||
* hashes of block data
|
||||
*
|
||||
* commit from validators from the last block
|
||||
*
|
||||
* @generated from field: bytes last_commit_hash = 6;
|
||||
*/
|
||||
lastCommitHash = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* transactions
|
||||
*
|
||||
* @generated from field: bytes data_hash = 7;
|
||||
*/
|
||||
dataHash = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* hashes from the app output from the prev block
|
||||
*
|
||||
* validators for the current block
|
||||
*
|
||||
* @generated from field: bytes validators_hash = 8;
|
||||
*/
|
||||
validatorsHash = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* validators for the next block
|
||||
*
|
||||
* @generated from field: bytes next_validators_hash = 9;
|
||||
*/
|
||||
nextValidatorsHash = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* consensus params for current block
|
||||
*
|
||||
* @generated from field: bytes consensus_hash = 10;
|
||||
*/
|
||||
consensusHash = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* state after txs from the previous block
|
||||
*
|
||||
* @generated from field: bytes app_hash = 11;
|
||||
*/
|
||||
appHash = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* root hash of all results from the txs from the previous block
|
||||
*
|
||||
* @generated from field: bytes last_results_hash = 12;
|
||||
*/
|
||||
lastResultsHash = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* consensus info
|
||||
*
|
||||
* evidence included in the block
|
||||
*
|
||||
* @generated from field: bytes evidence_hash = 13;
|
||||
*/
|
||||
evidenceHash = new Uint8Array(0);
|
||||
|
||||
/**
|
||||
* proposer_address is the original block proposer address, formatted as a Bech32 string.
|
||||
* In Tendermint, this type is `bytes`, but in the SDK, we convert it to a Bech32 string
|
||||
* for better UX.
|
||||
*
|
||||
* original proposer of the block
|
||||
*
|
||||
* @generated from field: string proposer_address = 14;
|
||||
*/
|
||||
proposerAddress = '';
|
||||
|
||||
constructor(data?: PartialMessage<Header>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.tendermint.v1beta1.Header';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'version', kind: 'message', T: Consensus },
|
||||
{ no: 2, name: 'chain_id', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 3, name: 'height', kind: 'scalar', T: 3 /* ScalarType.INT64 */ },
|
||||
{ no: 4, name: 'time', kind: 'message', T: Timestamp },
|
||||
{ no: 5, name: 'last_block_id', kind: 'message', T: BlockID },
|
||||
{
|
||||
no: 6,
|
||||
name: 'last_commit_hash',
|
||||
kind: 'scalar',
|
||||
T: 12 /* ScalarType.BYTES */,
|
||||
},
|
||||
{ no: 7, name: 'data_hash', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
|
||||
{
|
||||
no: 8,
|
||||
name: 'validators_hash',
|
||||
kind: 'scalar',
|
||||
T: 12 /* ScalarType.BYTES */,
|
||||
},
|
||||
{
|
||||
no: 9,
|
||||
name: 'next_validators_hash',
|
||||
kind: 'scalar',
|
||||
T: 12 /* ScalarType.BYTES */,
|
||||
},
|
||||
{
|
||||
no: 10,
|
||||
name: 'consensus_hash',
|
||||
kind: 'scalar',
|
||||
T: 12 /* ScalarType.BYTES */,
|
||||
},
|
||||
{ no: 11, name: 'app_hash', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
|
||||
{
|
||||
no: 12,
|
||||
name: 'last_results_hash',
|
||||
kind: 'scalar',
|
||||
T: 12 /* ScalarType.BYTES */,
|
||||
},
|
||||
{
|
||||
no: 13,
|
||||
name: 'evidence_hash',
|
||||
kind: 'scalar',
|
||||
T: 12 /* ScalarType.BYTES */,
|
||||
},
|
||||
{
|
||||
no: 14,
|
||||
name: 'proposer_address',
|
||||
kind: 'scalar',
|
||||
T: 9 /* ScalarType.STRING */,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Header {
|
||||
return new Header().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Header {
|
||||
return new Header().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Header {
|
||||
return new Header().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Header | PlainMessage<Header> | undefined,
|
||||
b: Header | PlainMessage<Header> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Header, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/base/v1beta1/coin.proto (package cosmos.base.v1beta1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* Coin defines a token with a denomination and an amount.
|
||||
*
|
||||
* NOTE: The amount field is an Int which implements the custom method
|
||||
* signatures required by gogoproto.
|
||||
*
|
||||
* @generated from message cosmos.base.v1beta1.Coin
|
||||
*/
|
||||
export class Coin extends Message<Coin> {
|
||||
/**
|
||||
* @generated from field: string denom = 1;
|
||||
*/
|
||||
denom = '';
|
||||
|
||||
/**
|
||||
* @generated from field: string amount = 2;
|
||||
*/
|
||||
amount = '';
|
||||
|
||||
constructor(data?: PartialMessage<Coin>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.v1beta1.Coin';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'denom', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 2, name: 'amount', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Coin {
|
||||
return new Coin().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Coin {
|
||||
return new Coin().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Coin {
|
||||
return new Coin().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Coin | PlainMessage<Coin> | undefined,
|
||||
b: Coin | PlainMessage<Coin> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Coin, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* DecCoin defines a token with a denomination and a decimal amount.
|
||||
*
|
||||
* NOTE: The amount field is an Dec which implements the custom method
|
||||
* signatures required by gogoproto.
|
||||
*
|
||||
* @generated from message cosmos.base.v1beta1.DecCoin
|
||||
*/
|
||||
export class DecCoin extends Message<DecCoin> {
|
||||
/**
|
||||
* @generated from field: string denom = 1;
|
||||
*/
|
||||
denom = '';
|
||||
|
||||
/**
|
||||
* @generated from field: string amount = 2;
|
||||
*/
|
||||
amount = '';
|
||||
|
||||
constructor(data?: PartialMessage<DecCoin>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.v1beta1.DecCoin';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'denom', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 2, name: 'amount', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DecCoin {
|
||||
return new DecCoin().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DecCoin {
|
||||
return new DecCoin().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DecCoin {
|
||||
return new DecCoin().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: DecCoin | PlainMessage<DecCoin> | undefined,
|
||||
b: DecCoin | PlainMessage<DecCoin> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(DecCoin, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* IntProto defines a Protobuf wrapper around an Int object.
|
||||
* Deprecated: Prefer to use math.Int directly. It supports binary Marshal and Unmarshal.
|
||||
*
|
||||
* @generated from message cosmos.base.v1beta1.IntProto
|
||||
*/
|
||||
export class IntProto extends Message<IntProto> {
|
||||
/**
|
||||
* @generated from field: string int = 1;
|
||||
*/
|
||||
int = '';
|
||||
|
||||
constructor(data?: PartialMessage<IntProto>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.v1beta1.IntProto';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'int', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IntProto {
|
||||
return new IntProto().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IntProto {
|
||||
return new IntProto().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IntProto {
|
||||
return new IntProto().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: IntProto | PlainMessage<IntProto> | undefined,
|
||||
b: IntProto | PlainMessage<IntProto> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(IntProto, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* DecProto defines a Protobuf wrapper around a Dec object.
|
||||
* Deprecated: Prefer to use math.LegacyDec directly. It supports binary Marshal and Unmarshal.
|
||||
*
|
||||
* @generated from message cosmos.base.v1beta1.DecProto
|
||||
*/
|
||||
export class DecProto extends Message<DecProto> {
|
||||
/**
|
||||
* @generated from field: string dec = 1;
|
||||
*/
|
||||
dec = '';
|
||||
|
||||
constructor(data?: PartialMessage<DecProto>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.base.v1beta1.DecProto';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'dec', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DecProto {
|
||||
return new DecProto().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DecProto {
|
||||
return new DecProto().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DecProto {
|
||||
return new DecProto().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: DecProto | PlainMessage<DecProto> | undefined,
|
||||
b: DecProto | PlainMessage<DecProto> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(DecProto, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/crypto/ed25519/keys.proto (package cosmos.crypto.ed25519, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* PubKey is an ed25519 public key for handling Tendermint keys in SDK.
|
||||
* It's needed for Any serialization and SDK compatibility.
|
||||
* It must not be used in a non Tendermint key context because it doesn't implement
|
||||
* ADR-28. Nevertheless, you will like to use ed25519 in app user level
|
||||
* then you must create a new proto message and follow ADR-28 for Address construction.
|
||||
*
|
||||
* @generated from message cosmos.crypto.ed25519.PubKey
|
||||
*/
|
||||
export class PubKey extends Message<PubKey> {
|
||||
/**
|
||||
* @generated from field: bytes key = 1;
|
||||
*/
|
||||
key = new Uint8Array(0);
|
||||
|
||||
constructor(data?: PartialMessage<PubKey>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.crypto.ed25519.PubKey';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'key', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PubKey {
|
||||
return new PubKey().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PubKey {
|
||||
return new PubKey().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PubKey {
|
||||
return new PubKey().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: PubKey | PlainMessage<PubKey> | undefined,
|
||||
b: PubKey | PlainMessage<PubKey> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(PubKey, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* PrivKey defines a ed25519 private key.
|
||||
* NOTE: ed25519 keys must not be used in SDK apps except in a tendermint validator context.
|
||||
*
|
||||
* @generated from message cosmos.crypto.ed25519.PrivKey
|
||||
*/
|
||||
export class PrivKey extends Message<PrivKey> {
|
||||
/**
|
||||
* @generated from field: bytes key = 1;
|
||||
*/
|
||||
key = new Uint8Array(0);
|
||||
|
||||
constructor(data?: PartialMessage<PrivKey>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.crypto.ed25519.PrivKey';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'key', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PrivKey {
|
||||
return new PrivKey().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PrivKey {
|
||||
return new PrivKey().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PrivKey {
|
||||
return new PrivKey().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: PrivKey | PlainMessage<PrivKey> | undefined,
|
||||
b: PrivKey | PlainMessage<PrivKey> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(PrivKey, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
// Since: cosmos-sdk 0.46
|
||||
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/crypto/hd/v1/hd.proto (package cosmos.crypto.hd.v1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Message, proto3 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* BIP44Params is used as path field in ledger item in Record.
|
||||
*
|
||||
* @generated from message cosmos.crypto.hd.v1.BIP44Params
|
||||
*/
|
||||
export class BIP44Params extends Message<BIP44Params> {
|
||||
/**
|
||||
* purpose is a constant set to 44' (or 0x8000002C) following the BIP43 recommendation
|
||||
*
|
||||
* @generated from field: uint32 purpose = 1;
|
||||
*/
|
||||
purpose = 0;
|
||||
|
||||
/**
|
||||
* coin_type is a constant that improves privacy
|
||||
*
|
||||
* @generated from field: uint32 coin_type = 2;
|
||||
*/
|
||||
coinType = 0;
|
||||
|
||||
/**
|
||||
* account splits the key space into independent user identities
|
||||
*
|
||||
* @generated from field: uint32 account = 3;
|
||||
*/
|
||||
account = 0;
|
||||
|
||||
/**
|
||||
* change is a constant used for public derivation. Constant 0 is used for external chain and constant 1 for internal
|
||||
* chain.
|
||||
*
|
||||
* @generated from field: bool change = 4;
|
||||
*/
|
||||
change = false;
|
||||
|
||||
/**
|
||||
* address_index is used as child index in BIP32 derivation
|
||||
*
|
||||
* @generated from field: uint32 address_index = 5;
|
||||
*/
|
||||
addressIndex = 0;
|
||||
|
||||
constructor(data?: PartialMessage<BIP44Params>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.crypto.hd.v1.BIP44Params';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'purpose', kind: 'scalar', T: 13 /* ScalarType.UINT32 */ },
|
||||
{ no: 2, name: 'coin_type', kind: 'scalar', T: 13 /* ScalarType.UINT32 */ },
|
||||
{ no: 3, name: 'account', kind: 'scalar', T: 13 /* ScalarType.UINT32 */ },
|
||||
{ no: 4, name: 'change', kind: 'scalar', T: 8 /* ScalarType.BOOL */ },
|
||||
{
|
||||
no: 5,
|
||||
name: 'address_index',
|
||||
kind: 'scalar',
|
||||
T: 13 /* ScalarType.UINT32 */,
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BIP44Params {
|
||||
return new BIP44Params().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BIP44Params {
|
||||
return new BIP44Params().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BIP44Params {
|
||||
return new BIP44Params().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: BIP44Params | PlainMessage<BIP44Params> | undefined,
|
||||
b: BIP44Params | PlainMessage<BIP44Params> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(BIP44Params, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,278 @@
|
||||
// Since: cosmos-sdk 0.46
|
||||
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/crypto/keyring/v1/record.proto (package cosmos.crypto.keyring.v1, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Any, Message, proto3 } from '@bufbuild/protobuf';
|
||||
import { BIP44Params } from '../../hd/v1/hd_pb.js';
|
||||
|
||||
/**
|
||||
* Record is used for representing a key in the keyring.
|
||||
*
|
||||
* @generated from message cosmos.crypto.keyring.v1.Record
|
||||
*/
|
||||
export class Record extends Message<Record> {
|
||||
/**
|
||||
* name represents a name of Record
|
||||
*
|
||||
* @generated from field: string name = 1;
|
||||
*/
|
||||
name = '';
|
||||
|
||||
/**
|
||||
* pub_key represents a public key in any format
|
||||
*
|
||||
* @generated from field: google.protobuf.Any pub_key = 2;
|
||||
*/
|
||||
pubKey?: Any;
|
||||
|
||||
/**
|
||||
* Record contains one of the following items
|
||||
*
|
||||
* @generated from oneof cosmos.crypto.keyring.v1.Record.item
|
||||
*/
|
||||
item:
|
||||
| {
|
||||
/**
|
||||
* local stores the private key locally.
|
||||
*
|
||||
* @generated from field: cosmos.crypto.keyring.v1.Record.Local local = 3;
|
||||
*/
|
||||
value: Record_Local;
|
||||
case: 'local';
|
||||
}
|
||||
| {
|
||||
/**
|
||||
* ledger stores the information about a Ledger key.
|
||||
*
|
||||
* @generated from field: cosmos.crypto.keyring.v1.Record.Ledger ledger = 4;
|
||||
*/
|
||||
value: Record_Ledger;
|
||||
case: 'ledger';
|
||||
}
|
||||
| {
|
||||
/**
|
||||
* Multi does not store any other information.
|
||||
*
|
||||
* @generated from field: cosmos.crypto.keyring.v1.Record.Multi multi = 5;
|
||||
*/
|
||||
value: Record_Multi;
|
||||
case: 'multi';
|
||||
}
|
||||
| {
|
||||
/**
|
||||
* Offline does not store any other information.
|
||||
*
|
||||
* @generated from field: cosmos.crypto.keyring.v1.Record.Offline offline = 6;
|
||||
*/
|
||||
value: Record_Offline;
|
||||
case: 'offline';
|
||||
}
|
||||
| { case: undefined; value?: undefined } = { case: undefined };
|
||||
|
||||
constructor(data?: PartialMessage<Record>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.crypto.keyring.v1.Record';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'name', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
|
||||
{ no: 2, name: 'pub_key', kind: 'message', T: Any },
|
||||
{ no: 3, name: 'local', kind: 'message', T: Record_Local, oneof: 'item' },
|
||||
{ no: 4, name: 'ledger', kind: 'message', T: Record_Ledger, oneof: 'item' },
|
||||
{ no: 5, name: 'multi', kind: 'message', T: Record_Multi, oneof: 'item' },
|
||||
{
|
||||
no: 6,
|
||||
name: 'offline',
|
||||
kind: 'message',
|
||||
T: Record_Offline,
|
||||
oneof: 'item',
|
||||
},
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Record {
|
||||
return new Record().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Record {
|
||||
return new Record().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Record {
|
||||
return new Record().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Record | PlainMessage<Record> | undefined,
|
||||
b: Record | PlainMessage<Record> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Record, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Item is a keyring item stored in a keyring backend.
|
||||
* Local item
|
||||
*
|
||||
* @generated from message cosmos.crypto.keyring.v1.Record.Local
|
||||
*/
|
||||
export class Record_Local extends Message<Record_Local> {
|
||||
/**
|
||||
* @generated from field: google.protobuf.Any priv_key = 1;
|
||||
*/
|
||||
privKey?: Any;
|
||||
|
||||
constructor(data?: PartialMessage<Record_Local>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.crypto.keyring.v1.Record.Local';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'priv_key', kind: 'message', T: Any },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Record_Local {
|
||||
return new Record_Local().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Record_Local {
|
||||
return new Record_Local().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Record_Local {
|
||||
return new Record_Local().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Record_Local | PlainMessage<Record_Local> | undefined,
|
||||
b: Record_Local | PlainMessage<Record_Local> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Record_Local, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ledger item
|
||||
*
|
||||
* @generated from message cosmos.crypto.keyring.v1.Record.Ledger
|
||||
*/
|
||||
export class Record_Ledger extends Message<Record_Ledger> {
|
||||
/**
|
||||
* @generated from field: cosmos.crypto.hd.v1.BIP44Params path = 1;
|
||||
*/
|
||||
path?: BIP44Params;
|
||||
|
||||
constructor(data?: PartialMessage<Record_Ledger>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.crypto.keyring.v1.Record.Ledger';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'path', kind: 'message', T: BIP44Params },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Record_Ledger {
|
||||
return new Record_Ledger().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Record_Ledger {
|
||||
return new Record_Ledger().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Record_Ledger {
|
||||
return new Record_Ledger().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Record_Ledger | PlainMessage<Record_Ledger> | undefined,
|
||||
b: Record_Ledger | PlainMessage<Record_Ledger> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Record_Ledger, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Multi item
|
||||
*
|
||||
* @generated from message cosmos.crypto.keyring.v1.Record.Multi
|
||||
*/
|
||||
export class Record_Multi extends Message<Record_Multi> {
|
||||
constructor(data?: PartialMessage<Record_Multi>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.crypto.keyring.v1.Record.Multi';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => []);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Record_Multi {
|
||||
return new Record_Multi().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Record_Multi {
|
||||
return new Record_Multi().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Record_Multi {
|
||||
return new Record_Multi().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Record_Multi | PlainMessage<Record_Multi> | undefined,
|
||||
b: Record_Multi | PlainMessage<Record_Multi> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Record_Multi, a, b);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Offline item
|
||||
*
|
||||
* @generated from message cosmos.crypto.keyring.v1.Record.Offline
|
||||
*/
|
||||
export class Record_Offline extends Message<Record_Offline> {
|
||||
constructor(data?: PartialMessage<Record_Offline>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.crypto.keyring.v1.Record.Offline';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => []);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Record_Offline {
|
||||
return new Record_Offline().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Record_Offline {
|
||||
return new Record_Offline().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Record_Offline {
|
||||
return new Record_Offline().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: Record_Offline | PlainMessage<Record_Offline> | undefined,
|
||||
b: Record_Offline | PlainMessage<Record_Offline> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(Record_Offline, a, b);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
|
||||
// @generated from file cosmos/crypto/multisig/keys.proto (package cosmos.crypto.multisig, syntax proto3)
|
||||
/* eslint-disable */
|
||||
// @ts-nocheck
|
||||
|
||||
import type {
|
||||
BinaryReadOptions,
|
||||
FieldList,
|
||||
JsonReadOptions,
|
||||
JsonValue,
|
||||
PartialMessage,
|
||||
PlainMessage,
|
||||
} from '@bufbuild/protobuf';
|
||||
import { Any, Message, proto3 } from '@bufbuild/protobuf';
|
||||
|
||||
/**
|
||||
* LegacyAminoPubKey specifies a public key type
|
||||
* which nests multiple public keys and a threshold,
|
||||
* it uses legacy amino address rules.
|
||||
*
|
||||
* @generated from message cosmos.crypto.multisig.LegacyAminoPubKey
|
||||
*/
|
||||
export class LegacyAminoPubKey extends Message<LegacyAminoPubKey> {
|
||||
/**
|
||||
* @generated from field: uint32 threshold = 1;
|
||||
*/
|
||||
threshold = 0;
|
||||
|
||||
/**
|
||||
* @generated from field: repeated google.protobuf.Any public_keys = 2;
|
||||
*/
|
||||
publicKeys: Any[] = [];
|
||||
|
||||
constructor(data?: PartialMessage<LegacyAminoPubKey>) {
|
||||
super();
|
||||
proto3.util.initPartial(data, this);
|
||||
}
|
||||
|
||||
static readonly runtime: typeof proto3 = proto3;
|
||||
static readonly typeName = 'cosmos.crypto.multisig.LegacyAminoPubKey';
|
||||
static readonly fields: FieldList = proto3.util.newFieldList(() => [
|
||||
{ no: 1, name: 'threshold', kind: 'scalar', T: 13 /* ScalarType.UINT32 */ },
|
||||
{ no: 2, name: 'public_keys', kind: 'message', T: Any, repeated: true },
|
||||
]);
|
||||
|
||||
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LegacyAminoPubKey {
|
||||
return new LegacyAminoPubKey().fromBinary(bytes, options);
|
||||
}
|
||||
|
||||
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LegacyAminoPubKey {
|
||||
return new LegacyAminoPubKey().fromJson(jsonValue, options);
|
||||
}
|
||||
|
||||
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LegacyAminoPubKey {
|
||||
return new LegacyAminoPubKey().fromJsonString(jsonString, options);
|
||||
}
|
||||
|
||||
static equals(
|
||||
a: LegacyAminoPubKey | PlainMessage<LegacyAminoPubKey> | undefined,
|
||||
b: LegacyAminoPubKey | PlainMessage<LegacyAminoPubKey> | undefined
|
||||
): boolean {
|
||||
return proto3.util.equals(LegacyAminoPubKey, a, b);
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user