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

package/jest.config.js

@@ -0,0 +1,18 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+    preset: "ts-jest",
+    testEnvironment: "node",
+    transform: {
+        "^.+\\.tsx?$": [
+            "ts-jest",
+            {
+                babelConfig: false,
+                tsconfig: "tsconfig.json",
+            },
+        ],
+    },
+    transformIgnorePatterns: [`/node_modules/*`],
+    testRegex: "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
+    moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
+    modulePathIgnorePatterns: ["dist/*"]
+};

package/package.json

@@ -1,42 +1,56 @@
 {
   "name": "@burnt-labs/xion-types",
-  "version": "21.0.0-alpha.4",
-  "description": "TypeScript definitions for Xion Protobuf files",
+  "version": "25.0.0",
+  "author": "burnt-labs <devops@burnt.com>",
+  "description": "xion-types",
   "main": "index.js",
-  "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'"
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/burnt-labs/xion-types",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
   },
-  "license": "MIT",
-  "dependencies": {
-    "@improbable-eng/grpc-web": "^0.14.1",
-    "browser-headers": "^0.4.1",
-    "google-protobuf": "^3.17.3",
-    "long": "^4.0.0",
-    "protobufjs": "~6.11.2"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/burnt-labs/xion-types"
+  },
+  "bugs": {
+    "url": "https://github.com/burnt-labs/xion-types/issues"
+  },
+  "scripts": {
+    "copy": "copyfiles -f ./LICENSE README.md package.json dist",
+    "clean": "rimraf dist",
+    "prepare": "npm run build",
+    "download-protos": "ts-node scripts/download-protos.ts",
+    "codegen": "ts-node scripts/codegen.ts",
+    "build": "npm run clean && tsc && tsc -p tsconfig.esm.json && npm run copy",
+    "build:dev": "npm run clean && npm run codegen && tsc --declarationMap && tsc -p tsconfig.esm.json && npm run copy",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
   },
   "devDependencies": {
-    "prettier": "^2.3.0",
-    "ts-proto": "^1.82.5",
-    "typescript": "^5.0.0"
+    "@types/node": "^22.14.1",
+    "copyfiles": "^2.4.1",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/burnt-labs/xion-types.git"
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.8.0",
+    "@cosmology/lcd": "^0.14.0",
+    "@cosmology/telescope": "^1.12.20",
+    "@improbable-eng/grpc-web": "^0.15.0",
+    "@interchainjs/cosmos": "1.11.5",
+    "@interchainjs/cosmos-types": "1.11.5",
+    "@interchainjs/encoding": "1.11.5",
+    "@interchainjs/pubkey": "1.11.5",
+    "@interchainjs/types": "1.11.5",
+    "@interchainjs/utils": "1.11.5",
+    "@tanstack/react-query": "^5.89.0"
   },
-  "keywords": [
-    "xion",
-    "blockchain",
-    "typescript",
-    "protobuf",
-    "cosmos",
-    "ibc"
-  ]
+  "keywords": [],
+  "packageManager": "yarn@1.22.22+sha1.ac34549e6aa8e7ead463a7407e1c7390f61a6610"
 }

package/scripts/aminos.ts

@@ -0,0 +1,29 @@
+export const AMINO_MAP = {
+  // PUT YOUR AMINO names here...
+  // Staking
+  // '/cosmos.staking.v1beta1.MsgCreateValidator': {
+  //   aminoType: 'cosmos-sdk/MsgCreateValidator'
+  // },
+  // '/cosmos.staking.v1beta1.MsgEditValidator': {
+  //   aminoType: 'cosmos-sdk/MsgEditValidator'
+  // },
+  // '/cosmos.staking.v1beta1.MsgDelegate': {
+  //   aminoType: 'cosmos-sdk/MsgDelegate'
+  // },
+  // '/cosmos.staking.v1beta1.MsgUndelegate': {
+  //   aminoType: 'cosmos-sdk/MsgUndelegate'
+  // },
+  // '/cosmos.staking.v1beta1.MsgBeginRedelegate': {
+  //   aminoType: 'cosmos-sdk/MsgBeginRedelegate'
+  // },
+  // '/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation': {
+  //   aminoType: 'cosmos-sdk/MsgCancelUnbondingDelegation'
+  // },
+  // '/cosmos.staking.v1beta1.MsgUpdateParams': {
+  //   aminoType: 'cosmos-sdk/x/staking/MsgUpdateParams'
+  // },
+  // // IBC
+  // '/ibc.applications.transfer.v1.MsgTransfer': {
+  //   aminoType: 'cosmos-sdk/MsgTransfer'
+  // }
+};

