@bitgo/public-types 6.22.0 → 6.24.0

package/src/schema/transactionRequest/intents/trxClaimRewardsIntent.ts

@@ -4,13 +4,19 @@ import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
+ * Claim accumulated Tron staking rewards (WithdrawBalance) to the owner's
+ * address. The reward balance must be non-zero; the handler does not verify
+ * the amount before submitting the transaction. Valid on TRX and TTRX.
+ *
  * @title TRX Claim Rewards Intent
  */
 export const TrxClaimRewardsIntent = t.intersection([
   BaseStakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Must be `"stakeClaimRewards"`. */
     intentType: intentTypes.stakeClaimRewards,
+    /** Tron address of the wallet owner; must match the wallet's root address. */
     ownerAddress: t.string,
   }),
 ]);

package/src/schema/transactionRequest/intents/trxDelegateResourceIntent.ts

@@ -4,15 +4,24 @@ import { BaseStakeIntent } from "./baseStakeIntent";
 import { intentTypes } from "./intentType";
 
 /**
+ * Delegate staked BANDWIDTH or ENERGY resources to another Tron address
+ * (DelegateResourceContract). The owner must have sufficient staked
+ * resources; the receiver address must be an active Tron account; and the
+ * amount must be at least 1 TRX (1,000,000 sun). Valid on TRX and TTRX.
+ *
  * @title TRX Delegate Resource Intent
  */
 export const TrxDelegateResourceIntent = t.intersection([
   BaseStakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Must be `"delegateResource"`. */
     intentType: intentTypes.delegateResource,
+    /** Tron address of the resource owner delegating their staked resources. */
     ownerAddress: t.string,
+    /** Tron address of the account receiving the delegated resources; must be an active Tron account. */
     receiverAddress: t.string,
+    /** The resource type to delegate: `BANDWIDTH` or `ENERGY`. */
     resource: t.union([t.literal("BANDWIDTH"), t.literal("ENERGY")]),
   }),
 ]);

package/src/schema/transactionRequest/intents/trxFreezeIntent.ts

@@ -4,15 +4,24 @@ import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
+ * Stake (freeze) TRX to obtain BANDWIDTH or ENERGY using the Tron Stake V2
+ * protocol (FreezeBalanceV2). The spendable balance must be greater than or
+ * equal to the freeze amount plus the transaction fee.
+ * Valid on TRX and TTRX.
+ *
  * @title TRX Freeze Intent
  */
 export const TrxFreezeIntent = t.intersection([
   BaseStakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Must be `"stake"`. */
     intentType: intentTypes.stake,
+    /** Tron address of the Super Representative the user intends to vote for after freezing. Stored by the staking service to auto-construct the subsequent vote intent; not consumed by wallet-platform's freeze transaction builder. */
     validatorAddress: t.string,
+    /** Tron address of the wallet owner staking the TRX. */
     ownerAddress: t.string,
+    /** The resource type to obtain by staking: `BANDWIDTH` or `ENERGY`. */
     resource: t.union([t.literal("BANDWIDTH"), t.literal("ENERGY")]),
   }),
 ]);

package/src/schema/transactionRequest/intents/trxUndelegateResourceIntent.ts

@@ -4,15 +4,24 @@ import { BaseStakeIntent } from "./baseStakeIntent";
 import { intentTypes } from "./intentType";
 
 /**
+ * Reclaim previously delegated BANDWIDTH or ENERGY resources from a
+ * receiver address (UnDelegateResourceContract). The undelegatable balance
+ * must be sufficient to cover the requested amount.
+ * Valid on TRX and TTRX.
+ *
  * @title TRX Undelegate Resource Intent
  */
 export const TrxUndelegateResourceIntent = t.intersection([
   BaseStakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Must be `"undelegateResource"`. */
     intentType: intentTypes.undelegateResource,
+    /** Tron address of the resource owner reclaiming the delegated resources. */
     ownerAddress: t.string,
+    /** Tron address of the account from which the resources are being reclaimed. */
     receiverAddress: t.string,
+    /** The resource type to reclaim: `BANDWIDTH` or `ENERGY`. */
     resource: t.union([t.literal("BANDWIDTH"), t.literal("ENERGY")]),
   }),
 ]);

