Add support for versioned transactions

Author: jeffyanta

pkg/code/async/geyser/external_deposit.go

@@ -117,7 +117,7 @@ func initiateExternalDepositIntoVm(ctx context.Context, data code_data.Provider,
 		return errors.Wrap(err, "error getting vta location in memory")
 	}
 
-	txn := solana.NewTransaction(
+	txn := solana.NewLegacyTransaction(
 		vmConfig.Authority.PublicKey().ToBytes(),
 		memo.Instruction(codeVmDepositMemoValue),
 		compute_budget.SetComputeUnitPrice(1_000),

pkg/code/async/nonce/util.go

@@ -169,7 +169,7 @@ func (p *service) createNonceAccountTx(ctx context.Context, nonce *nonce.Record)
 		),
 	}
 
-	tx := solana.NewTransaction(subPub, instructions...)
+	tx := solana.NewLegacyTransaction(subPub, instructions...)
 
 	bh, err := p.getLatestBlockhash(ctx)
 	if err != nil {

pkg/code/async/sequencer/testutil.go

@@ -47,7 +47,7 @@ func (h *mockFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fu
 		return nil, nil, errors.New("not supported")
 	}
 
-	txn := solana.NewTransaction(common.GetSubsidizer().PublicKey().ToBytes(), memo.Instruction(selectedNonce.Account.PublicKey().ToBase58()))
+	txn := solana.NewLegacyTransaction(common.GetSubsidizer().PublicKey().ToBytes(), memo.Instruction(selectedNonce.Account.PublicKey().ToBase58()))
 	return &txn, nil, nil
 }
 

pkg/code/async/sequencer/worker_test.go