package/scripts/codegen.ts

@@ -0,0 +1,94 @@
+import { TelescopeInput } from '@cosmology/telescope';
+import telescope from '@cosmology/telescope';
+import { join } from 'path';
+import { rimrafSync as rimraf } from 'rimraf';
+
+import { AMINO_MAP } from './aminos';
+
+const protoDirs: string[] = [join(__dirname, '/../protos'), join(__dirname, '/../../xion/proto')];
+const outPath: string = join(__dirname, '../types');
+rimraf(outPath);
+
+export const options: TelescopeInput = {
+  protoDirs,
+  outPath,
+  options: {
+    interfaces: {
+      enabled: true,
+      useUnionTypes: true
+    },
+    prototypes: {
+      enabled: true,
+      excluded: {
+        packages: [
+          //'ibc.applications.fee.v1', // issue with parsing protos (LCD routes with nested objects in params)
+          //'cosmos.app.v1alpha1',
+          // 'cosmos.app.v1beta1',
+          // 'cosmos.base.kv.v1beta1',
+          // 'cosmos.base.reflection.v1beta1',
+          // 'cosmos.base.snapshots.v1beta1',
+          // 'cosmos.base.store.v1beta1',
+          // 'cosmos.base.tendermint.v1beta1',
+          // 'cosmos.crisis.v1beta1',
+          // 'cosmos.evidence.v1beta1',
+          // 'cosmos.genutil.v1beta1',
+          // 'cosmos.autocli.v1',
+          // 'cosmos.msg.v1',
+          // 'cosmos.nft.v1beta1',
+          // 'cosmos.capability.v1beta1',
+          // 'cosmos.orm.v1alpha1',
+          // 'cosmos.orm.v1',
+          // 'cosmos.slashing.v1beta1',
+          // 'google.api',
+          // 'ibc.core.port.v1',
+          // 'ibc.core.types.v1'
+        ]
+      },
+    },
+
+    bundle: {
+      enabled: true
+    },
+
+    tsDisable: {
+      files: [],
+      patterns: [],
+      disableAll: true
+    },
+
+    eslintDisable: {
+      files: [],
+      patterns: [],
+      disableAll: false
+    },
+
+    stargateClients: {
+      enabled: true,
+      includeCosmosDefaultTypes: true
+    },
+
+    aminoEncoding: {
+      enabled: true,
+      customTypes: {
+        useCosmosSDKDec: false
+      },
+      exceptions: {
+        ...AMINO_MAP
+      },
+    },
+    rpcClients: {
+      type: 'tendermint',
+      enabled: true
+    },
+  }
+};
+
+
+telescope(options)
+  .then(() => {
+    console.log('✨ all done!');
+  })
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

package/scripts/download-protos.ts