package/src/schema/transactionRequest/intents/trxUnfreezeIntent.ts

@@ -4,14 +4,22 @@ import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
+ * Unstake (unfreeze) previously staked TRX using the Tron Stake V2
+ * protocol (UnfreezeBalanceV2). Initiates the unstaking waiting period;
+ * use the `claim` intent to withdraw the TRX after the waiting period
+ * has elapsed. Valid on TRX and TTRX.
+ *
  * @title TRX Unfreeze Intent
  */
 export const TrxUnfreezeIntent = t.intersection([
   BaseStakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Must be `"unstake"`. */
     intentType: intentTypes.unstake,
+    /** Tron address of the wallet owner unstaking the TRX. */
     ownerAddress: t.string,
+    /** The resource type to unstake: `BANDWIDTH` or `ENERGY`. */
     resource: t.union([t.literal("BANDWIDTH"), t.literal("ENERGY")]),
   }),
 ]);

package/src/schema/transactionRequest/intents/trxVoteIntent.ts

@@ -4,22 +4,33 @@ import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 export const TrxVote = t.type({
+  /** Tron address of the Super Representative (SR) receiving the votes. */
   vote_address: t.string,
+  /** Number of votes to allocate to this SR, as a decimal string. */
   vote_count: t.string,
 });
 
 export type TrxVote = t.TypeOf<typeof TrxVote>;
 
 /**
+ * Cast votes for Tron Super Representatives (SR) using accumulated Tron
+ * Power (VoteWitnessContract). The total vote count across all entries must
+ * not exceed the available Tron Power. Each staked TRX provides 1 unit of
+ * Tron Power. Valid on TRX and TTRX.
+ *
  * @title TRX Vote Intent
  */
 export const TrxVoteIntent = t.intersection([
   BaseStakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Must be `"voteDelegation"`. */
     intentType: intentTypes.voteDelegation,
+    /** Tron address of the Super Representative selected during the freeze step. Carried forward by the staking service so the user does not need to re-select a validator; not consumed by wallet-platform's vote transaction builder (which reads the `votes` array instead). */
     validatorAddress: t.string,
+    /** Tron address of the wallet owner casting the votes. */
     ownerAddress: t.string,
+    /** List of vote allocations. Each entry specifies a Super Representative address and the number of votes to assign. Total votes must not exceed available Tron Power. */
     votes: t.array(TrxVote),
   }),
 ]);

package/src/schema/transactionRequest/intents/trxWithdrawExpireUnfreezeIntent.ts

@@ -4,13 +4,20 @@ import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
+ * Withdraw previously unstaked TRX after the Tron unstaking waiting period
+ * has elapsed (WithdrawExpireUnfreeze). The handler does not verify that
+ * the waiting period has passed before submitting the transaction. Use the
+ * `unstake` intent to begin the unstaking process. Valid on TRX and TTRX.
+ *
  * @title TRX Withdraw Expire Unfreeze Intent
  */
 export const TrxWithdrawExpireUnfreezeIntent = t.intersection([
   BaseStakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Must be `"claim"`. */
     intentType: intentTypes.claim,
+    /** Tron address of the wallet owner withdrawing the unstaked TRX. */
     ownerAddress: t.string,
   }),
 ]);

package/src/schema/transactionRequest/intents/vetDecreaseStakeIntent.ts

@@ -5,19 +5,19 @@ import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
- * @title VET Decrease Stake Intent
- *
- * Intent for decreasing (partially unstaking) the stake amount for an existing validator
- * @param {Amount} amount - The amount of VET to remove from the existing stake
- * @param {string} validatorAddress - The address of the validator
- * @param {string} stakingContractAddress - The address of the staking contract
+ * Withdraw a portion of VET staked with a VeChain validator, reducing the
+ * position size. The specified amount is returned to the sender's wallet. No
+ * VET is spent — gas is paid by the enterprise gas tank (VTHO).
  */
 export const VetDecreaseStakeIntent = t.intersection([
   BaseStakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Must be "decreaseStake". */
     intentType: intentTypes.decreaseStake,
+    /** Address of the validator whose staked position is being reduced. */
     validatorAddress: NonEmptyString,
+    /** Address of the VeChain staking contract holding the position. */
     stakingContractAddress: NonEmptyString,
   }),
 ]);

