Swap PDA flows in SubmitIntent and Sequencer

Author: jeffyanta

pkg/code/async/sequencer/fulfillment_handler.go

@@ -256,11 +256,17 @@ func (h *NoPrivacyTransferWithAuthorityFulfillmentHandler) CanSubmitToBlockchain
 	if err != nil {
 		return false, err
 	}
-	hasCreateOnSendFee, err := h.data.HasFeeAction(ctx, fulfillmentRecord.Intent, transactionpb.FeePaymentAction_CREATE_ON_SEND_WITHDRAWAL)
+	isCreateOnSend, err := h.data.HasFeeAction(ctx, fulfillmentRecord.Intent, transactionpb.FeePaymentAction_CREATE_ON_SEND_WITHDRAWAL)
 	if err != nil {
 		return false, err
 	}
-	if isInternalTransfer || !hasCreateOnSendFee {
+	if !isInternalTransfer && !isCreateOnSend {
+		isCreateOnSend, err = isExternalWithdrawToVmSwapPda(ctx, h.data, fulfillmentRecord.Intent, destinationAccount)
+		if err != nil {
+			return false, err
+		}
+	}
+	if isInternalTransfer || !isCreateOnSend {
 		isDestinationAccountCreated, err := isAccountInitialized(ctx, h.data, *fulfillmentRecord.Destination)
 		if err != nil {
 			return false, err
@@ -410,16 +416,25 @@ func (h *NoPrivacyTransferWithAuthorityFulfillmentHandler) MakeOnDemandTransacti
 			*actionRecord.Quantity,
 		)
 	} else {
+		// The Fee payment can be an external transfer, but we know the account
+		// already exists and doesn't need an idempotent create instruction
 		isFeePayment := actionRecord.FeeType != nil
 
+		// Create-on-send is enabled if there was a fee, or it is to an approved
+		// destination for subsidization.
 		var isCreateOnSend bool
-		// The Fee payment can be an external transfer, but we know the account
-		// already exists and doesn't need an idempotent create instruction
 		if !isFeePayment {
 			isCreateOnSend, err = h.data.HasFeeAction(ctx, fulfillmentRecord.Intent, transactionpb.FeePaymentAction_CREATE_ON_SEND_WITHDRAWAL)
 			if err != nil {
 				return nil, nil, err
 			}
+
+			if !isCreateOnSend {
+				isCreateOnSend, err = isExternalWithdrawToVmSwapPda(ctx, h.data, fulfillmentRecord.Intent, destinationToken)
+				if err != nil {
+					return nil, nil, err
+				}
+			}
 		}
 
 		var destinationOwner *common.Account

pkg/code/async/sequencer/vm.go

@@ -1,6 +1,7 @@
 package async_sequencer
 
 import (
+	"bytes"
 	"context"
 	"sync"
 
@@ -12,6 +13,7 @@ import (
 	code_data "github.com/code-payments/code-server/pkg/code/data"
 	"github.com/code-payments/code-server/pkg/code/data/cvm/ram"
 	"github.com/code-payments/code-server/pkg/code/data/cvm/storage"
+	"github.com/code-payments/code-server/pkg/code/data/intent"
 	"github.com/code-payments/code-server/pkg/code/data/timelock"
 	"github.com/code-payments/code-server/pkg/solana/cvm"
 )
@@ -152,3 +154,43 @@ func isInternalVmTransfer(ctx context.Context, data code_data.Provider, destinat
 		return false, err
 	}
 }
+
+func isExternalWithdrawToVmSwapPda(ctx context.Context, data code_data.Provider, intentId string, destinationAta *common.Account) (bool, error) {
+	intentRecord, err := data.GetIntent(ctx, intentId)
+	if err != nil {
+		return false, err
+	}
+
+	if intentRecord.IntentType != intent.SendPublicPayment {
+		return false, nil
+	}
+
+	if !intentRecord.SendPublicPaymentMetadata.IsWithdrawal {
+		return false, nil
+	}
+
+	owner, err := common.NewAccountFromPublicKeyString(intentRecord.InitiatorOwnerAccount)
+	if err != nil {
+		return false, err
+	}
+
+	mint, err := common.NewAccountFromPublicKeyString(intentRecord.MintAccount)
+	if err != nil {
+		return false, err
+	}
+
+	vmConfig, err := common.GetVmConfigForMint(ctx, data, mint)
+	if err != nil {
+		return false, err
+	}
+
+	vmSwapAccounts, err := owner.GetVmSwapAccounts(vmConfig)
+	if err != nil {
+		return false, err
+	}
+
+	if !bytes.Equal(destinationAta.PublicKey().ToBytes(), vmSwapAccounts.Ata.PublicKey().ToBytes()) {
+		return false, nil
+	}
+	return vmSwapAccounts.Pda.PublicKey().ToBase58() == intentRecord.SendPublicPaymentMetadata.DestinationOwnerAccount, nil
+}

pkg/code/server/transaction/intent_handler.go

@@ -21,6 +21,7 @@ import (
 	"github.com/code-payments/code-server/pkg/code/data/account"
 	"github.com/code-payments/code-server/pkg/code/data/action"
 	"github.com/code-payments/code-server/pkg/code/data/intent"
+	"github.com/code-payments/code-server/pkg/code/data/timelock"
 	currency_lib "github.com/code-payments/code-server/pkg/currency"
 	"github.com/code-payments/code-server/pkg/solana"
 )
@@ -725,7 +726,7 @@ func (h *SendPublicPaymentIntentHandler) validateActions(
 			}
 
 			// Check whether the destination account is a token account of the same mint that's
-			// been created on the blockchain. If not, a fee is required
+			// been created on the blockchain. If not, a fee is likely required
 			err = validateExternalTokenAccountWithinIntent(ctx, h.data, destination, intentMint)
 			switch err {
 			case nil:
@@ -734,13 +735,42 @@ func (h *SendPublicPaymentIntentHandler) validateActions(
 					return err
 				}
 
-				if !simResult.HasAnyFeePayments() {
-					return NewIntentValidationErrorf("%s fee payment is required", transactionpb.FeePaymentAction_CREATE_ON_SEND_WITHDRAWAL.String())
-				}
-
 				if metadata.DestinationOwner == nil {
 					return NewIntentValidationError("destination owner account is required to derive ata")
 				}
+
+				destinationOwner, err := common.NewAccountFromProto(metadata.DestinationOwner)
+				if err != nil {
+					return err
+				}
+
+				var isVmSwapPda bool
+				vmSwapPdaTimelockRecord, err := h.data.GetTimelockBySwapPda(ctx, destinationOwner.PublicKey().ToBase58())
+				if err == nil {
+					isVmSwapPda = true
+				} else if err != timelock.ErrTimelockNotFound {
+					return err
+				}
+
+				if isVmSwapPda {
+					accountInfoRecord, err := h.data.GetAccountInfoByTokenAddress(ctx, vmSwapPdaTimelockRecord.VaultAddress)
+					if err != nil {
+						return err
+					}
+
+					if accountInfoRecord.OwnerAccount != initiatorOwnerAccount.PublicKey().ToBase58() {
+						return NewIntentDeniedError("can only send to your own vm swap pda")
+					}
+
+					if accountInfoRecord.MintAccount != intentMint.PublicKey().ToBase58() {
+						return NewIntentValidationError("vm swap pda is for a different mint")
+					}
+				}
+
+				// Only VM swap PDAs are subsidized by server
+				if !simResult.HasAnyFeePayments() && !isVmSwapPda {
+					return NewIntentValidationErrorf("%s fee payment is required", transactionpb.FeePaymentAction_CREATE_ON_SEND_WITHDRAWAL.String())
+				}
 			}
 
 			return nil