JUP-setup jupiter program to swap solana tokens and added functionali…

docs/README.md

@@ -98,10 +98,10 @@ int lamports = 3000;
 
 Account signer = new Account(secret_key);
 
-Transaction transaction = new Transaction();
-transaction.addInstruction(SystemProgram.transfer(fromPublicKey, toPublickKey, lamports));
+Transaction legacyTransaction = new Transaction();
+legacyTransaction.addInstruction(SystemProgram.transfer(fromPublicKey, toPublickKey, lamports));
 
-String signature = client.getApi().sendTransaction(transaction, signer);
+String signature = client.getApi().sendTransaction(legacyTransaction, signer);
 ```
 
 ### Get Balance
@@ -125,19 +125,19 @@ final Market solUsdcMarket = new MarketBuilder()
 final OrderBook bids = solUsdcMarket.getBidOrderBook();
 ```
 
-### Send a Transaction with Memo Program
+##### Send a legacyTransaction with call to the "Memo" program
 
 ```java
 // Create account from private key
 final Account feePayer = new Account(Base58.decode(new String(data)));
-final Transaction transaction = new Transaction();
+final Transaction legacyTransaction = new Transaction();
 
 // Add instruction to write memo
-transaction.addInstruction(
+legacyTransaction.addInstruction(
         MemoProgram.writeUtf8(feePayer.getPublicKey(),"Hello from SolanaJ :)")
 );
 
-String response = client.getApi().sendTransaction(transaction, feePayer);
+String response = client.getApi().sendTransaction(legacyTransaction, feePayer);
 ```
 
 ## 🤝 Contributing

pom.xml

@@ -125,6 +125,19 @@
             <version>5.14.2</version>
             <scope>test</scope>
         </dependency>
+
+        <dependency>
+            <groupId>org.apache.httpcomponents.client5</groupId>
+            <artifactId>httpclient5</artifactId>
+            <version>5.2.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.15.0</version>
+        </dependency>
+
         <dependency>
             <groupId>com.syntifi.near</groupId>
             <artifactId>borshj</artifactId>

src/main/java/org/p2p/solanaj/core/AccountKeysList.java

@@ -32,6 +32,13 @@ public ArrayList<AccountMeta> getList() {
         return accountKeysList;
     }
 
+    @Override
+    public String toString() {
+        return "AccountKeysList{" +
+                "accounts=" + accounts +
+                '}';
+    }
+
     private static final Comparator<AccountMeta> metaComparator = Comparator
         .comparing(AccountMeta::isSigner)
         .thenComparing(AccountMeta::isWritable).reversed();

src/main/java/org/p2p/solanaj/core/AccountMeta.java

@@ -13,4 +13,23 @@ public class AccountMeta {
 
     private boolean isWritable;
 
-}
+    /**
+     * Sorting based on isSigner and isWritable cannot fully meet the requirements. This value can be used for custom sorting, because if the order is incorrect during serialization, it may lead to failed method calls.
+     */
+    private int sort = Integer.MAX_VALUE;
+
+    public AccountMeta(PublicKey publicKey, boolean isSigner, boolean isWritable) {
+        this.publicKey = publicKey;
+        this.isSigner = isSigner;
+        this.isWritable = isWritable;
+    }
+
+    @Override
+    public String toString() {
+        return "AccountMeta{" +
+                "publicKey=" + publicKey +
+                ", isSigner=" + isSigner +
+                ", isWritable=" + isWritable +
+                '}';
+    }
+}

src/main/java/org/p2p/solanaj/core/LegacyMessage.java