package/src/schema/transactionRequest/intents/vetDelegateIntent.ts

@@ -3,17 +3,19 @@ import { DelegateIntent } from "./delegateIntent";
 import { NonEmptyString } from "io-ts-types";
 
 /**
- * @title VET Delegate Intent
- *
- * @param {string} tokenId - The ID of the NFT token to delegate
- * @param {string} stakingContractAddress - The address of the stargate contract
- * @param {string} validatorAddress - address of the validator to delegate to
+ * Delegate a VeChain staking NFT to a validator, granting the validator voting
+ * and reward rights for that position. No VET is spent — this is an NFT
+ * assignment operation, not a financial transfer. Gas is paid by the enterprise
+ * gas tank (VTHO).
  */
 export const VetDelegateIntent = t.intersection([
   DelegateIntent,
   t.type({
+    /** ID of the staking NFT to delegate to the validator. */
     tokenId: NonEmptyString,
+    /** Address of the VeChain staking (Stargate) contract that holds the NFT. */
     stakingContractAddress: NonEmptyString,
+    /** Address of the validator to delegate the staking NFT to. */
     validatorAddress: NonEmptyString,
   }),
 ]);

package/src/schema/transactionRequest/intents/vetIncreaseStakeIntent.ts

@@ -5,19 +5,19 @@ import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
- * @title VET Increase Stake Intent
- *
- * Intent for increasing the stake amount for an existing validator
- * @param {Amount} amount - The amount of VET to add to the existing stake
- * @param {string} validatorAddress - The address of the validator
- * @param {string} stakingContractAddress - The address of the staking contract
+ * Increase the VET staked with an existing VeChain validator by depositing
+ * additional VET into the staking contract. The sender must have sufficient VET
+ * balance. Gas is paid by the enterprise gas tank (VTHO).
  */
 export const VetIncreaseStakeIntent = t.intersection([
   BaseStakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Must be "increaseStake". */
     intentType: intentTypes.increaseStake,
+    /** Address of the validator whose staked position is being increased. */
     validatorAddress: NonEmptyString,
+    /** Address of the VeChain staking contract holding the existing position. */
     stakingContractAddress: NonEmptyString,
   }),
 ]);

package/src/schema/transactionRequest/intents/vetSignalExitIntent.ts

@@ -4,18 +4,19 @@ import { NonEmptyString } from "io-ts-types";
 import { intentTypes } from "./intentType";
 
 /**
- * @title VET Signal Exit Intent
- *
- * Intent for signaling the exit of a validator position at the end of the staking period.
- * This is the first step in a full unstake flow for validator registration.
- * @param {string} validatorAddress - The address of the validator to exit
- * @param {string} stakingContractAddress - The address of the staking contract
+ * Signal the intent to exit a VeChain validator staking position, initiating
+ * the cooldown period. This is the first step in the validator unstake flow —
+ * must be followed by `withdrawStake` after the cooldown expires. No VET is
+ * spent; gas is paid by the enterprise gas tank (VTHO).
  */
 export const VetSignalExitIntent = t.intersection([
   BaseStakeIntent,
   t.type({
+    /** Must be "signalExit". */
     intentType: intentTypes.signalExit,
+    /** Address of the validator node whose position is being exited. */
     validatorAddress: NonEmptyString,
+    /** Address of the VeChain staking contract where the validator position is held. */
     stakingContractAddress: NonEmptyString,
   }),
 ]);

package/src/schema/transactionRequest/intents/vetStakeClaimRewardsIntent.ts

@@ -3,19 +3,17 @@ import { NonEmptyString } from "io-ts-types";
 import { StakeClaimRewardsIntent } from "./stakeClaimRewardsIntent";
 
 /**
- * @title VET Stake Claim Rewards Intent
- *
- * Intent for claiming rewards from VeChain (VET) staking
- * VET staking rewards are accumulated by NFTs that represent stakes in the stargate contract.
- * This intent calls the claimRewards function on the stargate contract for a specific NFT token.
- *
- * @param {string} tokenId - The ID of the NFT token to claim rewards for
- * @param {string} stakingContractAddress - The address of the stargate contract
+ * Claim VTHO rewards accumulated by a VeChain staking NFT position. Rewards
+ * accrue in VTHO (VeChain's energy token) for each NFT held in the Stargate
+ * contract. Supply the NFT's token ID and the staking contract address. Gas is
+ * paid by the enterprise gas tank (VTHO).
  */
 export const VetStakeClaimRewardsIntent = t.intersection([
   StakeClaimRewardsIntent,
   t.type({
+    /** ID of the staking NFT whose accumulated VTHO rewards will be claimed. */
     tokenId: NonEmptyString,
+    /** Address of the VeChain staking (Stargate) contract that holds the NFT. */
     stakingContractAddress: NonEmptyString,
   }),
 ]);

