@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.31

package/esm/akash/escrow/id/v1/id.js

@@ -0,0 +1,206 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** Scope is an enum which refers to the account scope */
+export var Scope;
+(function (Scope) {
+    /** invalid - Prefix should start with 0 in enum. So declaring dummy state. */
+    Scope[Scope["invalid"] = 0] = "invalid";
+    /** deployment - DeploymentActive denotes state for deployment active. */
+    Scope[Scope["deployment"] = 1] = "deployment";
+    /** bid - DeploymentClosed denotes state for deployment closed. */
+    Scope[Scope["bid"] = 2] = "bid";
+    Scope[Scope["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Scope || (Scope = {}));
+export const ScopeAmino = Scope;
+export function scopeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "invalid":
+            return Scope.invalid;
+        case 1:
+        case "deployment":
+            return Scope.deployment;
+        case 2:
+        case "bid":
+            return Scope.bid;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Scope.UNRECOGNIZED;
+    }
+}
+export function scopeToJSON(object) {
+    switch (object) {
+        case Scope.invalid:
+            return "invalid";
+        case Scope.deployment:
+            return "deployment";
+        case Scope.bid:
+            return "bid";
+        case Scope.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseAccount() {
+    return {
+        scope: 0,
+        xid: ""
+    };
+}
+/**
+ * Account is the account identifier.
+ * @name Account
+ * @package akash.escrow.id.v1
+ * @see proto type: akash.escrow.id.v1.Account
+ */
+export const Account = {
+    typeUrl: "/akash.escrow.id.v1.Account",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.scope !== 0) {
+            writer.uint32(8).int32(message.scope);
+        }
+        if (message.xid !== "") {
+            writer.uint32(18).string(message.xid);
+        }
+        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 = createBaseAccount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.scope = reader.int32();
+                    break;
+                case 2:
+                    message.xid = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAccount();
+        message.scope = object.scope ?? 0;
+        message.xid = object.xid ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAccount();
+        if (object.scope !== undefined && object.scope !== null) {
+            message.scope = object.scope;
+        }
+        if (object.xid !== undefined && object.xid !== null) {
+            message.xid = object.xid;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.scope = message.scope ?? 0;
+        obj.xid = message.xid ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Account.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Account.decode(message.value);
+    },
+    toProto(message) {
+        return Account.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.escrow.id.v1.Account",
+            value: Account.encode(message).finish()
+        };
+    }
+};
+function createBasePayment() {
+    return {
+        aid: Account.fromPartial({}),
+        xid: ""
+    };
+}
+/**
+ * Payment is the payment identifier.
+ * @name Payment
+ * @package akash.escrow.id.v1
+ * @see proto type: akash.escrow.id.v1.Payment
+ */
+export const Payment = {
+    typeUrl: "/akash.escrow.id.v1.Payment",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.aid !== undefined) {
+            Account.encode(message.aid, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.xid !== "") {
+            writer.uint32(18).string(message.xid);
+        }
+        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 = createBasePayment();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.aid = Account.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.xid = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePayment();
+        message.aid = object.aid !== undefined && object.aid !== null ? Account.fromPartial(object.aid) : undefined;
+        message.xid = object.xid ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePayment();
+        if (object.aid !== undefined && object.aid !== null) {
+            message.aid = Account.fromAmino(object.aid);
+        }
+        if (object.xid !== undefined && object.xid !== null) {
+            message.xid = object.xid;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.aid = message.aid ? Account.toAmino(message.aid) : Account.toAmino(Account.fromPartial({}));
+        obj.xid = message.xid ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Payment.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Payment.decode(message.value);
+    },
+    toProto(message) {
+        return Payment.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.escrow.id.v1.Payment",
+            value: Payment.encode(message).finish()
+        };
+    }
+};

package/esm/akash/escrow/types/v1/account.js

@@ -0,0 +1,224 @@
+import { DecCoin } from "../../../../cosmos/base/v1beta1/coin";
+import { Balance } from "./balance";
+import { Depositor } from "./deposit";
+import { Account as Account1 } from "../../id/v1/id";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseAccountState() {
+    return {
+        owner: "",
+        state: 0,
+        transferred: [],
+        settledAt: BigInt(0),
+        funds: [],
+        deposits: []
+    };
+}
+/**
+ * Account stores state for an escrow account.
+ * @name AccountState
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.AccountState
+ */
+export const AccountState = {
+    typeUrl: "/akash.escrow.types.v1.AccountState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.state !== 0) {
+            writer.uint32(16).int32(message.state);
+        }
+        for (const v of message.transferred) {
+            DecCoin.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.settledAt !== BigInt(0)) {
+            writer.uint32(32).int64(message.settledAt);
+        }
+        for (const v of message.funds) {
+            Balance.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.deposits) {
+            Depositor.encode(v, writer.uint32(50).fork()).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 = createBaseAccountState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.state = reader.int32();
+                    break;
+                case 3:
+                    message.transferred.push(DecCoin.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.settledAt = reader.int64();
+                    break;
+                case 5:
+                    message.funds.push(Balance.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.deposits.push(Depositor.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAccountState();
+        message.owner = object.owner ?? "";
+        message.state = object.state ?? 0;
+        message.transferred = object.transferred?.map(e => DecCoin.fromPartial(e)) || [];
+        message.settledAt = object.settledAt !== undefined && object.settledAt !== null ? BigInt(object.settledAt.toString()) : BigInt(0);
+        message.funds = object.funds?.map(e => Balance.fromPartial(e)) || [];
+        message.deposits = object.deposits?.map(e => Depositor.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAccountState();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.state !== undefined && object.state !== null) {
+            message.state = object.state;
+        }
+        message.transferred = object.transferred?.map(e => DecCoin.fromAmino(e)) || [];
+        if (object.settled_at !== undefined && object.settled_at !== null) {
+            message.settledAt = BigInt(object.settled_at);
+        }
+        message.funds = object.funds?.map(e => Balance.fromAmino(e)) || [];
+        message.deposits = object.deposits?.map(e => Depositor.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.state = message.state ?? 0;
+        if (message.transferred) {
+            obj.transferred = message.transferred.map(e => e ? DecCoin.toAmino(e) : undefined);
+        }
+        else {
+            obj.transferred = message.transferred;
+        }
+        obj.settled_at = message.settledAt ? message.settledAt?.toString() : "0";
+        if (message.funds) {
+            obj.funds = message.funds.map(e => e ? Balance.toAmino(e) : undefined);
+        }
+        else {
+            obj.funds = message.funds;
+        }
+        if (message.deposits) {
+            obj.deposits = message.deposits.map(e => e ? Depositor.toAmino(e) : undefined);
+        }
+        else {
+            obj.deposits = message.deposits;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return AccountState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return AccountState.decode(message.value);
+    },
+    toProto(message) {
+        return AccountState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.escrow.types.v1.AccountState",
+            value: AccountState.encode(message).finish()
+        };
+    }
+};
+function createBaseAccount() {
+    return {
+        id: Account1.fromPartial({}),
+        state: AccountState.fromPartial({})
+    };
+}
+/**
+ * Account
+ * @name Account
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.Account
+ */
+export const Account = {
+    typeUrl: "/akash.escrow.types.v1.Account",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            Account1.encode(message.id, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.state !== undefined) {
+            AccountState.encode(message.state, writer.uint32(18).fork()).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 = createBaseAccount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = Account1.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.state = AccountState.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAccount();
+        message.id = object.id !== undefined && object.id !== null ? Account1.fromPartial(object.id) : undefined;
+        message.state = object.state !== undefined && object.state !== null ? AccountState.fromPartial(object.state) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAccount();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = Account1.fromAmino(object.id);
+        }
+        if (object.state !== undefined && object.state !== null) {
+            message.state = AccountState.fromAmino(object.state);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ? Account1.toAmino(message.id) : Account1.toAmino(Account1.fromPartial({}));
+        obj.state = message.state ? AccountState.toAmino(message.state) : AccountState.toAmino(AccountState.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Account.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Account.decode(message.value);
+    },
+    toProto(message) {
+        return Account.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.escrow.types.v1.Account",
+            value: Account.encode(message).finish()
+        };
+    }
+};

package/esm/akash/escrow/types/v1/balance.js

@@ -0,0 +1,86 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { Decimal } from "@interchainjs/math";
+function createBaseBalance() {
+    return {
+        denom: "",
+        amount: ""
+    };
+}
+/**
+ * Balance holds the unspent coin received from all deposits with same denom
+ * DecCoin is not being used here as it does not support negative values,
+ * and balance may go negative if account is overdrawn.
+ * @name Balance
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.Balance
+ */
+export const Balance = {
+    typeUrl: "/akash.escrow.types.v1.Balance",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(Decimal.fromUserInput(message.amount, 18).atomics);
+        }
+        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 = createBaseBalance();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.denom = reader.string();
+                    break;
+                case 2:
+                    message.amount = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseBalance();
+        message.denom = object.denom ?? "";
+        message.amount = object.amount ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseBalance();
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.denom = message.denom === "" ? undefined : message.denom;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Balance.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Balance.decode(message.value);
+    },
+    toProto(message) {
+        return Balance.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.escrow.types.v1.Balance",
+            value: Balance.encode(message).finish()
+        };
+    }
+};

package/esm/akash/escrow/types/v1/deposit.js

@@ -0,0 +1,107 @@
+import { DecCoin } from "../../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseDepositor() {
+    return {
+        owner: "",
+        height: BigInt(0),
+        source: 0,
+        balance: DecCoin.fromPartial({})
+    };
+}
+/**
+ * Depositor stores state of a deposit.
+ * @name Depositor
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.Depositor
+ */
+export const Depositor = {
+    typeUrl: "/akash.escrow.types.v1.Depositor",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.height !== BigInt(0)) {
+            writer.uint32(16).int64(message.height);
+        }
+        if (message.source !== 0) {
+            writer.uint32(24).int32(message.source);
+        }
+        if (message.balance !== undefined) {
+            DecCoin.encode(message.balance, writer.uint32(34).fork()).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 = createBaseDepositor();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.height = reader.int64();
+                    break;
+                case 3:
+                    message.source = reader.int32();
+                    break;
+                case 4:
+                    message.balance = DecCoin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDepositor();
+        message.owner = object.owner ?? "";
+        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+        message.source = object.source ?? 0;
+        message.balance = object.balance !== undefined && object.balance !== null ? DecCoin.fromPartial(object.balance) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDepositor();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.height !== undefined && object.height !== null) {
+            message.height = BigInt(object.height);
+        }
+        if (object.source !== undefined && object.source !== null) {
+            message.source = object.source;
+        }
+        if (object.balance !== undefined && object.balance !== null) {
+            message.balance = DecCoin.fromAmino(object.balance);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.height = message.height ? message.height?.toString() : "0";
+        obj.source = message.source ?? 0;
+        obj.balance = message.balance ? DecCoin.toAmino(message.balance) : DecCoin.toAmino(DecCoin.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Depositor.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Depositor.decode(message.value);
+    },
+    toProto(message) {
+        return Depositor.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.escrow.types.v1.Depositor",
+            value: Depositor.encode(message).finish()
+        };
+    }
+};