@sparkdreamnft/sparkdreamjs 0.0.29 → 0.0.31

package/cosmos_proto/bundle.d.ts

@@ -1,31 +1,31 @@
-import * as _113 from "./cosmos";
+import * as _174 from "./cosmos";
 export declare const cosmos_proto: {
-    scalarTypeFromJSON(object: any): _113.ScalarType;
-    scalarTypeToJSON(object: _113.ScalarType): string;
-    ScalarType: typeof _113.ScalarType;
-    ScalarTypeAmino: typeof _113.ScalarType;
+    scalarTypeFromJSON(object: any): _174.ScalarType;
+    scalarTypeToJSON(object: _174.ScalarType): string;
+    ScalarType: typeof _174.ScalarType;
+    ScalarTypeAmino: typeof _174.ScalarType;
     InterfaceDescriptor: {
         typeUrl: string;
-        encode(message: _113.InterfaceDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.InterfaceDescriptor;
-        fromPartial(object: import("../helpers").DeepPartial<_113.InterfaceDescriptor>): _113.InterfaceDescriptor;
-        fromAmino(object: _113.InterfaceDescriptorAmino): _113.InterfaceDescriptor;
-        toAmino(message: _113.InterfaceDescriptor): _113.InterfaceDescriptorAmino;
-        fromAminoMsg(object: _113.InterfaceDescriptorAminoMsg): _113.InterfaceDescriptor;
-        fromProtoMsg(message: _113.InterfaceDescriptorProtoMsg): _113.InterfaceDescriptor;
-        toProto(message: _113.InterfaceDescriptor): Uint8Array;
-        toProtoMsg(message: _113.InterfaceDescriptor): _113.InterfaceDescriptorProtoMsg;
+        encode(message: _174.InterfaceDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _174.InterfaceDescriptor;
+        fromPartial(object: import("../helpers").DeepPartial<_174.InterfaceDescriptor>): _174.InterfaceDescriptor;
+        fromAmino(object: _174.InterfaceDescriptorAmino): _174.InterfaceDescriptor;
+        toAmino(message: _174.InterfaceDescriptor): _174.InterfaceDescriptorAmino;
+        fromAminoMsg(object: _174.InterfaceDescriptorAminoMsg): _174.InterfaceDescriptor;
+        fromProtoMsg(message: _174.InterfaceDescriptorProtoMsg): _174.InterfaceDescriptor;
+        toProto(message: _174.InterfaceDescriptor): Uint8Array;
+        toProtoMsg(message: _174.InterfaceDescriptor): _174.InterfaceDescriptorProtoMsg;
     };
     ScalarDescriptor: {
         typeUrl: string;
-        encode(message: _113.ScalarDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.ScalarDescriptor;
-        fromPartial(object: import("../helpers").DeepPartial<_113.ScalarDescriptor>): _113.ScalarDescriptor;
-        fromAmino(object: _113.ScalarDescriptorAmino): _113.ScalarDescriptor;
-        toAmino(message: _113.ScalarDescriptor): _113.ScalarDescriptorAmino;
-        fromAminoMsg(object: _113.ScalarDescriptorAminoMsg): _113.ScalarDescriptor;
-        fromProtoMsg(message: _113.ScalarDescriptorProtoMsg): _113.ScalarDescriptor;
-        toProto(message: _113.ScalarDescriptor): Uint8Array;
-        toProtoMsg(message: _113.ScalarDescriptor): _113.ScalarDescriptorProtoMsg;
+        encode(message: _174.ScalarDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _174.ScalarDescriptor;
+        fromPartial(object: import("../helpers").DeepPartial<_174.ScalarDescriptor>): _174.ScalarDescriptor;
+        fromAmino(object: _174.ScalarDescriptorAmino): _174.ScalarDescriptor;
+        toAmino(message: _174.ScalarDescriptor): _174.ScalarDescriptorAmino;
+        fromAminoMsg(object: _174.ScalarDescriptorAminoMsg): _174.ScalarDescriptor;
+        fromProtoMsg(message: _174.ScalarDescriptorProtoMsg): _174.ScalarDescriptor;
+        toProto(message: _174.ScalarDescriptor): Uint8Array;
+        toProtoMsg(message: _174.ScalarDescriptor): _174.ScalarDescriptorProtoMsg;
     };
 };

package/cosmos_proto/bundle.js

@@ -35,7 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cosmos_proto = void 0;
 //@ts-nocheck
-const _113 = __importStar(require("./cosmos"));
+const _174 = __importStar(require("./cosmos"));
 exports.cosmos_proto = {
-    ..._113
+    ..._174
 };

package/esm/akash/base/deposit/v1/deposit.js

@@ -0,0 +1,139 @@
+//@ts-nocheck
+import { Coin } from "../../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** Source is an enum which lists source of funds for deployment deposit. */
+export var Source;
+(function (Source) {
+    /** invalid - Prefix should start with 0 in enum. So declaring dummy state. */
+    Source[Source["invalid"] = 0] = "invalid";
+    /** balance - SourceBalance denotes account balance as source of funds */
+    Source[Source["balance"] = 1] = "balance";
+    /** grant - SourceGrant denotes authz grants as source of funds */
+    Source[Source["grant"] = 2] = "grant";
+    Source[Source["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Source || (Source = {}));
+export const SourceAmino = Source;
+export function sourceFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "invalid":
+            return Source.invalid;
+        case 1:
+        case "balance":
+            return Source.balance;
+        case 2:
+        case "grant":
+            return Source.grant;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Source.UNRECOGNIZED;
+    }
+}
+export function sourceToJSON(object) {
+    switch (object) {
+        case Source.invalid:
+            return "invalid";
+        case Source.balance:
+            return "balance";
+        case Source.grant:
+            return "grant";
+        case Source.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseDeposit() {
+    return {
+        amount: Coin.fromPartial({}),
+        sources: []
+    };
+}
+/**
+ * Deposit is a data type used by MsgCreateDeployment, MsgDepositDeployment and MsgCreateBid to indicate source of the deposit.
+ * @name Deposit
+ * @package akash.base.deposit.v1
+ * @see proto type: akash.base.deposit.v1.Deposit
+ */
+export const Deposit = {
+    typeUrl: "/akash.base.deposit.v1.Deposit",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.amount !== undefined) {
+            Coin.encode(message.amount, writer.uint32(10).fork()).ldelim();
+        }
+        writer.uint32(42).fork();
+        for (const v of message.sources) {
+            writer.int32(v);
+        }
+        writer.ldelim();
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseDeposit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.amount = Coin.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.sources.push(reader.int32());
+                        }
+                    }
+                    else {
+                        message.sources.push(reader.int32());
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDeposit();
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        message.sources = object.sources?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDeposit();
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        message.sources = object.sources?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        if (message.sources) {
+            obj.sources = message.sources.map(e => e);
+        }
+        else {
+            obj.sources = message.sources;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Deposit.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Deposit.decode(message.value);
+    },
+    toProto(message) {
+        return Deposit.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.deposit.v1.Deposit",
+            value: Deposit.encode(message).finish()
+        };
+    }
+};

package/esm/akash/base/offchain/sign/v1/sign.js

@@ -0,0 +1,84 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../../helpers";
+function createBaseMsgSignData() {
+    return {
+        signer: "",
+        data: new Uint8Array()
+    };
+}
+/**
+ * MsgSignData defines an arbitrary, general-purpose, off-chain message
+ * @name MsgSignData
+ * @package akash.base.offchain.sign.v1
+ * @see proto type: akash.base.offchain.sign.v1.MsgSignData
+ */
+export const MsgSignData = {
+    typeUrl: "/akash.base.offchain.sign.v1.MsgSignData",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(18).bytes(message.data);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgSignData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.data = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSignData();
+        message.signer = object.signer ?? "";
+        message.data = object.data ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgSignData();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.data !== undefined && object.data !== null) {
+            message.data = bytesFromBase64(object.data);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer ?? "";
+        obj.data = message.data ? base64FromBytes(message.data) : "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgSignData.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgSignData.decode(message.value);
+    },
+    toProto(message) {
+        return MsgSignData.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.offchain.sign.v1.MsgSignData",
+            value: MsgSignData.encode(message).finish()
+        };
+    }
+};