package/src/schema/transactionRequest/intents/vetStakingIntent.ts

@@ -4,19 +4,18 @@ import { BaseIntentWithAmount } from "./baseIntent";
 import { NonEmptyString } from "io-ts-types";
 
 /**
- * @title VET Staking Intent
- *
- * Intent for staking VeChain (VET) tokens
- *
- * @param {Amount} amount - The amount of VET to stake
- * @param {string} stakingContractAddress - The address of the staking contract
- * @param {string} levelId - The level of the NFT tier
+ * Activate a new VeChain staking position by depositing VET into the staking
+ * contract. Use `levelId` to select the staking tier. To add to an existing
+ * position, use `increaseStake` instead. All VeChain gas fees are paid by the
+ * enterprise gas tank (VTHO); the sender pays no gas.
  */
 export const VetStakingIntent = t.intersection([
   StakeIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Address of the VeChain staking contract that will hold the staked VET. */
     stakingContractAddress: NonEmptyString,
+    /** Staking tier level in the VeChain contract. Determines reward rate and lock parameters. */
     levelId: NonEmptyString,
   }),
 ]);

package/src/schema/transactionRequest/intents/vetUnstakingIntent.ts

@@ -3,23 +3,18 @@ import { UnstakeIntent } from "./unstakeIntent";
 import { NonEmptyString } from "io-ts-types";
 import { UndelegateIntent } from "./undelegateIntent";
 