@@ -271,7 +271,7 @@ func (e *workerTestEnv) createAnyFulfillmentInState(t *testing.T, state fulfillm
 	fakeCodeAccouht := testutil.NewRandomAccount(t)
 	fakeNonceAccount := testutil.NewRandomAccount(t)
 
-	txn := solana.NewTransaction(
+	txn := solana.NewLegacyTransaction(
 		fakeCodeAccouht.PublicKey().ToBytes(),
 		system.AdvanceNonce(fakeNonceAccount.PublicKey().ToBytes(), fakeCodeAccouht.PublicKey().ToBytes()),
 	)
@@ -361,7 +361,7 @@ func (e *workerTestEnv) assertFulfillmentCreatedOnDemand(t *testing.T, id uint64
 	require.NotNil(t, fulfillmentRecord.Blockhash)
 	require.NotEmpty(t, fulfillmentRecord.Data)
 
-	expectedTxn := solana.NewTransaction(common.GetSubsidizer().PublicKey().ToBytes(), memo.Instruction(nonceAddress))
+	expectedTxn := solana.NewLegacyTransaction(common.GetSubsidizer().PublicKey().ToBytes(), memo.Instruction(nonceAddress))
 	expectedTxn.Sign(e.subsidizer.PrivateKey().ToBytes())
 	expectedSignature := base58.Encode(expectedTxn.Signature())
 

pkg/code/data/blockchain.go

@@ -19,7 +19,6 @@ const (
 
 type BlockchainData interface {
 	SubmitBlockchainTransaction(ctx context.Context, tx *solana.Transaction) (solana.Signature, error)
-	RequestBlockchainAirdrop(ctx context.Context, account string, amount uint64) (solana.Signature, error)
 
 	GetBlockchainAccountInfo(ctx context.Context, account string, commitment solana.Commitment) (*solana.AccountInfo, error)
 	GetBlockchainAccountDataAfterBlock(ctx context.Context, account string, slot uint64) ([]byte, uint64, error)
@@ -70,23 +69,6 @@ func (dp *BlockchainProvider) SubmitBlockchainTransaction(ctx context.Context, t
 	return res, err
 }
 
-func (dp *BlockchainProvider) RequestBlockchainAirdrop(ctx context.Context, account string, amount uint64) (solana.Signature, error) {
-	tracer := metrics.TraceMethodCall(ctx, blockchainProviderMetricsName, "RequestBlockchainAirdrop")
-	defer tracer.End()
-
-	pubkey, err := base58.Decode(account)
-	if err != nil {
-		return solana.Signature{}, err
-	}
-
-	res, err := dp.sc.RequestAirdrop(pubkey, amount, solana.CommitmentProcessed)
-	if err != nil {
-		tracer.OnError(err)
-	}
-
-	return res, err
-}
-
 func (dp *BlockchainProvider) GetBlockchainAccountInfo(ctx context.Context, account string, commitment solana.Commitment) (*solana.AccountInfo, error) {
 	tracer := metrics.TraceMethodCall(ctx, blockchainProviderMetricsName, "GetBlockchainAccountInfo")
 	defer tracer.End()

pkg/code/transaction/transaction.go

@@ -33,9 +33,8 @@ func MakeNoncedTransaction(nonce *Nonce, instructions ...solana.Instruction) (so
 
 	instructions = append([]solana.Instruction{advanceNonceInstruction}, instructions...)
 
-	txn := solana.NewTransaction(payer.PublicKey().ToBytes(), instructions...)
+	txn := solana.NewLegacyTransaction(payer.PublicKey().ToBytes(), instructions...)
 	txn.SetBlockhash(nonce.Blockhash)
-
 	return txn, nil
 }
 

pkg/solana/address_lookup_table.go

@@ -10,13 +10,13 @@ func PutKey32(dst []byte, src []byte, offset *int) {
 	*offset += ed25519.PublicKeySize
 }
 
-func PutOptionalKey32(dst []byte, src []byte, offset *int) {
+func PutOptionalKey32(dst []byte, src []byte, offset *int, optionSize int) {
 	if len(src) > 0 {
 		dst[0] = 1
-		copy(dst[4:], src)
+		copy(dst[optionSize:], src)
 	}
 
-	*offset += 4 + ed25519.PublicKeySize
+	*offset += optionSize + ed25519.PublicKeySize
 }
 
 func PutUint64(dst []byte, v uint64, offset *int) {
@@ -34,12 +34,12 @@ func PutUint8(dst []byte, v uint8, offset *int) {
 	*offset += 1
 }
 
-func PutOptionalUint64(dst []byte, v *uint64, offset *int) {
+func PutOptionalUint64(dst []byte, v *uint64, offset *int, optionSize int) {
 	if v != nil {
 		dst[0] = 1
-		binary.LittleEndian.PutUint64(dst[4:], *v)
+		binary.LittleEndian.PutUint64(dst[optionSize:], *v)
 	}
-	*offset += 4 + 8
+	*offset += optionSize + 8
 }
 
 func GetKey32(src []byte, dst *ed25519.PublicKey, offset *int) {
@@ -71,10 +71,10 @@ func GetUint8(src []byte, dst *uint8, offset *int) {
 	*offset += 1
 }
 
-func GetOptionalUint64(src []byte, dst **uint64, offset *int) {
+func GetOptionalUint64(src []byte, dst **uint64, offset *int, optionSize int) {
 	if src[0] == 1 {
-		val := binary.LittleEndian.Uint64(src[4:])
+		val := binary.LittleEndian.Uint64(src[optionSize:])
 		*dst = &val
 	}
-	*offset += 4 + 8
+	*offset += optionSize + 8
 }

pkg/solana/binary/utils.go

@@ -178,9 +178,9 @@ type Client interface {
 	GetConfirmationStatus(Signature, Commitment) (bool, error)
 	GetConfirmedBlock(slot uint64) (*Block, error)
 	GetConfirmedBlocksWithLimit(start, limit uint64) ([]uint64, error)
-	GetConfirmedTransaction(Signature) (ConfirmedTransaction, error)
-	GetMinimumBalanceForRentExemption(size uint64) (lamports uint64, err error)
+	GetFilteredProgramAccounts(program ed25519.PublicKey, offset uint, filterValue []byte) ([]string, uint64, error)
 	GetLatestBlockhash() (Blockhash, error)
+	GetMinimumBalanceForRentExemption(size uint64) (lamports uint64, err error)
 	GetSignatureStatus(Signature, Commitment) (*SignatureStatus, error)
 	GetSignatureStatuses([]Signature) ([]*SignatureStatus, error)
 	GetSignaturesForAddress(owner ed25519.PublicKey, commitment Commitment, limit uint64, before, until string) ([]*TransactionSignature, error)
@@ -189,8 +189,6 @@ type Client interface {
 	GetTokenAccountsByOwner(owner, mint ed25519.PublicKey) ([]ed25519.PublicKey, error)
 	GetTransaction(Signature, Commitment) (ConfirmedTransaction, error)
 	GetTransactionTokenBalances(Signature) (TransactionTokenBalances, error)
-	GetFilteredProgramAccounts(program ed25519.PublicKey, offset uint, filterValue []byte) ([]string, uint64, error)
-	RequestAirdrop(ed25519.PublicKey, uint64, Commitment) (Signature, error)
 	SubmitTransaction(Transaction, Commitment) (Signature, error)
 }
 
@@ -528,47 +526,6 @@ func (c *client) GetConfirmedBlocksWithLimit(start, limit uint64) (slots []uint6
 	return slots, c.call(&slots, "getConfirmedBlocksWithLimit", start, limit)
 }
 
-func (c *client) GetConfirmedTransaction(sig Signature) (ConfirmedTransaction, error) {
-	type rpcResponse struct {
-		Slot        uint64   `json:"slot"`
-		Transaction []string `json:"transaction"` // [val, encoding]
-		Meta        *struct {
-			Err interface{} `json:"err"`
-		} `json:"meta"`
-	}
-
-	var resp *rpcResponse
-	if err := c.call(&resp, "getConfirmedTransaction", base58.Encode(sig[:]), "base64"); err != nil {
-		return ConfirmedTransaction{}, err
-	}
-
-	if resp == nil {
-		return ConfirmedTransaction{}, ErrSignatureNotFound
-	}
-
-	txn := ConfirmedTransaction{
-		Slot: resp.Slot,
-	}
-
-	var err error
-	rawTxn, err := base64.StdEncoding.DecodeString(resp.Transaction[0])
-	if err != nil {
-		return txn, errors.Wrap(err, "failed to decode transaction")
-	}
-	if err := txn.Transaction.Unmarshal(rawTxn); err != nil {
-		return txn, errors.Wrap(err, "failed to unmarshal transaction")
-	}
-
-	if resp.Meta != nil {
-		txn.Err, err = ParseTransactionError(resp.Meta.Err)
-		if err != nil {
-			return txn, errors.Wrap(err, "failed to parse transaction result")
-		}
-	}
-
-	return txn, nil
-}
-
 func (c *client) GetTransaction(sig Signature, commitment Commitment) (ConfirmedTransaction, error) {
 	type rpcResponse struct {
 		Slot        uint64           `json:"slot"`
@@ -578,11 +535,13 @@ func (c *client) GetTransaction(sig Signature, commitment Commitment) (Confirmed
 	}
 
 	config := struct {
-		Commitment string `json:"commitment"`
-		Encoding   string `json:"encoding"`
+		Commitment                     string `json:"commitment"`
+		Encoding                       string `json:"encoding"`
+		MaxSupportedTransactionVersion int    `json:"maxSupportedTransactionVersion"`
 	}{
-		Commitment: commitment.Commitment,
-		Encoding:   "base64",
+		Commitment:                     commitment.Commitment,
+		Encoding:                       "base64",
+		MaxSupportedTransactionVersion: 0,
 	}
 
 	var resp *rpcResponse
@@ -935,27 +894,6 @@ func (c *client) GetAccountDataAfterBlock(account ed25519.PublicKey, slot uint64
 	return rawData, unmarshalledGetAccountInfoResp.Context.Slot, nil
 }
 
-func (c *client) RequestAirdrop(account ed25519.PublicKey, lamports uint64, commitment Commitment) (Signature, error) {
-	var sigStr string
-	if err := c.call(&sigStr, "requestAirdrop", base58.Encode(account[:]), lamports, commitment); err != nil {
-		return Signature{}, errors.Wrapf(err, "requestAirdrop() failed to send request")
-	}
-
-	sigBytes, err := base58.Decode(sigStr)
-	if err != nil {
-		return Signature{}, errors.Wrap(err, "invalid signature in response")
-	}
-
-	var sig Signature
-	copy(sig[:], sigBytes)
-
-	if sig == (Signature{}) {
-		return Signature{}, errors.New("empty signature returned")
-	}
-
-	return sig, nil
-}
-
 func (c *client) GetConfirmationStatus(sig Signature, commitment Commitment) (bool, error) {
 	type response struct {
 		Value bool `json:"value"`