@xpla/xplajs 1.7.0-beta.0

package/src/cosmos/crypto/ed25519/keys.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivKey = exports.PubKey = void 0;
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+const registry_1 = require("../../../registry");
+function createBasePubKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+exports.PubKey = {
+    typeUrl: "/cosmos.crypto.ed25519.PubKey",
+    aminoType: "tendermint/PubKeyEd25519",
+    is(o) {
+        return o && (o.$typeUrl === exports.PubKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.PubKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePubKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePubKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePubKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = (0, helpers_1.bytesFromBase64)(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? (0, helpers_1.base64FromBytes)(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PubKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "tendermint/PubKeyEd25519",
+            value: exports.PubKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PubKey.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PubKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.ed25519.PubKey",
+            value: exports.PubKey.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.PubKey.typeUrl, exports.PubKey);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.PubKey.aminoType, exports.PubKey.typeUrl);
+function createBasePrivKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+exports.PrivKey = {
+    typeUrl: "/cosmos.crypto.ed25519.PrivKey",
+    aminoType: "tendermint/PrivKeyEd25519",
+    is(o) {
+        return o && (o.$typeUrl === exports.PrivKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.PrivKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePrivKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePrivKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePrivKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = (0, helpers_1.bytesFromBase64)(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? (0, helpers_1.base64FromBytes)(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PrivKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "tendermint/PrivKeyEd25519",
+            value: exports.PrivKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PrivKey.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PrivKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.ed25519.PrivKey",
+            value: exports.PrivKey.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.PrivKey.typeUrl, exports.PrivKey);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.PrivKey.aminoType, exports.PrivKey.typeUrl);

package/src/cosmos/crypto/ed25519/keys.ts

@@ -0,0 +1,209 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial, bytesFromBase64, base64FromBytes } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/**
+ * 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.
+ */
+export interface PubKey {
+  key: Uint8Array;
+}
+export interface PubKeyProtoMsg {
+  typeUrl: "/cosmos.crypto.ed25519.PubKey";
+  value: Uint8Array;
+}
+/**
+ * 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.
+ */
+export interface PubKeyAmino {
+  key: string;
+}
+export interface PubKeyAminoMsg {
+  type: "tendermint/PubKeyEd25519";
+  value: PubKeyAmino;
+}
+/**
+ * PrivKey defines a ed25519 private key.
+ * NOTE: ed25519 keys must not be used in SDK apps except in a tendermint validator context.
+ */
+export interface PrivKey {
+  key: Uint8Array;
+}
+export interface PrivKeyProtoMsg {
+  typeUrl: "/cosmos.crypto.ed25519.PrivKey";
+  value: Uint8Array;
+}
+/**
+ * PrivKey defines a ed25519 private key.
+ * NOTE: ed25519 keys must not be used in SDK apps except in a tendermint validator context.
+ */
+export interface PrivKeyAmino {
+  key: string;
+}
+export interface PrivKeyAminoMsg {
+  type: "tendermint/PrivKeyEd25519";
+  value: PrivKeyAmino;
+}
+function createBasePubKey(): PubKey {
+  return {
+    key: new Uint8Array()
+  };
+}
+export const PubKey = {
+  typeUrl: "/cosmos.crypto.ed25519.PubKey",
+  aminoType: "tendermint/PubKeyEd25519",
+  is(o: any): o is PubKey {
+    return o && (o.$typeUrl === PubKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+  },
+  isAmino(o: any): o is PubKeyAmino {
+    return o && (o.$typeUrl === PubKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+  },
+  encode(message: PubKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PubKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePubKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<PubKey>): PubKey {
+    const message = createBasePubKey();
+    message.key = object.key ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: PubKeyAmino): PubKey {
+    const message = createBasePubKey();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    return message;
+  },
+  toAmino(message: PubKey): PubKeyAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PubKeyAminoMsg): PubKey {
+    return PubKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: PubKey): PubKeyAminoMsg {
+    return {
+      type: "tendermint/PubKeyEd25519",
+      value: PubKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PubKeyProtoMsg): PubKey {
+    return PubKey.decode(message.value);
+  },
+  toProto(message: PubKey): Uint8Array {
+    return PubKey.encode(message).finish();
+  },
+  toProtoMsg(message: PubKey): PubKeyProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.ed25519.PubKey",
+      value: PubKey.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(PubKey.typeUrl, PubKey);
+GlobalDecoderRegistry.registerAminoProtoMapping(PubKey.aminoType, PubKey.typeUrl);
+function createBasePrivKey(): PrivKey {
+  return {
+    key: new Uint8Array()
+  };
+}
+export const PrivKey = {
+  typeUrl: "/cosmos.crypto.ed25519.PrivKey",
+  aminoType: "tendermint/PrivKeyEd25519",
+  is(o: any): o is PrivKey {
+    return o && (o.$typeUrl === PrivKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+  },
+  isAmino(o: any): o is PrivKeyAmino {
+    return o && (o.$typeUrl === PrivKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+  },
+  encode(message: PrivKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PrivKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePrivKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<PrivKey>): PrivKey {
+    const message = createBasePrivKey();
+    message.key = object.key ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: PrivKeyAmino): PrivKey {
+    const message = createBasePrivKey();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    return message;
+  },
+  toAmino(message: PrivKey): PrivKeyAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PrivKeyAminoMsg): PrivKey {
+    return PrivKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: PrivKey): PrivKeyAminoMsg {
+    return {
+      type: "tendermint/PrivKeyEd25519",
+      value: PrivKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PrivKeyProtoMsg): PrivKey {
+    return PrivKey.decode(message.value);
+  },
+  toProto(message: PrivKey): Uint8Array {
+    return PrivKey.encode(message).finish();
+  },
+  toProtoMsg(message: PrivKey): PrivKeyProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.ed25519.PrivKey",
+      value: PrivKey.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(PrivKey.typeUrl, PrivKey);
+GlobalDecoderRegistry.registerAminoProtoMapping(PrivKey.aminoType, PrivKey.typeUrl);

package/src/cosmos/crypto/hd/v1/hd.ts

@@ -0,0 +1,169 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/** BIP44Params is used as path field in ledger item in Record. */
+export interface BIP44Params {
+  /** purpose is a constant set to 44' (or 0x8000002C) following the BIP43 recommendation */
+  purpose: number;
+  /** coin_type is a constant that improves privacy */
+  coinType: number;
+  /** account splits the key space into independent user identities */
+  account: number;
+  /**
+   * change is a constant used for public derivation. Constant 0 is used for external chain and constant 1 for internal
+   * chain.
+   */
+  change: boolean;
+  /** address_index is used as child index in BIP32 derivation */
+  addressIndex: number;
+}
+export interface BIP44ParamsProtoMsg {
+  typeUrl: "/cosmos.crypto.hd.v1.BIP44Params";
+  value: Uint8Array;
+}
+/** BIP44Params is used as path field in ledger item in Record. */
+export interface BIP44ParamsAmino {
+  /** purpose is a constant set to 44' (or 0x8000002C) following the BIP43 recommendation */
+  purpose: number;
+  /** coin_type is a constant that improves privacy */
+  coin_type: number;
+  /** account splits the key space into independent user identities */
+  account: number;
+  /**
+   * change is a constant used for public derivation. Constant 0 is used for external chain and constant 1 for internal
+   * chain.
+   */
+  change: boolean;
+  /** address_index is used as child index in BIP32 derivation */
+  address_index: number;
+}
+export interface BIP44ParamsAminoMsg {
+  type: "crypto/keys/hd/BIP44Params";
+  value: BIP44ParamsAmino;
+}
+function createBaseBIP44Params(): BIP44Params {
+  return {
+    purpose: 0,
+    coinType: 0,
+    account: 0,
+    change: false,
+    addressIndex: 0
+  };
+}
+export const BIP44Params = {
+  typeUrl: "/cosmos.crypto.hd.v1.BIP44Params",
+  aminoType: "crypto/keys/hd/BIP44Params",
+  is(o: any): o is BIP44Params {
+    return o && (o.$typeUrl === BIP44Params.typeUrl || typeof o.purpose === "number" && typeof o.coinType === "number" && typeof o.account === "number" && typeof o.change === "boolean" && typeof o.addressIndex === "number");
+  },
+  isAmino(o: any): o is BIP44ParamsAmino {
+    return o && (o.$typeUrl === BIP44Params.typeUrl || typeof o.purpose === "number" && typeof o.coin_type === "number" && typeof o.account === "number" && typeof o.change === "boolean" && typeof o.address_index === "number");
+  },
+  encode(message: BIP44Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.purpose !== 0) {
+      writer.uint32(8).uint32(message.purpose);
+    }
+    if (message.coinType !== 0) {
+      writer.uint32(16).uint32(message.coinType);
+    }
+    if (message.account !== 0) {
+      writer.uint32(24).uint32(message.account);
+    }
+    if (message.change === true) {
+      writer.uint32(32).bool(message.change);
+    }
+    if (message.addressIndex !== 0) {
+      writer.uint32(40).uint32(message.addressIndex);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): BIP44Params {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBIP44Params();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.purpose = reader.uint32();
+          break;
+        case 2:
+          message.coinType = reader.uint32();
+          break;
+        case 3:
+          message.account = reader.uint32();
+          break;
+        case 4:
+          message.change = reader.bool();
+          break;
+        case 5:
+          message.addressIndex = reader.uint32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<BIP44Params>): BIP44Params {
+    const message = createBaseBIP44Params();
+    message.purpose = object.purpose ?? 0;
+    message.coinType = object.coinType ?? 0;
+    message.account = object.account ?? 0;
+    message.change = object.change ?? false;
+    message.addressIndex = object.addressIndex ?? 0;
+    return message;
+  },
+  fromAmino(object: BIP44ParamsAmino): BIP44Params {
+    const message = createBaseBIP44Params();
+    if (object.purpose !== undefined && object.purpose !== null) {
+      message.purpose = object.purpose;
+    }
+    if (object.coin_type !== undefined && object.coin_type !== null) {
+      message.coinType = object.coin_type;
+    }
+    if (object.account !== undefined && object.account !== null) {
+      message.account = object.account;
+    }
+    if (object.change !== undefined && object.change !== null) {
+      message.change = object.change;
+    }
+    if (object.address_index !== undefined && object.address_index !== null) {
+      message.addressIndex = object.address_index;
+    }
+    return message;
+  },
+  toAmino(message: BIP44Params): BIP44ParamsAmino {
+    const obj: any = {};
+    obj.purpose = message.purpose === 0 ? undefined : message.purpose;
+    obj.coin_type = message.coinType === 0 ? undefined : message.coinType;
+    obj.account = message.account === 0 ? undefined : message.account;
+    obj.change = message.change === false ? undefined : message.change;
+    obj.address_index = message.addressIndex === 0 ? undefined : message.addressIndex;
+    return obj;
+  },
+  fromAminoMsg(object: BIP44ParamsAminoMsg): BIP44Params {
+    return BIP44Params.fromAmino(object.value);
+  },
+  toAminoMsg(message: BIP44Params): BIP44ParamsAminoMsg {
+    return {
+      type: "crypto/keys/hd/BIP44Params",
+      value: BIP44Params.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: BIP44ParamsProtoMsg): BIP44Params {
+    return BIP44Params.decode(message.value);
+  },
+  toProto(message: BIP44Params): Uint8Array {
+    return BIP44Params.encode(message).finish();
+  },
+  toProtoMsg(message: BIP44Params): BIP44ParamsProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.hd.v1.BIP44Params",
+      value: BIP44Params.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(BIP44Params.typeUrl, BIP44Params);
+GlobalDecoderRegistry.registerAminoProtoMapping(BIP44Params.aminoType, BIP44Params.typeUrl);