-/**
- * @title Common VET unstake intent fields
- *
- *
- * @param {string} tokenId - The ID of the NFT token
- * @param {string} stakingContractAddress - The address of the stargate contract
- */
 const VetUnstakeCommonFields = t.type({
+  /** ID of the staking NFT to operate on. */
   tokenId: NonEmptyString,
+  /** Address of the VeChain staking (Stargate) contract that holds the NFT. */
   stakingContractAddress: NonEmptyString,
 });
 
 /**
- * @title VET Exit Delegation Intent
- *
- * Intent for the first step of VET unstaking process - exiting delegation
- * This calls the exitDelegation function on the stargate contract
+ * Remove validator delegation for a VeChain staking NFT, returning it to an
+ * undelegated state. This is the first step in the full unstaking flow — must
+ * precede `unstake` (burn NFT). No VET is spent; gas is paid by the enterprise
+ * gas tank (VTHO).
  */
 export const VetExitDelegationIntent = t.intersection([
   UndelegateIntent,
@@ -29,10 +24,10 @@ export const VetExitDelegationIntent = t.intersection([
 export type VetExitDelegationIntent = t.TypeOf<typeof VetExitDelegationIntent>;
 
 /**
- * @title VET Burn NFT Intent
- *
- * Intent for the second step of VET unstaking process - burning the NFT
- * This calls the burn function on the stargate contract after the cooldown period
+ * Burn a VeChain staking NFT to complete the unstaking withdrawal and reclaim
+ * staked VET. This is the second (final) step in the basic unstaking flow —
+ * must be preceded by `undelegate`. No VET is spent by the sender; gas is paid
+ * by the enterprise gas tank (VTHO).
  */
 export const VetBurnNFTIntent = t.intersection([
   UnstakeIntent,

package/src/schema/transactionRequest/intents/vetValidatorRegistrationIntent.ts

@@ -4,20 +4,23 @@ import { NonEmptyString } from "io-ts-types";
 import { BaseIntentWithAmount } from "./baseIntent";
 
 /**
- * @title VET Validator Registration Intent
- *
- * Intent for adding validator with stake amount from endorser
- * @param {Amount} amount - The amount of VET to stake
- * @param {string} validatorAddress - The address of the validator
- * @param {number} stakingPeriod - The staking period which can be one of the three -- 60480 (7 days), 129600 (15 days) or 259200 (30 days).
- * @param {string} stakingContractAddress - The address of the staking contract
+ * Register a new validator node in VeChain's staking contract by depositing a
+ * VET bond. The staking period determines the lock duration (60480, 129600, or
+ * 259200 blocks). Gas is paid by the enterprise gas tank (VTHO).
  */
 export const VetValidatorRegistrationIntent = t.intersection([
   ValidatorRegistrationIntent,
   BaseIntentWithAmount,
   t.type({
+    /** Address of the validator node being registered. Must be a valid VeChain address. */
     validatorAddress: NonEmptyString,
-    stakingPeriod: t.number,
+    /** Duration of the staking lock period in blocks. Valid values: 60480 (~7 days), 129600 (~15 days), 259200 (~30 days). */
+    stakingPeriod: t.union([
+      t.literal(60480),
+      t.literal(129600),
+      t.literal(259200),
+    ]),
+    /** Address of the VeChain staking contract to register the validator with. */
     stakingContractAddress: NonEmptyString,
   }),
 ]);

package/src/schema/transactionRequest/intents/vetWithdrawStakeIntent.ts

@@ -4,18 +4,19 @@ import { NonEmptyString } from "io-ts-types";
 import { intentTypes } from "./intentType";
 
 /**
- * @title VET Withdraw Stake Intent
- *
- * Intent for withdrawing a validator's stake after the validator has exited.
- * This is the second step in a full unstake flow, after signalExit and the cooldown period.
- * @param {string} validatorAddress - The address of the validator to withdraw from
- * @param {string} stakingContractAddress - The address of the staking contract
+ * Withdraw a VeChain validator's staked VET after the cooldown period from a
+ * `signalExit` has completed. This is the second (final) step in the validator
+ * unstake flow. No VET is spent — staked VET is returned to the sender; gas is
+ * paid by the enterprise gas tank (VTHO).
  */
 export const VetWithdrawStakeIntent = t.intersection([
   BaseStakeIntent,
   t.type({
+    /** Must be "withdrawStake". */
     intentType: intentTypes.withdrawStake,
+    /** Address of the validator node whose staked VET is being withdrawn. */
     validatorAddress: NonEmptyString,
+    /** Address of the VeChain staking contract holding the exited position. */
     stakingContractAddress: NonEmptyString,
   }),
 ]);

package/dist/src/schema/transactionRequest/intents/irysPledgeIntent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"irysPledgeIntent.js","sourceRoot":"","sources":["../../../../../src/schema/transactionRequest/intents/irysPledgeIntent.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2B;AAC3B,uDAAoD;AACpD,6CAA2C;AAC3C,uDAAyD;AAM5C,QAAA,0BAA0B,GAAG,CAAC,CAAC,YAAY,CAAC;IACvD,sCAAoB;IACpB,CAAC,CAAC,IAAI,CAAC;QAEL,WAAW,EAAE,CAAC,CAAC,MAAM;KACtB,CAAC;CACH,CAAC,CAAC;AAcU,QAAA,gBAAgB,GAAG,CAAC,CAAC,YAAY,CAAC;IAC7C,iCAAe;IACf,CAAC,CAAC,IAAI,CAAC;QACL,UAAU,EAAE,wBAAW,CAAC,MAAM;QAC9B,gBAAgB,EAAE,kCAA0B;KAC7C,CAAC;CACH,CAAC,CAAC"}

package/dist/src/schema/transactionRequest/intents/irysStakeIntent.d.ts

@@ -1,93 +0,0 @@
-import * as t from "io-ts";
-export declare const IrysCommitmentParams: t.TypeC<{
-    commitmentFee: t.StringC;
-    commitmentValue: t.StringC;
-    signerAddress: t.StringC;
-    chainId: t.NumberC;
-}>;
-export type IrysCommitmentParams = t.TypeOf<typeof IrysCommitmentParams>;
-export declare const IrysStakeIntent: t.IntersectionC<[t.IntersectionC<[t.IntersectionC<[t.IntersectionC<[t.TypeC<{
-    intentType: t.KeyofC<{
-        payment: t.LiteralC<"payment">;
-        transferToken: t.LiteralC<"transferToken">;
-        consolidate: t.LiteralC<"consolidate">;
-        consolidateToken: t.LiteralC<"consolidateToken">;
-        fanout: t.LiteralC<"fanout">;
-        stake: t.LiteralC<"stake">;
-        unstake: t.LiteralC<"unstake">;
-        delegate: t.LiteralC<"delegate">;
-        undelegate: t.LiteralC<"undelegate">;
-        switchValidator: t.LiteralC<"switchValidator">;
-        claim: t.LiteralC<"claim">;
-        stakeClaimRewards: t.LiteralC<"stakeClaimRewards">;
-        pledge: t.LiteralC<"pledge">;
-        voteDelegation: t.LiteralC<"voteDelegation">;
-        vote: t.LiteralC<"vote">;
-        createAccount: t.LiteralC<"createAccount">;
-        updateAccount: t.LiteralC<"updateAccount">;
-        addTrustLine: t.LiteralC<"addTrustLine">;
-        removeTrustLine: t.LiteralC<"removeTrustLine">;
-        signMessage: t.LiteralC<"signMessage">;
-        signTypedStructuredData: t.LiteralC<"signTypedStructuredData">;
-        enableToken: t.LiteralC<"enableToken">;
-        authorize: t.LiteralC<"authorize">;
-        acceleration: t.LiteralC<"acceleration">;
-        fillNonce: t.LiteralC<"fillNonce">;
-        walletRecovery: t.LiteralC<"walletRecovery">;
-        contractCall: t.LiteralC<"contractCall">;
-        deactivate: t.LiteralC<"deactivate">;
-        customTx: t.LiteralC<"customTx">;
-        closeAssociatedTokenAccount: t.LiteralC<"closeAssociatedTokenAccount">;
-        stakeWithCallData: t.LiteralC<"stakeWithCallData">;
-        unstakeWithCallData: t.LiteralC<"unstakeWithCallData">;
-        switchValidatorWithCallData: t.LiteralC<"switchValidatorWithCallData">;
-        feeAddressTransfer: t.LiteralC<"feeAddressTransfer">;
-        tokenApproval: t.LiteralC<"tokenApproval">;
-        transferStake: t.LiteralC<"transferStake">;
-        validatorRegistration: t.LiteralC<"validatorRegistration">;
-        increaseStake: t.LiteralC<"increaseStake">;
-        decreaseStake: t.LiteralC<"decreaseStake">;
-        signalExit: t.LiteralC<"signalExit">;
-        withdrawStake: t.LiteralC<"withdrawStake">;
-        spotTransfer: t.LiteralC<"spotTransfer">;
-        bridgeFunds: t.LiteralC<"bridgeFunds">;
-        enableBridging: t.LiteralC<"enableBridging">;
-        goUnstake: t.LiteralC<"goUnstake">;
-        createBtcDelegation: t.LiteralC<"createBtcDelegation">;
-        transferAccept: t.LiteralC<"transferAccept">;
-        transferReject: t.LiteralC<"transferReject">;
-        transferAcknowledge: t.LiteralC<"transferAcknowledge">;
-        transferOfferWithdrawn: t.LiteralC<"transferOfferWithdrawn">;
-        cosignDelegationProposal: t.LiteralC<"cosignDelegationProposal">;
-        cosignDelegationAccept: t.LiteralC<"cosignDelegationAccept">;
-        allocationRequest: t.LiteralC<"allocationRequest">;
-        cantonCommand: t.LiteralC<"cantonCommand">;
-        allocationAllocate: t.LiteralC<"allocationAllocate">;
-        "defi-deposit": t.LiteralC<"defi-deposit">;
-        "defi-redeem": t.LiteralC<"defi-redeem">;
-        "defi-approve": t.LiteralC<"defi-approve">;
-        delegateResource: t.LiteralC<"delegateResource">;
-        undelegateResource: t.LiteralC<"undelegateResource">;
-        export: t.LiteralC<"export">;
-        import: t.LiteralC<"import">;
-        importtoc: t.LiteralC<"importtoc">;
-    }>;
-}>, t.PartialC<{
-    sequenceId: t.UnionC<[t.Type<string, string, unknown>, t.UndefinedC]>;
-    comment: t.UnionC<[t.Type<string, string, unknown>, t.UndefinedC]>;
-    nonce: t.UnionC<[t.Type<string | number, string | number, unknown>, t.UndefinedC]>;
-}>]>, t.TypeC<{
-    stakingRequestId: t.StringC;
-}>, t.PartialC<{
-    source: t.KeyofC<typeof import("./stakingRequestSource").StakingRequestSourceEnum>;
-}>]>, t.TypeC<{
-    intentType: t.LiteralC<"stake">;
-}>]>, t.TypeC<{
-    commitmentParams: t.TypeC<{
-        commitmentFee: t.StringC;
-        commitmentValue: t.StringC;
-        signerAddress: t.StringC;
-        chainId: t.NumberC;
-    }>;
-}>]>;
-export type IrysStakeIntent = t.TypeOf<typeof IrysStakeIntent>;

package/dist/src/schema/transactionRequest/intents/irysStakeIntent.js

@@ -1,41 +0,0 @@
-"use strict";
-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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IrysStakeIntent = exports.IrysCommitmentParams = void 0;
-const t = __importStar(require("io-ts"));
-const stakeIntent_1 = require("./stakeIntent");
-exports.IrysCommitmentParams = t.type({
-    commitmentFee: t.string,
-    commitmentValue: t.string,
-    signerAddress: t.string,
-    chainId: t.number,
-});
-exports.IrysStakeIntent = t.intersection([
-    stakeIntent_1.StakeIntent,
-    t.type({
-        commitmentParams: exports.IrysCommitmentParams,
-    }),
-]);
-//# sourceMappingURL=irysStakeIntent.js.map

package/dist/src/schema/transactionRequest/intents/irysStakeIntent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"irysStakeIntent.js","sourceRoot":"","sources":["../../../../../src/schema/transactionRequest/intents/irysStakeIntent.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2B;AAC3B,+CAA4C;AAM/B,QAAA,oBAAoB,GAAG,CAAC,CAAC,IAAI,CAAC;IAEzC,aAAa,EAAE,CAAC,CAAC,MAAM;IAEvB,eAAe,EAAE,CAAC,CAAC,MAAM;IAEzB,aAAa,EAAE,CAAC,CAAC,MAAM;IAEvB,OAAO,EAAE,CAAC,CAAC,MAAM;CAClB,CAAC,CAAC;AAWU,QAAA,eAAe,GAAG,CAAC,CAAC,YAAY,CAAC;IAC5C,yBAAW;IACX,CAAC,CAAC,IAAI,CAAC;QACL,gBAAgB,EAAE,4BAAoB;KACvC,CAAC;CACH,CAAC,CAAC"}

package/src/schema/transactionRequest/intents/irysPledgeIntent.ts

@@ -1,38 +0,0 @@
-import * as t from "io-ts";
-import { BaseStakeIntent } from "./baseStakeIntent";
-import { intentTypes } from "./intentType";
-import { IrysCommitmentParams } from "./irysStakeIntent";
-
-/**
- * Extended commitment parameters for Irys PLEDGE transactions.
- * Includes pledgeCount (number of partitions to pledge).
- */
-export const IrysPledgeCommitmentParams = t.intersection([
-  IrysCommitmentParams,
-  t.type({
-    /** Number of partitions to pledge (each is 16TB). */
-    pledgeCount: t.number,
-  }),
-]);
-
-export type IrysPledgeCommitmentParams = t.TypeOf<
-  typeof IrysPledgeCommitmentParams
->;
-
-/**
- * @title Irys Pledge Intent
- *
- * Intent for Irys PLEDGE commitment transactions.
- * PLEDGE commits to store a 16TB partition (repeatable, each adds a partition).
- * Requires an active STAKE delegation first.
- * Routes to BGM_IRYS (mechanism 86) via irys/signtx keyserver path.
- */
-export const IrysPledgeIntent = t.intersection([
-  BaseStakeIntent,
-  t.type({
-    intentType: intentTypes.pledge,
-    commitmentParams: IrysPledgeCommitmentParams,
-  }),
-]);
-
-export type IrysPledgeIntent = t.TypeOf<typeof IrysPledgeIntent>;