@@ -0,0 +1,181 @@
+package org.p2p.solanaj.core;
+
+import org.bitcoinj.core.Base58;
+import org.p2p.solanaj.utils.ShortvecEncoding;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class LegacyMessage {
+    private static class MessageHeader {
+        static final int HEADER_LENGTH = 3;
+
+        byte numRequiredSignatures = 0;
+        byte numReadonlySignedAccounts = 0;
+        byte numReadonlyUnsignedAccounts = 0;
+
+        byte[] toByteArray() {
+            return new byte[] { numRequiredSignatures, numReadonlySignedAccounts, numReadonlyUnsignedAccounts };
+        }
+    }
+
+    private static class CompiledInstruction {
+        byte programIdIndex;
+        byte[] keyIndicesCount;
+        byte[] keyIndices;
+        byte[] dataLength;
+        byte[] data;
+
+        int getLength() {
+            // 1 = programIdIndex length
+            return 1 + keyIndicesCount.length + keyIndices.length + dataLength.length + data.length;
+        }
+    }
+
+    private static final int RECENT_BLOCK_HASH_LENGTH = 32;
+
+    private MessageHeader messageHeader;
+    private String recentBlockhash;
+    private final AccountKeysList accountKeys;
+    private final List<TransactionInstruction> instructions;
+    private Account feePayer;
+
+    public LegacyMessage() {
+        this.accountKeys = new AccountKeysList();
+        this.instructions = new ArrayList<>();
+    }
+
+    public LegacyMessage addInstruction(TransactionInstruction instruction) {
+        accountKeys.addAll(instruction.getKeys());
+        accountKeys.add(new AccountMeta(instruction.getProgramId(), false, false));
+        instructions.add(instruction);
+
+        return this;
+    }
+
+    public void setRecentBlockHash(String recentBlockhash) {
+        this.recentBlockhash = recentBlockhash;
+    }
+
+    public byte[] serialize() {
+
+        if (recentBlockhash == null) {
+            throw new IllegalArgumentException("recentBlockhash required");
+        }
+
+        if (instructions.isEmpty()) {
+            throw new IllegalArgumentException("No instructions provided");
+        }
+
+        messageHeader = new MessageHeader();
+
+        List<AccountMeta> keysList = getAccountKeys();
+        int accountKeysSize = keysList.size();
+
+        byte[] accountAddressesLength = ShortvecEncoding.encodeLength(accountKeysSize);
+
+        int compiledInstructionsLength = 0;
+        List<CompiledInstruction> compiledInstructions = new ArrayList<>();
+
+        for (TransactionInstruction instruction : instructions) {
+            int keysSize = instruction.getKeys().size();
+
+            byte[] keyIndices = new byte[keysSize];
+            for (int i = 0; i < keysSize; i++) {
+                keyIndices[i] = (byte) findAccountIndex(keysList, instruction.getKeys().get(i).getPublicKey());
+            }
+
+            CompiledInstruction compiledInstruction = new CompiledInstruction();
+            compiledInstruction.programIdIndex = (byte) findAccountIndex(keysList, instruction.getProgramId());
+            compiledInstruction.keyIndicesCount = ShortvecEncoding.encodeLength(keysSize);
+            compiledInstruction.keyIndices = keyIndices;
+            compiledInstruction.dataLength = ShortvecEncoding.encodeLength(instruction.getData().length);
+            compiledInstruction.data = instruction.getData();
+
+            compiledInstructions.add(compiledInstruction);
+
+            compiledInstructionsLength += compiledInstruction.getLength();
+        }
+
+        byte[] instructionsLength = ShortvecEncoding.encodeLength(compiledInstructions.size());
+
+        int bufferSize = MessageHeader.HEADER_LENGTH + RECENT_BLOCK_HASH_LENGTH + accountAddressesLength.length
+                + (accountKeysSize * PublicKey.PUBLIC_KEY_LENGTH) + instructionsLength.length
+                + compiledInstructionsLength;
+
+        ByteBuffer out = ByteBuffer.allocate(bufferSize);
+
+        ByteBuffer accountKeysBuff = ByteBuffer.allocate(accountKeysSize * PublicKey.PUBLIC_KEY_LENGTH);
+        for (AccountMeta accountMeta : keysList) {
+            accountKeysBuff.put(accountMeta.getPublicKey().toByteArray());
+
+            if (accountMeta.isSigner()) {
+                messageHeader.numRequiredSignatures += 1;
+                if (!accountMeta.isWritable()) {
+                    messageHeader.numReadonlySignedAccounts += 1;
+                }
+            } else {
+                if (!accountMeta.isWritable()) {
+                    messageHeader.numReadonlyUnsignedAccounts += 1;
+                }
+            }
+        }
+
+        out.put(messageHeader.toByteArray());
+
+        out.put(accountAddressesLength);
+        out.put(accountKeysBuff.array());
+
+        out.put(Base58.decode(recentBlockhash));
+
+        out.put(instructionsLength);
+        for (CompiledInstruction compiledInstruction : compiledInstructions) {
+            out.put(compiledInstruction.programIdIndex);
+            out.put(compiledInstruction.keyIndicesCount);
+            out.put(compiledInstruction.keyIndices);
+            out.put(compiledInstruction.dataLength);
+            out.put(compiledInstruction.data);
+        }
+
+        return out.array();
+    }
+
+    protected void setFeePayer(Account feePayer) {
+        this.feePayer = feePayer;
+    }
+
+    private List<AccountMeta> getAccountKeys() {
+        List<AccountMeta> keysList = accountKeys.getList();
+
+        // Check whether custom sorting is needed. The `getAccountKeys()` method returns a reversed list of accounts, with signable and mutable accounts at the end, but the fee is placed first. When a transaction involves multiple accounts that need signing, an incorrect order can cause bugs. Change to custom sorting based on the contract order.
+        boolean needSort = keysList.stream().anyMatch(accountMeta -> accountMeta.getSort() < Integer.MAX_VALUE);
+        if (needSort) {
+            // Sort in ascending order based on the `sort` field.
+            return keysList.stream()
+                    .sorted(Comparator.comparingInt(AccountMeta::getSort))
+                    .collect(Collectors.toList());
+        }
+
+        int feePayerIndex = findAccountIndex(keysList, feePayer.getPublicKey());
+        List<AccountMeta> newList = new ArrayList<AccountMeta>();
+        AccountMeta feePayerMeta = keysList.get(feePayerIndex);
+        newList.add(new AccountMeta(feePayerMeta.getPublicKey(), true, true));
+        keysList.remove(feePayerIndex);
+        newList.addAll(keysList);
+
+        return newList;
+    }
+
+    private int findAccountIndex(List<AccountMeta> accountMetaList, PublicKey key) {
+        for (int i = 0; i < accountMetaList.size(); i++) {
+            if (accountMetaList.get(i).getPublicKey().equals(key)) {
+                return i;
+            }
+        }
+
+        throw new RuntimeException("unable to find account index");
+    }
+}

