Add TransactionProposalCreate for Cosign

include/xrpl/protocol/detail/transactions.macro

@@ -1194,6 +1194,20 @@ TRANSACTION(ttSPONSORSHIP_SET, 91, SponsorshipSet,
     {sfRemainingOwnerCount, SoeOptional},
 }))
 
+/** This transaction posts an unsigned transaction on-ledger as a
+    TransactionProposal, pending multi-signature collection. */
+#if TRANSACTION_INCLUDE
+#   include <xrpl/tx/transactors/proposal/TransactionProposalCreate.h>
+#endif
+TRANSACTION(ttTRANSACTION_PROPOSAL_CREATE, 92, TransactionProposalCreate,
+    Delegation::NotDelegable,
+    featureCosign,
+    NoPriv,
+    ({
+    {sfProposedTransaction, SoeRequired},
+    {sfExpiration, SoeRequired},
+}))
+
 /** This system-generated transaction type is used to update the status of the various amendments.
 
     For details, see: https://xrpl.org/amendments.html

include/xrpl/protocol_autogen/transactions/TransactionProposalCreate.h

@@ -0,0 +1,155 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class TransactionProposalCreateBuilder;
+
+/**
+ * @brief Transaction: TransactionProposalCreate
+ *
+ * Type: ttTRANSACTION_PROPOSAL_CREATE (92)
+ * Delegable: Delegation::NotDelegable
+ * Amendment: featureCosign
+ * Privileges: NoPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use TransactionProposalCreateBuilder to construct new transactions.
+ */
+class TransactionProposalCreate : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttTRANSACTION_PROPOSAL_CREATE;
+
+    /**
+     * @brief Construct a TransactionProposalCreate transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit TransactionProposalCreate(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for TransactionProposalCreate");
+        }
+    }
+
+    // Transaction-specific field getters
+    /**
+     * @brief Get sfProposedTransaction (SoeRequired)
+     * @note This is an untyped field.
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STObject
+    getProposedTransaction() const
+    {
+        return this->tx_->getFieldObject(sfProposedTransaction);
+    }
+
+    /**
+     * @brief Get sfExpiration (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getExpiration() const
+    {
+        return this->tx_->at(sfExpiration);
+    }
+};
+
+/**
+ * @brief Builder for TransactionProposalCreate transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class TransactionProposalCreateBuilder : public TransactionBuilderBase<TransactionProposalCreateBuilder>
+{
+public:
+    /**
+     * @brief Construct a new TransactionProposalCreateBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param proposedTransaction The sfProposedTransaction field value.
+     * @param expiration The sfExpiration field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    TransactionProposalCreateBuilder(SF_ACCOUNT::type::value_type account,
+                     STObject const& proposedTransaction,                     std::decay_t<typename SF_UINT32::type::value_type> const& expiration,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<TransactionProposalCreateBuilder>(ttTRANSACTION_PROPOSAL_CREATE, account, sequence, fee)
+    {
+        setProposedTransaction(proposedTransaction);
+        setExpiration(expiration);
+    }
+
+    /**
+     * @brief Construct a TransactionProposalCreateBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    TransactionProposalCreateBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttTRANSACTION_PROPOSAL_CREATE)
+        {
+            throw std::runtime_error("Invalid transaction type for TransactionProposalCreateBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfProposedTransaction (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    TransactionProposalCreateBuilder&
+    setProposedTransaction(STObject const& value)
+    {
+        object_.setFieldObject(sfProposedTransaction, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfExpiration (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    TransactionProposalCreateBuilder&
+    setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfExpiration] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the TransactionProposalCreate wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    TransactionProposalCreate
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return TransactionProposalCreate{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/tx/transactors/proposal/ProposalHelpers.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STObject.h>
+#include <xrpl/protocol/TxFormats.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+/**
+ * Whether the proposed transaction carries any signature field.
+ *
+ * A proposal is stored in unsigned canonical form; signatures may only ever
+ * arrive through TransactionProposalSign. Shared by the create-time check and
+ * the invariant that guards the stored entry, so the two cannot drift apart.
+ */
+inline bool
+hasSignatureField(STObject const& proposedTx)
+{
+    return proposedTx.isFieldPresent(sfTxnSignature) || proposedTx.isFieldPresent(sfSigners) ||
+        proposedTx.isFieldPresent(sfBatchSigners) ||
+        proposedTx.isFieldPresent(sfCounterpartySignature) ||
+        proposedTx.isFieldPresent(sfSponsorSignature);
+}
+
+/**
+ * Whether the proposed transaction's SigningPubKey is present and empty, as
+ * unsigned canonical form requires. An absent field is not the same as an
+ * empty one, and a populated one means the payload was already signed.
+ */
+inline bool
+hasEmptySigningPubKey(STObject const& proposedTx)
+{
+    return proposedTx.isFieldPresent(sfSigningPubKey) &&
+        proposedTx.getFieldVL(sfSigningPubKey).empty();
+}
+
+/**
+ * Owner-reserve increments held by a proposal of an ordinary transaction.
+ */
+constexpr std::uint32_t kProposalOwnerCount = 5;
+
+/**
+ * Owner-reserve increments held by a proposal of a Batch transaction. A
+ * proposed Batch stores up to eight inner transactions plus multi-account
+ * signatures, so it reserves more than an ordinary proposed transaction.
+ */
+constexpr std::uint32_t kBatchProposalOwnerCount = 10;
+
+/**
+ * Owner-reserve increments held by a proposal of the given transaction.
+ */
+inline std::uint32_t
+proposalOwnerCount(STObject const& proposedTx)
+{
+    return proposedTx.getFieldU16(sfTransactionType) == ttBATCH ? kBatchProposalOwnerCount
+                                                                : kProposalOwnerCount;
+}
+
+}  // namespace xrpl

include/xrpl/tx/transactors/proposal/TransactionProposalCreate.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/tx/ApplyContext.h>
+#include <xrpl/tx/Transactor.h>
+
+#include <cstddef>
+#include <memory>
+
+namespace xrpl {
+
+class TransactionProposalCreate : public Transactor
+{
+public:
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Normal;
+
+    explicit TransactionProposalCreate(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::const_ref before, SLE::const_ref after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+
+private:
+    // Invariant state: the proposal entry this transaction created, and any
+    // proposal entries it touched in another way (there must be none).
+    std::shared_ptr<SLE const> createdProposal_;
+    std::size_t createdProposals_ = 0;
+    std::size_t otherProposalTouches_ = 0;
+};
+
+}  // namespace xrpl