atlas.js-protos 0.1.0

package/dist/types/registry.js

@@ -0,0 +1,200 @@
+"use strict";
+//@ts-nocheck
+/**
+* This file and any referenced files were automatically generated by @ahm23/telescope@2.3.1
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalDecoderRegistry = void 0;
+const _m0 = __importStar(require("protobufjs/minimal"));
+const any_1 = require("cosmjs-types/google/protobuf/any");
+class GlobalDecoderRegistry {
+    static registry = {};
+    static aminoProtoMapping = {};
+    static existingTypeUrls = [];
+    static registerExistingTypeUrl(typeUrl) {
+        if (GlobalDecoderRegistry.existingTypeUrls.includes(typeUrl)) {
+            return false;
+        }
+        GlobalDecoderRegistry.existingTypeUrls.push(typeUrl);
+        return true;
+    }
+    static registerAminoProtoMapping(aminoType, typeUrl) {
+        GlobalDecoderRegistry.aminoProtoMapping[aminoType] = typeUrl;
+    }
+    static register(key, decoder) {
+        GlobalDecoderRegistry.registry[key] = decoder;
+    }
+    static getDecoder(key) {
+        return GlobalDecoderRegistry.registry[key];
+    }
+    static getDecoderByInstance(obj) {
+        if (obj === undefined || obj === null) {
+            return null;
+        }
+        const protoType = obj;
+        if (protoType.$typeUrl) {
+            return GlobalDecoderRegistry.getDecoder(protoType.$typeUrl);
+        }
+        for (const key in GlobalDecoderRegistry.registry) {
+            if (Object.prototype.hasOwnProperty.call(GlobalDecoderRegistry.registry, key)) {
+                const element = GlobalDecoderRegistry.registry[key];
+                if (element.is(obj)) {
+                    return element;
+                }
+                if (element.isSDK && element.isSDK(obj)) {
+                    return element;
+                }
+                if (element.isAmino && element.isAmino(obj)) {
+                    return element;
+                }
+            }
+        }
+        return null;
+    }
+    static getDecoderByAminoType(type) {
+        if (type === undefined || type === null) {
+            return null;
+        }
+        const typeUrl = GlobalDecoderRegistry.aminoProtoMapping[type];
+        if (!typeUrl) {
+            return null;
+        }
+        return GlobalDecoderRegistry.getDecoder(typeUrl);
+    }
+    static wrapAny(obj) {
+        if (any_1.Any.is(obj)) {
+            return obj;
+        }
+        const decoder = getDecoderByInstance(obj);
+        return {
+            typeUrl: decoder.typeUrl,
+            value: decoder.encode(obj).finish(),
+        };
+    }
+    static unwrapAny(input) {
+        let data;
+        if (any_1.Any.is(input)) {
+            data = input;
+        }
+        else {
+            const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+            data = any_1.Any.decode(reader, reader.uint32());
+        }
+        const decoder = GlobalDecoderRegistry.getDecoder(data.typeUrl);
+        if (!decoder) {
+            return data;
+        }
+        return decoder.decode(data.value);
+    }
+    static fromJSON(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.fromJSON(object);
+    }
+    static toJSON(message) {
+        const decoder = getDecoderByInstance(message);
+        return decoder.toJSON(message);
+    }
+    static fromPartial(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder ? decoder.fromPartial(object) : object;
+    }
+    static fromSDK(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.fromSDK(object);
+    }
+    static fromSDKJSON(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.fromSDKJSON(object);
+    }
+    static toSDK(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.toSDK(object);
+    }
+    static fromAmino(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.fromAmino(object);
+    }
+    static fromAminoMsg(object) {
+        const decoder = GlobalDecoderRegistry.getDecoderByAminoType(object.type);
+        if (!decoder) {
+            throw new Error(`There's no decoder for the amino type ${object.type}`);
+        }
+        return decoder.fromAminoMsg(object);
+    }
+    static toAmino(object) {
+        let data;
+        let decoder;
+        if (any_1.Any.is(object)) {
+            data = GlobalDecoderRegistry.unwrapAny(object);
+            decoder = GlobalDecoderRegistry.getDecoder(object.typeUrl);
+            if (!decoder) {
+                decoder = any_1.Any;
+            }
+        }
+        else {
+            data = object;
+            decoder = getDecoderByInstance(object);
+        }
+        return decoder.toAmino(data);
+    }
+    static toAminoMsg(object) {
+        let data;
+        let decoder;
+        if (any_1.Any.is(object)) {
+            data = GlobalDecoderRegistry.unwrapAny(object);
+            decoder = GlobalDecoderRegistry.getDecoder(object.typeUrl);
+            if (!decoder) {
+                decoder = any_1.Any;
+            }
+        }
+        else {
+            data = object;
+            decoder = getDecoderByInstance(object);
+        }
+        return decoder.toAminoMsg(data);
+    }
+}
+exports.GlobalDecoderRegistry = GlobalDecoderRegistry;
+function getDecoderByInstance(obj) {
+    const decoder = GlobalDecoderRegistry.getDecoderByInstance(obj);
+    if (!decoder) {
+        throw new Error(`There's no decoder for the instance ${JSON.stringify(obj)}`);
+    }
+    return decoder;
+}
+GlobalDecoderRegistry.register(any_1.Any.typeUrl, any_1.Any);

package/dist/types/registry.mjs

@@ -0,0 +1,163 @@
+//@ts-nocheck
+/**
+* This file and any referenced files were automatically generated by @ahm23/telescope@2.3.1
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+import * as _m0 from "protobufjs/minimal";
+import { Any } from "cosmjs-types/google/protobuf/any";
+export class GlobalDecoderRegistry {
+    static registry = {};
+    static aminoProtoMapping = {};
+    static existingTypeUrls = [];
+    static registerExistingTypeUrl(typeUrl) {
+        if (GlobalDecoderRegistry.existingTypeUrls.includes(typeUrl)) {
+            return false;
+        }
+        GlobalDecoderRegistry.existingTypeUrls.push(typeUrl);
+        return true;
+    }
+    static registerAminoProtoMapping(aminoType, typeUrl) {
+        GlobalDecoderRegistry.aminoProtoMapping[aminoType] = typeUrl;
+    }
+    static register(key, decoder) {
+        GlobalDecoderRegistry.registry[key] = decoder;
+    }
+    static getDecoder(key) {
+        return GlobalDecoderRegistry.registry[key];
+    }
+    static getDecoderByInstance(obj) {
+        if (obj === undefined || obj === null) {
+            return null;
+        }
+        const protoType = obj;
+        if (protoType.$typeUrl) {
+            return GlobalDecoderRegistry.getDecoder(protoType.$typeUrl);
+        }
+        for (const key in GlobalDecoderRegistry.registry) {
+            if (Object.prototype.hasOwnProperty.call(GlobalDecoderRegistry.registry, key)) {
+                const element = GlobalDecoderRegistry.registry[key];
+                if (element.is(obj)) {
+                    return element;
+                }
+                if (element.isSDK && element.isSDK(obj)) {
+                    return element;
+                }
+                if (element.isAmino && element.isAmino(obj)) {
+                    return element;
+                }
+            }
+        }
+        return null;
+    }
+    static getDecoderByAminoType(type) {
+        if (type === undefined || type === null) {
+            return null;
+        }
+        const typeUrl = GlobalDecoderRegistry.aminoProtoMapping[type];
+        if (!typeUrl) {
+            return null;
+        }
+        return GlobalDecoderRegistry.getDecoder(typeUrl);
+    }
+    static wrapAny(obj) {
+        if (Any.is(obj)) {
+            return obj;
+        }
+        const decoder = getDecoderByInstance(obj);
+        return {
+            typeUrl: decoder.typeUrl,
+            value: decoder.encode(obj).finish(),
+        };
+    }
+    static unwrapAny(input) {
+        let data;
+        if (Any.is(input)) {
+            data = input;
+        }
+        else {
+            const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+            data = Any.decode(reader, reader.uint32());
+        }
+        const decoder = GlobalDecoderRegistry.getDecoder(data.typeUrl);
+        if (!decoder) {
+            return data;
+        }
+        return decoder.decode(data.value);
+    }
+    static fromJSON(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.fromJSON(object);
+    }
+    static toJSON(message) {
+        const decoder = getDecoderByInstance(message);
+        return decoder.toJSON(message);
+    }
+    static fromPartial(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder ? decoder.fromPartial(object) : object;
+    }
+    static fromSDK(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.fromSDK(object);
+    }
+    static fromSDKJSON(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.fromSDKJSON(object);
+    }
+    static toSDK(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.toSDK(object);
+    }
+    static fromAmino(object) {
+        const decoder = getDecoderByInstance(object);
+        return decoder.fromAmino(object);
+    }
+    static fromAminoMsg(object) {
+        const decoder = GlobalDecoderRegistry.getDecoderByAminoType(object.type);
+        if (!decoder) {
+            throw new Error(`There's no decoder for the amino type ${object.type}`);
+        }
+        return decoder.fromAminoMsg(object);
+    }
+    static toAmino(object) {
+        let data;
+        let decoder;
+        if (Any.is(object)) {
+            data = GlobalDecoderRegistry.unwrapAny(object);
+            decoder = GlobalDecoderRegistry.getDecoder(object.typeUrl);
+            if (!decoder) {
+                decoder = Any;
+            }
+        }
+        else {
+            data = object;
+            decoder = getDecoderByInstance(object);
+        }
+        return decoder.toAmino(data);
+    }
+    static toAminoMsg(object) {
+        let data;
+        let decoder;
+        if (Any.is(object)) {
+            data = GlobalDecoderRegistry.unwrapAny(object);
+            decoder = GlobalDecoderRegistry.getDecoder(object.typeUrl);
+            if (!decoder) {
+                decoder = Any;
+            }
+        }
+        else {
+            data = object;
+            decoder = getDecoderByInstance(object);
+        }
+        return decoder.toAminoMsg(data);
+    }
+}
+function getDecoderByInstance(obj) {
+    const decoder = GlobalDecoderRegistry.getDecoderByInstance(obj);
+    if (!decoder) {
+        throw new Error(`There's no decoder for the instance ${JSON.stringify(obj)}`);
+    }
+    return decoder;
+}
+GlobalDecoderRegistry.register(Any.typeUrl, Any);

package/dist/types/types.d.ts

@@ -0,0 +1,74 @@
+/**
+* This file and any referenced files were automatically generated by @ahm23/telescope@2.3.1
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+import * as _m0 from "protobufjs/minimal";
+import { Any } from "cosmjs-types/google/protobuf/any";
+import { DeliverTxResponse } from "@interchainjs/types";
+export type { DeliverTxResponse };
+export type ProtoMsg = Omit<Any, "typeUrl"> & {
+    typeUrl: any;
+};
+export interface IAminoMsg<Amino> {
+    type: any;
+    value: Amino;
+}
+export interface IProtoType {
+    $typeUrl?: any;
+}
+/**
+ * A type generated by Telescope 1.0.
+ */
+export interface TelescopeGeneratedCodec<T = unknown, SDK = unknown, Amino = unknown> {
+    readonly typeUrl: string;
+    readonly aminoType?: string;
+    is?(o: unknown): o is T;
+    isSDK?(o: unknown): o is SDK;
+    isAmino?(o: unknown): o is Amino;
+    encode: (message: T, writer?: _m0.Writer | any) => _m0.Writer | any;
+    decode: (input: _m0.Reader | Uint8Array | any, length?: number) => T;
+    fromPartial: (object: any) => T | any;
+    fromJSON?: (object: any) => T | any;
+    toJSON?: (message: T | any) => any;
+    fromSDK?: (sdk: SDK) => T;
+    fromSDKJSON?: (object: any) => SDK;
+    toSDK?: (message: T) => SDK;
+    fromAmino?: (amino: Amino) => T;
+    toAmino?: (message: T) => Amino;
+    fromAminoMsg?: (aminoMsg: IAminoMsg<Amino>) => T;
+    toAminoMsg?: (message: T) => IAminoMsg<Amino>;
+    toProto?: (message: T) => Uint8Array;
+    fromProtoMsg?: (message: ProtoMsg) => T;
+    toProtoMsg?: (message: T) => Any;
+    registerTypeUrl?: () => void;
+}
+export type TelescopeGeneratedType<T = unknown, SDK = unknown, Amino = unknown> = TelescopeGeneratedCodec<T, SDK, Amino>;
+export type GeneratedType = TelescopeGeneratedCodec;
+/**
+ * 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.
+ */
+interface Coin {
+    denom: string;
+    amount: string;
+}
+export type EncodeObject = Message<any>;
+export interface Message<T> {
+    typeUrl: string;
+    value: T;
+}
+export interface StdFee {
+    amount: Coin[];
+    gas: string;
+    /** The granter address that is used for paying with feegrants */
+    granter?: string;
+    /** The fee payer address. The payer must have signed the transaction. */
+    payer?: string;
+}
+export interface TxRpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+    signAndBroadcast?(signerAddress: string, messages: EncodeObject[], fee: StdFee | "auto" | number, memo: string): Promise<DeliverTxResponse>;
+}

