@burnt-labs/xion-types 21.0.0-alpha.2 → 21.0.0-alpha.4

package/README.md

@@ -1,120 +1,111 @@
 # @burnt-labs/xion-types
 
-TypeScript type definitions for Xion blockchain protobuf messages. This package provides generated TypeScript interfaces and encoding/decoding functions for all Xion and Cosmos SDK protocol buffer definitions.
+TypeScript definitions for Xion Protobuf files. This package provides TypeScript type definitions generated from the Protobuf files used in the Xion project, enabling developers to work with Xion-related data structures in a type-safe way.
+
+## Table of Contents
+
+- [@burnt-labs/xion-types](#burnt-labsxion-types)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Example](#example)
+  - [Development](#development)
+  - [License](#license)
+
+---
 
 ## Installation
 
+Install the **@burnt-labs/xion-types** package via npm or yarn:
+
 ```bash
+# Using npm
 npm install @burnt-labs/xion-types
+
+# Using yarn
+yarn add @burnt-labs/xion-types
 ```
 
+---
+
 ## Usage
 
-Import types directly from their module paths (following the cosmjs-types pattern):
+Once installed, you can import the type definitions in your TypeScript project. The types are generated from the Protobuf files used in the Xion project.
 
 ```typescript
-// Import Xion-specific types
-import { QueryWebAuthNVerifyRegisterRequest } from "@burnt-labs/xion-types/xion/v1/query";
-import { MsgAddAuthenticator } from "@burnt-labs/xion-types/xion/v1/tx";
+import { MyProtobufType } from '@burnt-labs/xion-types/types/filename';
 
-// Import Cosmos SDK types
-import { Coin } from "@burnt-labs/xion-types/cosmos/base/v1beta1/coin";
-import { MsgSend } from "@burnt-labs/xion-types/cosmos/bank/v1beta1/tx";
-
-// Import IBC types
-import { Channel } from "@burnt-labs/xion-types/ibc/core/channel/v1/channel";
+const myData: MyProtobufType = {
+  field1: 'value',
+  field2: 42
+};
 ```
 
-### Working with Messages
+> **Note:** Replace `filename` with the appropriate file name where the type is defined.
 
-Each generated type includes encode/decode methods and JSON conversion:
+---
 
-```typescript
-import { MsgSend } from "@burnt-labs/xion-types/cosmos/bank/v1beta1/tx";
-import { Coin } from "@burnt-labs/xion-types/cosmos/base/v1beta1/coin";
-
-// Create a message
-const msg = MsgSend.fromPartial({
-  fromAddress: "xion1...",
-  toAddress: "xion1...",
-  amount: [
-    {
-      denom: "uxion",
-      amount: "1000000"
-    }
-  ]
-});
-
-// Encode to binary
-const encoded = MsgSend.encode(msg).finish();
-
-// Decode from binary
-const decoded = MsgSend.decode(encoded);
-
-// Convert to/from JSON
-const json = MsgSend.toJSON(msg);
-const fromJson = MsgSend.fromJSON(json);
-```
+## Example
 
-### WebAuthn Support
-
-Xion includes native WebAuthn support for account abstraction:
+Here is a full example of how you might use the **@burnt-labs/xion-types** package in a TypeScript project:
 
 ```typescript
-import { 
-  QueryWebAuthNVerifyRegisterRequest,
-  QueryWebAuthNVerifyRegisterResponse 
-} from "@burnt-labs/xion-types/xion/v1/query";
-
-const request = QueryWebAuthNVerifyRegisterRequest.fromPartial({
-  addr: "xion1...",
-  challenge: new Uint8Array([...]),
-  rp: "example.com",
-  authenticatorData: new Uint8Array([...]),
-  clientData: new Uint8Array([...])
-});
-```
+import { MyProtobufType } from '@burnt-labs/xion-types/types/filename';
 
-### Helper Types
+function processData(data: MyProtobufType): void {
+  console.log(`Field 1: ${data.field1}`);
+  console.log(`Field 2: ${data.field2}`);
+}
 
-The package exports common helper types used throughout the generated code:
+const sampleData: MyProtobufType = {
+  field1: 'Hello, Xion!',
+  field2: 100
+};
 
-```typescript
-import type { DeepPartial, Exact } from "@burnt-labs/xion-types";
+processData(sampleData);
 ```
 
-## Available Modules
-
-The package includes definitions for:
+> This simple example illustrates how you can work with the types generated from Xion's Protobuf definitions.
 
-- **Xion modules** (`xion/v1/*`) - WebAuthn, global fees, JWT, and other Xion-specific functionality
-- **Cosmos SDK modules** (`cosmos/*`) - Bank, staking, governance, distribution, etc.
-- **IBC modules** (`ibc/*`) - Inter-blockchain communication protocol
-- **CosmWasm** (`cosmwasm/*`) - Smart contract support
-- **Tendermint** (`tendermint/*`) - Consensus engine types
+---
 
 ## Development
 
-### Regenerating Types
+If you want to modify or regenerate the TypeScript definitions from Protobuf files, follow these steps:
 
-To regenerate the TypeScript definitions from the protocol buffer files:
+1. **Clone the Repository**
+   ```bash
+   git clone https://github.com/burnt-labs/xion.git
+   cd xion
+   ```
 
-```bash
-cd client/ts
-npm run codegen
-```
+2. **Install Dependencies**
+   ```bash
+   npm install
+   ```
 
-This will:
-1. Generate TypeScript files from the proto definitions using buf and ts-proto
-2. Compile TypeScript to JavaScript
-3. Prepare the package for publishing
+3. **Generate TypeScript Definitions**
+   ```bash
+   npx protoc --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts \
+     --ts_out=./generated \
+     --proto_path=./proto \
+     $(find ./proto -name '*.proto')
+   ```
 
-### Building
+4. **Compile TypeScript Files**
+   ```bash
+   tsc --noEmit
+   ```
 
-```bash
-npm run build
-```
+> These steps will generate the TypeScript definitions from the Protobuf files located in the `proto` directory.
+
+---
 
 ## License
 
-MIT
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+---
+
+For more information, check out [Xion's GitHub repository](https://github.com/burnt-labs/xion).
+

package/index.js

@@ -1,10 +1,15 @@
-// Auto-generated index file
-// This file is automatically generated by generate-index.js
-// Exports we want to provide at the root of the "@burnt-labs/xion-types" package
-// Following the cosmjs-types pattern - only export helpers, not all types
-// Export helper types from generated files
-// Note: These types are used internally but not exported by Telescope
-// Export protobufPackage constant if needed
-export { protobufPackage } from "./types/generated/cosmos/base/v1beta1/coin"; // Users should import specific types directly from their paths:
- // import { Coin } from "@burnt-labs/xion-types/cosmos/base/v1beta1/coin";
- // import { QueryWebAuthNVerifyRegisterRequest } from "@burnt-labs/xion-types/xion/v1/query";
+// Xion Types - Generated TypeScript definitions for Xion blockchain
+// This file serves as the main entry point for the @burnt-labs/xion-types package
+
+// Note: This file is a placeholder and will be replaced by the compiled TypeScript
+// The actual exports come from the generated type definitions
+
+module.exports = {
+  // Package information
+  name: '@burnt-labs/xion-types',
+  version: '16.0.0',
+  description: 'TypeScript definitions for Xion Protobuf files'
+};
+
+// For TypeScript users, import the types directly from the generated files
+// For JavaScript users, the types are available in the dist/types directory

package/package.json

@@ -1,19 +1,42 @@
 {
   "name": "@burnt-labs/xion-types",
-  "version": "21.0.0-alpha.2",
+  "version": "21.0.0-alpha.4",
   "description": "TypeScript definitions for Xion Protobuf files",
   "main": "index.js",
-  "types": "index.d.ts",
+  "types": "types/",
+  "files": [
+    "types/",
+    "index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "echo 'Types are pre-generated, no build step needed'",
+    "test": "echo 'No tests configured'",
+    "prepublishOnly": "echo 'Package ready for publishing'"
+  },
   "license": "MIT",
   "dependencies": {
-    "@cosmology/protobufjs": "^7.3.2",
     "@improbable-eng/grpc-web": "^0.14.1",
-    "@interchainjs/math": "^1.17.3",
-    "@interchainjs/pubkey": "^1.17.3",
-    "@interchainjs/types": "^1.17.3",
     "browser-headers": "^0.4.1",
     "google-protobuf": "^3.17.3",
     "long": "^4.0.0",
-    "protobufjs": "^7.5.4"
-  }
+    "protobufjs": "~6.11.2"
+  },
+  "devDependencies": {
+    "prettier": "^2.3.0",
+    "ts-proto": "^1.82.5",
+    "typescript": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/burnt-labs/xion-types.git"
+  },
+  "keywords": [
+    "xion",
+    "blockchain",
+    "typescript",
+    "protobuf",
+    "cosmos",
+    "ibc"
+  ]
 }

package/types/amino/amino.ts

@@ -0,0 +1,9 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v1.181.2
+//   protoc               unknown
+// source: amino/amino.proto
+
+/* eslint-disable */
+
+export const protobufPackage = "amino";

package/types/capability/v1/capability.ts

@@ -0,0 +1,245 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v1.181.2
+//   protoc               unknown
+// source: capability/v1/capability.proto
+
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "capability.v1";
+
+/**
+ * Capability defines an implementation of an object capability. The index
+ * provided to a Capability must be globally unique.
+ */
+export interface Capability {
+  index: Long;
+}
+
+/**
+ * Owner defines a single capability owner. An owner is defined by the name of
+ * capability and the module name.
+ */
+export interface Owner {
+  module: string;
+  name: string;
+}
+
+/**
+ * CapabilityOwners defines a set of owners of a single Capability. The set of
+ * owners must be unique.
+ */
+export interface CapabilityOwners {
+  owners: Owner[];
+}
+
+function createBaseCapability(): Capability {
+  return { index: Long.UZERO };
+}
+
+export const Capability = {
+  encode(message: Capability, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.index.equals(Long.UZERO)) {
+      writer.uint32(8).uint64(message.index);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Capability {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCapability();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.index = reader.uint64() as Long;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Capability {
+    return { index: isSet(object.index) ? Long.fromValue(object.index) : Long.UZERO };
+  },
+
+  toJSON(message: Capability): unknown {
+    const obj: any = {};
+    if (!message.index.equals(Long.UZERO)) {
+      obj.index = (message.index || Long.UZERO).toString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Capability>, I>>(base?: I): Capability {
+    return Capability.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Capability>, I>>(object: I): Capability {
+    const message = createBaseCapability();
+    message.index = (object.index !== undefined && object.index !== null) ? Long.fromValue(object.index) : Long.UZERO;
+    return message;
+  },
+};
+
+function createBaseOwner(): Owner {
+  return { module: "", name: "" };
+}
+
+export const Owner = {
+  encode(message: Owner, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.module !== "") {
+      writer.uint32(10).string(message.module);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Owner {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOwner();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.module = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Owner {
+    return {
+      module: isSet(object.module) ? globalThis.String(object.module) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+    };
+  },
+
+  toJSON(message: Owner): unknown {
+    const obj: any = {};
+    if (message.module !== "") {
+      obj.module = message.module;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Owner>, I>>(base?: I): Owner {
+    return Owner.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Owner>, I>>(object: I): Owner {
+    const message = createBaseOwner();
+    message.module = object.module ?? "";
+    message.name = object.name ?? "";
+    return message;
+  },
+};
+
+function createBaseCapabilityOwners(): CapabilityOwners {
+  return { owners: [] };
+}
+
+export const CapabilityOwners = {
+  encode(message: CapabilityOwners, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.owners) {
+      Owner.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CapabilityOwners {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCapabilityOwners();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.owners.push(Owner.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CapabilityOwners {
+    return { owners: globalThis.Array.isArray(object?.owners) ? object.owners.map((e: any) => Owner.fromJSON(e)) : [] };
+  },
+
+  toJSON(message: CapabilityOwners): unknown {
+    const obj: any = {};
+    if (message.owners?.length) {
+      obj.owners = message.owners.map((e) => Owner.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CapabilityOwners>, I>>(base?: I): CapabilityOwners {
+    return CapabilityOwners.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CapabilityOwners>, I>>(object: I): CapabilityOwners {
+    const message = createBaseCapabilityOwners();
+    message.owners = object.owners?.map((e) => Owner.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}