@@ -0,0 +1,248 @@
+// @ts-ignore
+import downloadProtos from '@cosmology/telescope/main/commands/download'
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+
+/**
+ * Fix common proto syntax errors that cause telescope to fail
+ */
+function fixProtoSyntaxErrors(protoDir: string): void {
+  console.log('🔧 Fixing proto syntax errors...');
+  
+  let totalFilesFixed = 0;
+  
+  function processDirectory(dir: string): void {
+    const items = readdirSync(dir);
+    
+    for (const item of items) {
+      const fullPath = join(dir, item);
+      const stat = statSync(fullPath);
+      
+      if (stat.isDirectory()) {
+        processDirectory(fullPath);
+      } else if (item.endsWith('.proto')) {
+        let content = readFileSync(fullPath, 'utf8');
+        const originalContent = content;
+        
+        // Fix: Remove standalone semicolons (lines with just spaces and a semicolon)
+        content = content.replace(/^(\s*);(\s*)$/gm, '$1$2');
+        
+        if (content !== originalContent) {
+          writeFileSync(fullPath, content, 'utf8');
+          const relativePath = fullPath.replace(protoDir + '/', '');
+          console.log(`  ✅ Fixed syntax errors in: ${relativePath}`);
+          totalFilesFixed++;
+        }
+      }
+    }
+  }
+  
+  processDirectory(protoDir);
+  
+  if (totalFilesFixed > 0) {
+    console.log(`🎉 Fixed syntax errors in ${totalFilesFixed} proto files`);
+  } else {
+    console.log('✅ No proto syntax errors found');
+  }
+}
+
+// Read dependencies from .env file
+const envFilePath = join(__dirname, '../../.env');
+let deps: string[];
+
+try {
+  const envContent = readFileSync(envFilePath, 'utf8');
+  
+  // Parse the DEPS variable from .env file
+  const depsMatch = envContent.match(/DEPS="([^"]+)"/);
+  if (!depsMatch) {
+    throw new Error('DEPS variable not found in .env file');
+  }
+  
+  deps = depsMatch[1].split('\n').filter(dep => dep.trim());
+  console.log(`📋 Loaded ${deps.length} dependencies from .env file`);
+} catch (error) {
+  console.error('❌ Error: Could not read .env file or parse DEPS variable');
+  console.error('Please ensure .env file exists in the project root with DEPS variable');
+  process.exit(1);
+}
+
+// Generate module mapping dynamically from dependencies
+function generateModuleMapping(deps: string[]): Record<string, { owner: string; repo: string }> {
+  const mapping: Record<string, { owner: string; repo: string }> = {};
+  
+  for (const dep of deps) {
+    // Parse GitHub URLs like github.com/owner/repo or github.com/owner/repo/version
+    const match = dep.match(/github\.com\/([^\/]+)\/([^\/]+)/);
+    if (match) {
+      const [, owner, repo] = match;
+      mapping[dep] = { owner, repo };
+    }
+  }
+  
+  return mapping;
+}
+
+const moduleMapping = generateModuleMapping(deps);
+
+function generateConfig() {
+  console.log('🔄 Generating config with dependency versions...');
+  
+  const xionDir = join(__dirname, '../../xion');
+  const repos: any[] = [];
+  const targets: string[] = [];
+  
+  for (const dep of deps) {
+    try {
+      // First, let's see if there's a replace directive
+      const replaceInfo = execSync(
+        `cd "${xionDir}" && go list -f '{{ if .Replace }}{{ .Replace.Path }} {{ .Replace.Version }}{{ else }}NO_REPLACE{{ end }}' -m "${dep}"`,
+        { encoding: 'utf8' }
+      ).trim();
+      
+      console.log(`Module: ${dep}`);
+      console.log(`  Replace info: ${replaceInfo}`);
+      
+      // Get module info, handling replace directives properly
+      const moduleInfo = execSync(
+        `cd "${xionDir}" && go list -f '{{ .Version }}{{ if .Replace }} {{ .Replace.Path }}{{ else }} {{ .Path }}{{ end }}' -m "${dep}"`,
+        { encoding: 'utf8' }
+      ).trim();
+      
+      const parts = moduleInfo.split(' ');
+      const version = parts[0];
+      const effectivePath = parts[1];
+      
+      console.log(`  Version: ${version}`);
+      console.log(`  Effective path: ${effectivePath}`);
+      
+      // All modules should work now with the updated configuration
+      // if (dep.includes('problematic-module')) {
+      //   console.log(`  Skipping ${dep} - known to have issues with proto extraction`);
+      //   continue;
+      // }
+      
+      // Parse the effective path to get owner/repo
+      let owner: string, repo: string;
+      
+      if (effectivePath.startsWith('github.com/')) {
+        const match = effectivePath.match(/github\.com\/([^\/]+)\/([^\/]+)/);
+        if (match) {
+          [, owner, repo] = match;
+        } else {
+          console.warn(`Could not parse GitHub path: ${effectivePath}`);
+          continue;
+        }
+      } else {
+        // Fallback to original module mapping if not a GitHub path
+        if (moduleMapping[dep]) {
+          ({ owner, repo } = moduleMapping[dep]);
+        } else {
+          console.warn(`No mapping found for non-GitHub module: ${effectivePath}`);
+          continue;
+        }
+      }
+      
+      // Handle pseudo-versions (e.g., v0.53.1-0.20250911214339-3cd81ea27e01)
+      let branchOrTag = version;
+      if (version.includes('-0.')) {
+        // Extract commit hash from pseudo-version
+        const commitMatch = version.match(/-([a-f0-9]{12})$/);
+        if (commitMatch) {
+          branchOrTag = commitMatch[1]; // Use commit hash
+        } else {
+          branchOrTag = 'main'; // Fallback to main
+        }
+        console.log(`  Pseudo-version detected, using: ${branchOrTag}`);
+      }
+      
+      repos.push({
+        owner,
+        repo,
+        branch: branchOrTag
+      });
+      
+      // Generate target patterns based on repo names, excluding problematic patterns
+      let targetPattern: string;
+      switch (repo) {
+        case 'cosmos-sdk':
+          targetPattern = 'cosmos/**/*.proto';
+          break;
+        case 'wasmd':
+          targetPattern = 'cosmwasm/**/*.proto';
+          break;
+        case 'ibc-go':
+          targetPattern = 'ibc/**/*.proto';
+          break;
+        case 'abstract-account':
+          targetPattern = 'abstractaccount/**/*.proto';
+          break;
+        case 'tokenfactory':
+          // Be more specific to avoid problematic Google Cloud protos
+          targetPattern = 'osmosis/tokenfactory/**/*.proto';
+          break;
+        case 'ibc-apps':
+          targetPattern = 'packetforward/**/*.proto';
+          break;
+        default:
+          targetPattern = `${repo}/**/*.proto`;
+      }
+      
+      if (!targets.includes(targetPattern)) {
+        targets.push(targetPattern);
+      }
+      
+      console.log(`Added ${owner}/${repo} with version: ${version} and target: ${targetPattern}`);
+    } catch (error) {
+      console.warn(`Warning: Could not find module info for ${dep}:`, error);
+    }
+  }
+  
+  // Include only the essential Google proto types, avoiding newer problematic ones
+  // Don't include google/protobuf/** as it might have newer features telescope can't parse
+  targets.push('google/api/**/*.proto');
+  targets.push('google/rpc/**/*.proto');
+  
+  console.log('📋 Final configuration:');
+  console.log('  Repos:', repos.length);
+  repos.forEach(repo => console.log(`    - ${repo.owner}/${repo.repo}@${repo.branch}`));
+  console.log('  Targets:', targets.length);
+  targets.forEach(target => console.log(`    - ${target}`));
+  
+  return {
+    repos,
+    protoDirMapping: {
+      "gogo/protobuf/master": ".",
+      "googleapis/googleapis/master": ".",
+      "protocolbuffers/protobuf/main": "src"
+    },
+    outDir: "protos",
+    ssh: false,
+    tempRepoDir: "git-modules",
+    targets
+  };
+}
+
+const config = generateConfig();
+
+// Set environment variable to suppress Git detached HEAD warnings
+process.env.GIT_CONFIG_COUNT = '1';
+process.env.GIT_CONFIG_KEY_0 = 'advice.detachedHead';
+process.env.GIT_CONFIG_VALUE_0 = 'false';
+
+downloadProtos(config)
+  .then(() => {
+    console.log('✅ Proto download completed');
+    
+    // Fix proto syntax errors after download
+    const protoDir = join(__dirname, '../protos');
+    fixProtoSyntaxErrors(protoDir);
+    
+    console.log('🎉 Proto download and syntax fixing complete!');
+  })
+  // @ts-ignore
+  .catch((error) => {
+    console.error('❌ Proto download failed:', error);
+    process.exit(1);
+  });