package/dist/types/types.js

@@ -0,0 +1,8 @@
+"use strict";
+//@ts-nocheck
+/**
+* This file and any referenced files were automatically generated by @ahm23/telescope@2.3.1
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/types.mjs

@@ -0,0 +1,7 @@
+//@ts-nocheck
+/**
+* This file and any referenced files were automatically generated by @ahm23/telescope@2.3.1
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+export {};

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "atlas.js-protos",
+  "version": "0.1.0",
+  "description": "Protobuf type definitions and message helpers for Atlas Protocol.",
+  "author": "Ahmed Moussa",
+  "homepage": "https://github.com/Atlas-DePIN/atlas.js-protos",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "storage": [
+        "./dist/storage/index.d.ts"
+      ],
+      "storage/tx": [
+        "./dist/storage/tx.d.ts"
+      ],
+      "storage/query": [
+        "./dist/storage/query.d.ts"
+      ],
+      "filetree": [
+        "./dist/filetree/index.d.ts"
+      ],
+      "filetree/tx": [
+        "./dist/filetree/tx.d.ts"
+      ],
+      "filetree/query": [
+        "./dist/filetree/query.d.ts"
+      ]
+    }
+  },
+  "directories": {
+    "lib": "src"
+  },
+  "files": [
+    "dist",
+    "!CHANGELOG.md"
+  ],
+  "scripts": {
+    "build:cjs": "yarn tsc -p tsconfig.json --outDir dist --module commonjs || true",
+    "build:mjs": "yarn tsc -p tsconfig.json --outDir mjs --module es2022 --declaration false || true",
+    "clean:mjs": "rimraf mjs",
+    "clean:dist": "rimraf dist",
+    "clean": "npm run clean:mjs && npm run clean:dist",
+    "build:rename": "publish-scripts --cmd rename --srcDir mjs --outDir dist --findExt js --replaceExt mjs --no-rmDir",
+    "build": "npm run clean && npm run build:cjs && npm run build:mjs && npm run build:rename",
+    "codegen": "node scripts/codegen.js",
+    "prepare": "npm run build",
+    "lint": "eslint src --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Atlas-DePIN/atlas.js-protos"
+  },
+  "keywords": [],
+  "bugs": {
+    "url": "https://github.com/Atlas-DePIN/atlas.js-protos/issues"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "eslint": "8.45.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "^29.5.0",
+    "jest-in-case": "^1.0.2",
+    "prettier": "^2.8.7",
+    "publish-scripts": "0.1.0",
+    "rimraf": "^5.0.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "@ahm23/telescope": "^2.3.1",
+    "@ahm23/telescope-ast": "^2.3.1",
+    "@ahm23/telescope-lcd": "^0.17.1",
+    "@ahm23/telescope-proto-parser": "^2.2.2",
+    "@cosmjs/amino": "0.29.4",
+    "@cosmjs/proto-signing": "^0.38.1",
+    "@cosmjs/stargate": "^0.38.1",
+    "@cosmjs/tendermint-rpc": "^0.38.1",
+    "@improbable-eng/grpc-web": "^0.15.0",
+    "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
+    "@interchainjs/cosmos": "^1.19.3",
+    "@interchainjs/types": "^1.19.1",
+    "browser-headers": "^0.4.1",
+    "cosmjs-types": "^0.11.0",
+    "long": "^5.3.2",
+    "protobufjs": "^8.0.0"
+  }
+}