@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.32

package/akash/escrow/types/v1/payment.d.ts

@@ -0,0 +1,150 @@
+import { State } from "./state";
+import { DecCoin, DecCoinAmino, Coin, CoinAmino } from "../../../../cosmos/base/v1beta1/coin";
+import { Payment as Payment1 } from "../../id/v1/id";
+import { PaymentAmino as Payment1Amino } from "../../id/v1/id";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * Payment stores state for a payment.
+ * @name PaymentState
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.PaymentState
+ */
+export interface PaymentState {
+    /**
+     * Owner is the account bech32 address of the user who owns the deployment.
+     * It is a string representing a valid bech32 account address.
+     *
+     * Example:
+     *   "akash1..."
+     */
+    owner: string;
+    /**
+     * State represents the state of the Payment.
+     */
+    state: State;
+    /**
+     * Rate holds the rate of the Payment.
+     */
+    rate: DecCoin;
+    /**
+     * Balance is the current available coins.
+     */
+    balance: DecCoin;
+    /**
+     * Unsettled is the amount needed to settle payment if account is overdrawn
+     */
+    unsettled: DecCoin;
+    /**
+     * Withdrawn corresponds to the amount of coins withdrawn by the Payment.
+     */
+    withdrawn: Coin;
+}
+export interface PaymentStateProtoMsg {
+    typeUrl: "/akash.escrow.types.v1.PaymentState";
+    value: Uint8Array;
+}
+/**
+ * Payment stores state for a payment.
+ * @name PaymentStateAmino
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.PaymentState
+ */
+export interface PaymentStateAmino {
+    /**
+     * Owner is the account bech32 address of the user who owns the deployment.
+     * It is a string representing a valid bech32 account address.
+     *
+     * Example:
+     *   "akash1..."
+     */
+    owner: string;
+    /**
+     * State represents the state of the Payment.
+     */
+    state: State;
+    /**
+     * Rate holds the rate of the Payment.
+     */
+    rate: DecCoinAmino;
+    /**
+     * Balance is the current available coins.
+     */
+    balance: DecCoinAmino;
+    /**
+     * Unsettled is the amount needed to settle payment if account is overdrawn
+     */
+    unsettled: DecCoinAmino;
+    /**
+     * Withdrawn corresponds to the amount of coins withdrawn by the Payment.
+     */
+    withdrawn: CoinAmino;
+}
+export interface PaymentStateAminoMsg {
+    type: "/akash.escrow.types.v1.PaymentState";
+    value: PaymentStateAmino;
+}
+/**
+ * Payment
+ * @name Payment
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.Payment
+ */
+export interface Payment {
+    id: Payment1;
+    state: PaymentState;
+}
+export interface PaymentProtoMsg {
+    typeUrl: "/akash.escrow.types.v1.Payment";
+    value: Uint8Array;
+}
+/**
+ * Payment
+ * @name PaymentAmino
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.Payment
+ */
+export interface PaymentAmino {
+    id: Payment1Amino;
+    state: PaymentStateAmino;
+}
+export interface PaymentAminoMsg {
+    type: "/akash.escrow.types.v1.Payment";
+    value: PaymentAmino;
+}
+/**
+ * Payment stores state for a payment.
+ * @name PaymentState
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.PaymentState
+ */
+export declare const PaymentState: {
+    typeUrl: string;
+    encode(message: PaymentState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PaymentState;
+    fromPartial(object: DeepPartial<PaymentState>): PaymentState;
+    fromAmino(object: PaymentStateAmino): PaymentState;
+    toAmino(message: PaymentState): PaymentStateAmino;
+    fromAminoMsg(object: PaymentStateAminoMsg): PaymentState;
+    fromProtoMsg(message: PaymentStateProtoMsg): PaymentState;
+    toProto(message: PaymentState): Uint8Array;
+    toProtoMsg(message: PaymentState): PaymentStateProtoMsg;
+};
+/**
+ * Payment
+ * @name Payment
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.Payment
+ */
+export declare const Payment: {
+    typeUrl: string;
+    encode(message: Payment, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Payment;
+    fromPartial(object: DeepPartial<Payment>): Payment;
+    fromAmino(object: PaymentAmino): Payment;
+    toAmino(message: Payment): PaymentAmino;
+    fromAminoMsg(object: PaymentAminoMsg): Payment;
+    fromProtoMsg(message: PaymentProtoMsg): Payment;
+    toProto(message: Payment): Uint8Array;
+    toProtoMsg(message: Payment): PaymentProtoMsg;
+};

package/akash/escrow/types/v1/payment.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Payment = exports.PaymentState = void 0;
+const coin_1 = require("../../../../cosmos/base/v1beta1/coin");
+const id_1 = require("../../id/v1/id");
+const binary_1 = require("../../../../binary");
+function createBasePaymentState() {
+    return {
+        owner: "",
+        state: 0,
+        rate: coin_1.DecCoin.fromPartial({}),
+        balance: coin_1.DecCoin.fromPartial({}),
+        unsettled: coin_1.DecCoin.fromPartial({}),
+        withdrawn: coin_1.Coin.fromPartial({})
+    };
+}
+/**
+ * Payment stores state for a payment.
+ * @name PaymentState
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.PaymentState
+ */
+exports.PaymentState = {
+    typeUrl: "/akash.escrow.types.v1.PaymentState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.state !== 0) {
+            writer.uint32(16).int32(message.state);
+        }
+        if (message.rate !== undefined) {
+            coin_1.DecCoin.encode(message.rate, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.balance !== undefined) {
+            coin_1.DecCoin.encode(message.balance, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.unsettled !== undefined) {
+            coin_1.DecCoin.encode(message.unsettled, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.withdrawn !== undefined) {
+            coin_1.Coin.encode(message.withdrawn, writer.uint32(50).fork()).ldelim();
+        }
+        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 = createBasePaymentState();
+        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.rate = coin_1.DecCoin.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.balance = coin_1.DecCoin.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.unsettled = coin_1.DecCoin.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.withdrawn = coin_1.Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePaymentState();
+        message.owner = object.owner ?? "";
+        message.state = object.state ?? 0;
+        message.rate = object.rate !== undefined && object.rate !== null ? coin_1.DecCoin.fromPartial(object.rate) : undefined;
+        message.balance = object.balance !== undefined && object.balance !== null ? coin_1.DecCoin.fromPartial(object.balance) : undefined;
+        message.unsettled = object.unsettled !== undefined && object.unsettled !== null ? coin_1.DecCoin.fromPartial(object.unsettled) : undefined;
+        message.withdrawn = object.withdrawn !== undefined && object.withdrawn !== null ? coin_1.Coin.fromPartial(object.withdrawn) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePaymentState();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.state !== undefined && object.state !== null) {
+            message.state = object.state;
+        }
+        if (object.rate !== undefined && object.rate !== null) {
+            message.rate = coin_1.DecCoin.fromAmino(object.rate);
+        }
+        if (object.balance !== undefined && object.balance !== null) {
+            message.balance = coin_1.DecCoin.fromAmino(object.balance);
+        }
+        if (object.unsettled !== undefined && object.unsettled !== null) {
+            message.unsettled = coin_1.DecCoin.fromAmino(object.unsettled);
+        }
+        if (object.withdrawn !== undefined && object.withdrawn !== null) {
+            message.withdrawn = coin_1.Coin.fromAmino(object.withdrawn);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.state = message.state ?? 0;
+        obj.rate = message.rate ? coin_1.DecCoin.toAmino(message.rate) : coin_1.DecCoin.toAmino(coin_1.DecCoin.fromPartial({}));
+        obj.balance = message.balance ? coin_1.DecCoin.toAmino(message.balance) : coin_1.DecCoin.toAmino(coin_1.DecCoin.fromPartial({}));
+        obj.unsettled = message.unsettled ? coin_1.DecCoin.toAmino(message.unsettled) : coin_1.DecCoin.toAmino(coin_1.DecCoin.fromPartial({}));
+        obj.withdrawn = message.withdrawn ? coin_1.Coin.toAmino(message.withdrawn) : coin_1.Coin.toAmino(coin_1.Coin.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PaymentState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.PaymentState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PaymentState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.escrow.types.v1.PaymentState",
+            value: exports.PaymentState.encode(message).finish()
+        };
+    }
+};
+function createBasePayment() {
+    return {
+        id: id_1.Payment.fromPartial({}),
+        state: exports.PaymentState.fromPartial({})
+    };
+}
+/**
+ * Payment
+ * @name Payment
+ * @package akash.escrow.types.v1
+ * @see proto type: akash.escrow.types.v1.Payment
+ */
+exports.Payment = {
+    typeUrl: "/akash.escrow.types.v1.Payment",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            id_1.Payment.encode(message.id, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.state !== undefined) {
+            exports.PaymentState.encode(message.state, writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBasePayment();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = id_1.Payment.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.state = exports.PaymentState.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePayment();
+        message.id = object.id !== undefined && object.id !== null ? id_1.Payment.fromPartial(object.id) : undefined;
+        message.state = object.state !== undefined && object.state !== null ? exports.PaymentState.fromPartial(object.state) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePayment();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = id_1.Payment.fromAmino(object.id);
+        }
+        if (object.state !== undefined && object.state !== null) {
+            message.state = exports.PaymentState.fromAmino(object.state);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ? id_1.Payment.toAmino(message.id) : id_1.Payment.toAmino(id_1.Payment.fromPartial({}));
+        obj.state = message.state ? exports.PaymentState.toAmino(message.state) : exports.PaymentState.toAmino(exports.PaymentState.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Payment.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Payment.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Payment.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.escrow.types.v1.Payment",
+            value: exports.Payment.encode(message).finish()
+        };
+    }
+};

package/akash/escrow/types/v1/state.d.ts

@@ -0,0 +1,15 @@
+/** State stores state for an escrow account. */
+export declare enum State {
+    /** invalid - AccountStateInvalid is an invalid state. */
+    invalid = 0,
+    /** open - StateOpen is the state when an object is open. */
+    open = 1,
+    /** closed - StateClosed is the state when an object is closed. */
+    closed = 2,
+    /** overdrawn - StateOverdrawn is the state when an object are overdrawn. */
+    overdrawn = 3,
+    UNRECOGNIZED = -1
+}
+export declare const StateAmino: typeof State;
+export declare function stateFromJSON(object: any): State;
+export declare function stateToJSON(object: State): string;

package/akash/escrow/types/v1/state.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateAmino = exports.State = void 0;
+exports.stateFromJSON = stateFromJSON;
+exports.stateToJSON = stateToJSON;
+//@ts-nocheck
+/** State stores state for an escrow account. */
+var State;
+(function (State) {
+    /** invalid - AccountStateInvalid is an invalid state. */
+    State[State["invalid"] = 0] = "invalid";
+    /** open - StateOpen is the state when an object is open. */
+    State[State["open"] = 1] = "open";
+    /** closed - StateClosed is the state when an object is closed. */
+    State[State["closed"] = 2] = "closed";
+    /** overdrawn - StateOverdrawn is the state when an object are overdrawn. */
+    State[State["overdrawn"] = 3] = "overdrawn";
+    State[State["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(State || (exports.State = State = {}));
+exports.StateAmino = State;
+function stateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "invalid":
+            return State.invalid;
+        case 1:
+        case "open":
+            return State.open;
+        case 2:
+        case "closed":
+            return State.closed;
+        case 3:
+        case "overdrawn":
+            return State.overdrawn;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return State.UNRECOGNIZED;
+    }
+}
+function stateToJSON(object) {
+    switch (object) {
+        case State.invalid:
+            return "invalid";
+        case State.open:
+            return "open";
+        case State.closed:
+            return "closed";
+        case State.overdrawn:
+            return "overdrawn";
+        case State.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}

package/akash/escrow/v1/authz.d.ts

@@ -0,0 +1,114 @@
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Scope defines the types of deposit operations that can be authorized.
+ * This enum is used to restrict the authorization to specific deposit contexts,
+ * allowing fine-grained permission control within the authz system.
+ */
+export declare enum DepositAuthorization_Scope {
+    /** invalid - Prefix should start with 0 in enum. So declaring dummy state. */
+    invalid = 0,
+    /** deployment - DepositScopeDeployment allows deposits for deployment-related operations. */
+    deployment = 1,
+    /** bid - DepositScopeBid allows deposits for bid-related operations. */
+    bid = 2,
+    UNRECOGNIZED = -1
+}
+export declare const DepositAuthorization_ScopeAmino: typeof DepositAuthorization_Scope;
+export declare function depositAuthorization_ScopeFromJSON(object: any): DepositAuthorization_Scope;
+export declare function depositAuthorization_ScopeToJSON(object: DepositAuthorization_Scope): string;
+/**
+ * DepositAuthorization allows the grantee to deposit up to spend_limit coins from
+ * the granter's account for Akash deployments and bids. This authorization is used
+ * within the Cosmos SDK authz module to grant scoped permissions for deposit operations.
+ * The authorization can be restricted to specific scopes (deployment or bid) to limit
+ * what types of deposits the grantee is authorized to make on behalf of the granter.
+ * @name DepositAuthorization
+ * @package akash.escrow.v1
+ * @see proto type: akash.escrow.v1.DepositAuthorization
+ */
+export interface DepositAuthorization {
+    /**
+     * SpendLimit is the maximum amount the grantee is authorized to spend from the granter's account.
+     * This limit applies cumulatively across all deposit operations within the authorized scopes.
+     * Once this limit is reached, the authorization becomes invalid and no further deposits can be made.
+     * Deprecated: use spend_limits instead
+     */
+    spendLimit: Coin;
+    /**
+     * Scopes defines the specific types of deposit operations this authorization permits.
+     * This provides fine-grained control over what operations
+     * the grantee can perform using the granter's funds.
+     */
+    scopes: DepositAuthorization_Scope[];
+    /**
+     * SpendLimits specifies the maximum amount per denomination the grantee is authorized to spend.
+     * Each entry represents the limit for a specific denomination, enforced independently.
+     * Once an individual denomination's limit is exhausted, no further deposits can be made in that denomination.
+     */
+    spendLimits: Coin[];
+}
+export interface DepositAuthorizationProtoMsg {
+    typeUrl: "/akash.escrow.v1.DepositAuthorization";
+    value: Uint8Array;
+}
+/**
+ * DepositAuthorization allows the grantee to deposit up to spend_limit coins from
+ * the granter's account for Akash deployments and bids. This authorization is used
+ * within the Cosmos SDK authz module to grant scoped permissions for deposit operations.
+ * The authorization can be restricted to specific scopes (deployment or bid) to limit
+ * what types of deposits the grantee is authorized to make on behalf of the granter.
+ * @name DepositAuthorizationAmino
+ * @package akash.escrow.v1
+ * @see proto type: akash.escrow.v1.DepositAuthorization
+ */
+export interface DepositAuthorizationAmino {
+    /**
+     * SpendLimit is the maximum amount the grantee is authorized to spend from the granter's account.
+     * This limit applies cumulatively across all deposit operations within the authorized scopes.
+     * Once this limit is reached, the authorization becomes invalid and no further deposits can be made.
+     * Deprecated: use spend_limits instead
+     */
+    spend_limit: CoinAmino;
+    /**
+     * Scopes defines the specific types of deposit operations this authorization permits.
+     * This provides fine-grained control over what operations
+     * the grantee can perform using the granter's funds.
+     */
+    scopes: DepositAuthorization_Scope[];
+    /**
+     * SpendLimits specifies the maximum amount per denomination the grantee is authorized to spend.
+     * Each entry represents the limit for a specific denomination, enforced independently.
+     * Once an individual denomination's limit is exhausted, no further deposits can be made in that denomination.
+     */
+    spend_limits: CoinAmino[];
+}
+export interface DepositAuthorizationAminoMsg {
+    type: "akash/DepositAuthorization";
+    value: DepositAuthorizationAmino;
+}
+/**
+ * DepositAuthorization allows the grantee to deposit up to spend_limit coins from
+ * the granter's account for Akash deployments and bids. This authorization is used
+ * within the Cosmos SDK authz module to grant scoped permissions for deposit operations.
+ * The authorization can be restricted to specific scopes (deployment or bid) to limit
+ * what types of deposits the grantee is authorized to make on behalf of the granter.
+ * @name DepositAuthorization
+ * @package akash.escrow.v1
+ * @see proto type: akash.escrow.v1.DepositAuthorization
+ */
+export declare const DepositAuthorization: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: DepositAuthorization, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): DepositAuthorization;
+    fromPartial(object: DeepPartial<DepositAuthorization>): DepositAuthorization;
+    fromAmino(object: DepositAuthorizationAmino): DepositAuthorization;
+    toAmino(message: DepositAuthorization): DepositAuthorizationAmino;
+    fromAminoMsg(object: DepositAuthorizationAminoMsg): DepositAuthorization;
+    toAminoMsg(message: DepositAuthorization): DepositAuthorizationAminoMsg;
+    fromProtoMsg(message: DepositAuthorizationProtoMsg): DepositAuthorization;
+    toProto(message: DepositAuthorization): Uint8Array;
+    toProtoMsg(message: DepositAuthorization): DepositAuthorizationProtoMsg;
+};