package/telescope.config.json

@@ -0,0 +1,84 @@
+{
+  "options": {
+    "classesUseArrowFunctions": true,
+    "env": "v-next",
+    "useInterchainJs": true,
+    "useSDKTypes": true,
+    "prototypes": {
+      "enableRegistryLoader": false,
+      "enableMessageComposer": false,
+      "enabled": true,
+      "parser": {
+        "keepCase": false,
+        "alternateCommentMode": true,
+        "preferTrailingComment": false
+      },
+      "methods": {
+        "fromJSON": true,
+        "toJSON": true,
+        "encode": true,
+        "decode": true,
+        "fromPartial": true,
+        "toAmino": true,
+        "fromAmino": true,
+        "fromProto": false,
+        "toProto": false,
+        "fromProtoMsg": false,
+        "toProtoMsg": false,
+        "toAminoMsg": true,
+        "fromAminoMsg": true
+      },
+      "addTypeUrlToDecoders": true,
+      "addTypeUrlToObjects": true,
+      "addAminoTypeToObjects": true,
+      "typingsFormat": {
+        "duration": "duration",
+        "timestamp": "date",
+        "useExact": true,
+        "useDeepPartial": true,
+        "num64": "bigint",
+        "customTypes": {
+          "useCosmosSDKDec": true,
+          "useEnhancedDecimal": false
+        },
+        "useTelescopeGeneratedType": true,
+        "autoFixUndefinedEnumDefault": true
+      }
+    },
+    "bundle": {
+      "enabled": false
+    },
+    "stargateClients": {
+      "enabled": true
+    },
+    "lcdClients": {
+      "enabled": true
+    },
+    "rpcClients": {
+      "enabled": true
+    },
+    "helperFunctions": {
+      "enabled": true,
+      "useGlobalDecoderRegistry": true,
+      "hooks": {
+        "react": true,
+        "vue": false
+      }
+    },
+    "interfaces": {
+      "enabled": true,
+      "useGlobalDecoderRegistry": true,
+      "registerAllDecodersToGlobal": false,
+      "useUnionTypes": true
+    },
+    "aminoEncoding": {
+      "enabled": true,
+      "useLegacyInlineEncoding": false,
+      "disableMsgTypes": false,
+      "useProtoOptionality": true,
+      "customTypes": {
+        "useCosmosSDKDec": true
+      }
+    }
+  }
+}