src/main/java/org/p2p/solanaj/core/LegacyTransaction.java

@@ -0,0 +1,114 @@
+package org.p2p.solanaj.core;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+import org.bitcoinj.core.Base58;
+import org.p2p.solanaj.utils.ShortvecEncoding;
+import org.p2p.solanaj.utils.TweetNaclFast;
+
+public class LegacyTransaction {
+
+    public static final int SIGNATURE_LENGTH = 64;
+
+    private final LegacyMessage legacyMessage;
+    private final List<String> signatures;
+    private byte[] serializedLegacyMessage;
+
+    /**
+     * Constructs a new Legacy Transaction instance.
+     */
+    public LegacyTransaction() {
+        this.legacyMessage = new LegacyMessage();
+        this.signatures = new ArrayList<>(); // Use diamond operator
+    }
+
+    /**
+     * Adds an instruction to the legacy transaction.
+     *
+     * @param instruction The instruction to add
+     * @return This Transaction instance for method chaining
+     * @throws NullPointerException if the instruction is null
+     */
+    public LegacyTransaction addInstruction(TransactionInstruction instruction) {
+        Objects.requireNonNull(instruction, "Instruction cannot be null"); // Add input validation
+        legacyMessage.addInstruction(instruction);
+        return this;
+    }
+
+    /**
+     * Sets the recent blockhash for the legacy transaction.
+     *
+     * @param recentBlockhash The recent blockhash to set
+     * @throws NullPointerException if the recentBlockhash is null
+     */
+    public void setRecentBlockHash(String recentBlockhash) {
+        Objects.requireNonNull(recentBlockhash, "Recent blockhash cannot be null"); // Add input validation
+        legacyMessage.setRecentBlockHash(recentBlockhash);
+    }
+
+    /**
+     * Signs the legacy transaction with a single signer.
+     *
+     * @param signer The account to sign the transaction
+     * @throws NullPointerException if the signer is null
+     */
+    public void sign(Account signer) {
+        sign(List.of(Objects.requireNonNull(signer, "Signer cannot be null"))); // Add input validation
+    }
+
+    /**
+     * Signs the legacy transaction with multiple signers.
+     *
+     * @param signers The list of accounts to sign the transaction
+     * @throws IllegalArgumentException if no signers are provided
+     */
+    public void sign(List<Account> signers) {
+        if (signers == null || signers.isEmpty()) {
+            throw new IllegalArgumentException("No signers provided");
+        }
+
+        Account feePayer = signers.get(0);
+        legacyMessage.setFeePayer(feePayer);
+
+        serializedLegacyMessage = legacyMessage.serialize();
+
+        for (Account signer : signers) {
+            try {
+                TweetNaclFast.Signature signatureProvider = new TweetNaclFast.Signature(new byte[0], signer.getSecretKey());
+                byte[] signature = signatureProvider.detached(serializedLegacyMessage);
+                signatures.add(Base58.encode(signature));
+            } catch (Exception e) {
+                throw new RuntimeException("Error signing transaction", e); // Improve exception handling
+            }
+        }
+    }
+
+    /**
+     * Serializes the legacy transaction into a byte array.
+     *
+     * @return The serialized transaction as a byte array
+     */
+    public byte[] serialize() {
+        int signaturesSize = signatures.size();
+        byte[] signaturesLength = ShortvecEncoding.encodeLength(signaturesSize);
+
+        // Calculate total size before allocating ByteBuffer
+        int totalSize = signaturesLength.length + signaturesSize * SIGNATURE_LENGTH + serializedLegacyMessage.length;
+        ByteBuffer out = ByteBuffer.allocate(totalSize);
+
+        out.put(signaturesLength);
+
+        for (String signature : signatures) {
+            byte[] rawSignature = Base58.decode(signature);
+            out.put(rawSignature);
+        }
+
+        out.put(serializedLegacyMessage);
+
+        return out.array();
+    }
+}