package/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "module": "es2022",
+    "rootDir": ".",
+    "declaration": false
+  }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "types",
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["dist", "node_modules", "scripts", "**/*.spec.*", "**/*.test.*"],
+}

package/types/abstractaccount/bundle.ts

@@ -0,0 +1,35 @@
+//@ts-nocheck
+import * as _0 from "./v1/account";
+import * as _1 from "./v1/events";
+import * as _2 from "./v1/genesis";
+import * as _3 from "./v1/params";
+import * as _4 from "./v1/query";
+import * as _5 from "./v1/tx";
+import * as _289 from "./v1/tx.amino";
+import * as _290 from "./v1/tx.registry";
+import * as _291 from "./v1/query.lcd";
+import * as _292 from "./v1/query.rpc.Query";
+import * as _293 from "./v1/tx.rpc.msg";
+import * as _475 from "./lcd";
+import * as _476 from "./rpc.query";
+import * as _477 from "./rpc.tx";
+export namespace abstractaccount {
+  export const v1 = {
+    ..._0,
+    ..._1,
+    ..._2,
+    ..._3,
+    ..._4,
+    ..._5,
+    ..._289,
+    ..._290,
+    ..._291,
+    ..._292,
+    ..._293
+  };
+  export const ClientFactory = {
+    ..._475,
+    ..._476,
+    ..._477
+  };
+}

package/types/abstractaccount/client.ts

@@ -0,0 +1,48 @@
+//@ts-nocheck
+import { GeneratedType, Registry, OfflineSigner } from "@cosmjs/proto-signing";
+import { defaultRegistryTypes, AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
+import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
+import * as abstractaccountV1TxRegistry from "./v1/tx.registry";
+import * as abstractaccountV1TxAmino from "./v1/tx.amino";
+export const abstractaccountAminoConverters = {
+  ...abstractaccountV1TxAmino.AminoConverter
+};
+export const abstractaccountProtoRegistry: ReadonlyArray<[string, GeneratedType]> = [...abstractaccountV1TxRegistry.registry];
+export const getSigningAbstractaccountClientOptions = ({
+  defaultTypes = defaultRegistryTypes
+}: {
+  defaultTypes?: ReadonlyArray<[string, GeneratedType]>;
+} = {}): {
+  registry: Registry;
+  aminoTypes: AminoTypes;
+} => {
+  const registry = new Registry([...defaultTypes, ...abstractaccountProtoRegistry]);
+  const aminoTypes = new AminoTypes({
+    ...abstractaccountAminoConverters
+  });
+  return {
+    registry,
+    aminoTypes
+  };
+};
+export const getSigningAbstractaccountClient = async ({
+  rpcEndpoint,
+  signer,
+  defaultTypes = defaultRegistryTypes
+}: {
+  rpcEndpoint: string | HttpEndpoint;
+  signer: OfflineSigner;
+  defaultTypes?: ReadonlyArray<[string, GeneratedType]>;
+}) => {
+  const {
+    registry,
+    aminoTypes
+  } = getSigningAbstractaccountClientOptions({
+    defaultTypes
+  });
+  const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+    registry: registry as any,
+    aminoTypes
+  });
+  return client;
+};