Examples use-cases - get blocks

common/src/testFixtures/kotlin/org/onflow/flow/common/test/FlowTestUtil.kt

@@ -161,7 +161,6 @@ object FlowTestUtil {
         val fileLocation = flowJsonLocation?.let(::File)
         if (fileLocation != null && fileLocation.exists() && fileLocation.isFile) {
             flowJson = fileLocation.absolutePath
-            println("Flow JSON found as file: $flowJson")
         }
 
         // Check if flowJsonLocation is a classpath resource

java-example/src/main/java/org/onflow/examples/java/AccessAPIConnector.java

@@ -82,13 +82,14 @@ private FlowTransactionResult waitForSeal(FlowId txID) {
 
     private FlowAddress getAccountCreatedAddress(FlowTransactionResult txResult) {
         FlowEvent event = txResult.getEvents().stream()
-        .filter(it -> "flow.AccountCreated".equals(it.getType()))
+                .filter(it -> "flow.AccountCreated".equals(it.getType()))
                 .findFirst()
                 .orElseThrow(() -> new RuntimeException("account created event not found"));
 
         EventField field = (EventField) event.getPayload().getJsonCadence();
         String address = (String) field.getValue().getRequiredField("address").getValue();
 
+        assert address != null;
         return new FlowAddress(address);
     }
 
@@ -103,18 +104,10 @@ private byte[] loadScript(String name) {
         }
     }
 
-    public FlowAddress createAccount(FlowAddress payerAddress, PublicKey publicKey) {
-
-        FlowAccountKey payerAccountKey = getAccountKey(payerAddress, 0);
-
-        FlowScript script = new FlowScript(loadScript("cadence/create_account.cdc"));
-
-        FlowTransaction tx = new FlowTransaction(
+    private FlowTransaction createTransaction(FlowAddress payerAddress, FlowAccountKey payerAccountKey, FlowScript script, List<FlowArgument> arguments) {
+        return new FlowTransaction(
                 script,
-                List.of(
-                        new FlowArgument(new StringField(publicKey.getHex())),
-                        new FlowArgument(new UInt8NumberField(Integer.toString(publicKey.getAlgo().getIndex())))
-                ),
+                arguments,
                 getLatestBlockID(),
                 500L,
                 new FlowTransactionProposalKey(
@@ -127,50 +120,52 @@ public FlowAddress createAccount(FlowAddress payerAddress, PublicKey publicKey)
                 Collections.emptyList(),
                 Collections.emptyList()
         );
+    }
 
+    private FlowId signAndSendTransaction(FlowTransaction tx, FlowAddress payerAddress, FlowAccountKey payerAccountKey) {
         Signer signer = Crypto.getSigner(privateKey, payerAccountKey.getHashAlgo());
         tx = tx.addEnvelopeSignature(payerAddress, payerAccountKey.getId(), signer);
+        return sendTransaction(tx);
+    }
 
-        FlowId txID = sendTransaction(tx);
-
+    public FlowAddress createAccount(FlowAddress payerAddress, PublicKey publicKey) {
+        FlowAccountKey payerAccountKey = getAccountKey(payerAddress, 0);
+        FlowScript script = new FlowScript(loadScript("cadence/create_account.cdc"));
+        List<FlowArgument> arguments = List.of(
+                new FlowArgument(new StringField(publicKey.getHex())),
+                new FlowArgument(new UInt8NumberField(Integer.toString(publicKey.getAlgo().getIndex())))
+        );
+        FlowTransaction tx = createTransaction(payerAddress, payerAccountKey, script, arguments);
+        FlowId txID = signAndSendTransaction(tx, payerAddress, payerAccountKey);
         FlowTransactionResult txResult = waitForSeal(txID);
         return getAccountCreatedAddress(txResult);
     }
 
+    public FlowId sendSampleTransaction(FlowAddress payerAddress, PublicKey publicKey) {
+        FlowAccountKey payerAccountKey = getAccountKey(payerAddress, 0);
+        FlowScript script = new FlowScript(loadScript("cadence/create_account.cdc"));
+        List<FlowArgument> arguments = List.of(
+                new FlowArgument(new StringField(publicKey.getHex())),
+                new FlowArgument(new UInt8NumberField(Integer.toString(publicKey.getAlgo().getIndex())))
+        );
+        FlowTransaction tx = createTransaction(payerAddress, payerAccountKey, script, arguments);
+        return signAndSendTransaction(tx, payerAddress, payerAccountKey);
+    }
+
     public void transferTokens(FlowAddress senderAddress, FlowAddress recipientAddress, BigDecimal amount) {
         if (amount.scale() != 8) {
             throw new RuntimeException("FLOW amount must have exactly 8 decimal places of precision (e.g. 10.00000000)");
         }
 
         FlowAccountKey senderAccountKey = getAccountKey(senderAddress, 0);
-
         FlowScript script = new FlowScript(loadScript("cadence/transfer_flow.cdc"));
-
         List<FlowArgument> arguments = List.of(
                 new FlowArgument(new UFix64NumberField(amount.toPlainString())),
                 new FlowArgument(new AddressField(recipientAddress.getBase16Value()))
         );
 
-        FlowTransaction tx = new FlowTransaction(
-                script,
-                arguments,
-                getLatestBlockID(),
-                500L,
-                new FlowTransactionProposalKey(
-                        senderAddress,
-                        senderAccountKey.getId(),
-                        senderAccountKey.getSequenceNumber()
-                ),
-                senderAddress,
-                Collections.singletonList(senderAddress),
-                Collections.emptyList(),
-                Collections.emptyList()
-        );
-
-        Signer signer = Crypto.getSigner(privateKey, senderAccountKey.getHashAlgo());
-        tx = tx.addEnvelopeSignature(senderAddress, senderAccountKey.getId(), signer);
-
-        FlowId txID = sendTransaction(tx);
+        FlowTransaction tx = createTransaction(senderAddress, senderAccountKey, script, arguments);
+        FlowId txID = signAndSendTransaction(tx, senderAddress, senderAccountKey);
         waitForSeal(txID);
     }
 

java-example/src/main/java/org/onflow/examples/java/getAccount/GetAccountAccessAPIConnector.java

@@ -0,0 +1,38 @@
+package org.onflow.examples.java.getAccount;
+
+import org.onflow.flow.sdk.*;
+import java.math.BigDecimal;
+
+public class GetAccountAccessAPIConnector {
+
+    private final FlowAccessApi accessAPI;
+
+    public GetAccountAccessAPIConnector(FlowAccessApi accessAPI) {
+        this.accessAPI = accessAPI;
+    }
+
+    public FlowAccount getAccountAtLatestBlock(FlowAddress address) {
+        FlowAccessApi.AccessApiCallResponse<FlowAccount> response = accessAPI.getAccountAtLatestBlock(address);
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowAccount>) response).getData();
+        } else {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        }
+    }
+
+    public FlowAccount getAccountAtBlockHeight(FlowAddress address, long height) {
+        FlowAccessApi.AccessApiCallResponse<FlowAccount> response = accessAPI.getAccountByBlockHeight(address, height);
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowAccount>) response).getData();
+        } else {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        }
+    }
+
+    public BigDecimal getAccountBalance(FlowAddress address) {
+        FlowAccount account = getAccountAtLatestBlock(address);
+        return account.getBalance();
+    }
+}

java-example/src/main/java/org/onflow/examples/java/getBlock/GetBlockAccessAPIConnector.java

@@ -0,0 +1,46 @@
+package org.onflow.examples.java.getBlock;
+
+import org.onflow.flow.sdk.*;
+
+public class GetBlockAccessAPIConnector {
+
+    private final FlowAccessApi accessAPI;
+
+    public GetBlockAccessAPIConnector(FlowAccessApi accessAPI) {
+        this.accessAPI = accessAPI;
+    }
+
+    public FlowBlock getLatestSealedBlock() {
+        boolean isSealed = true;
+        FlowAccessApi.AccessApiCallResponse<FlowBlock> response = accessAPI.getLatestBlock(isSealed);
+
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowBlock>) response).getData();
+        } else {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        }
+    }
+
+    public FlowBlock getBlockByID(FlowId blockID) {
+        FlowAccessApi.AccessApiCallResponse<FlowBlock> response = accessAPI.getBlockById(blockID);
+
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowBlock>) response).getData();
+        } else {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        }
+    }
+
+    public FlowBlock getBlockByHeight(long height) {
+        FlowAccessApi.AccessApiCallResponse<FlowBlock> response = accessAPI.getBlockByHeight(height);
+
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowBlock>) response).getData();
+        } else {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        }
+    }
+}

java-example/src/main/java/org/onflow/examples/java/getEvent/GetEventAccessAPIConnector.java

@@ -0,0 +1,55 @@
+package org.onflow.examples.java.getEvent;
+
+import kotlin.ranges.LongRange;
+import org.onflow.flow.sdk.*;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class GetEventAccessAPIConnector {
+    private final FlowAccessApi accessAPI;
+
+    public GetEventAccessAPIConnector(FlowAccessApi accessAPI) {
+        this.accessAPI = accessAPI;
+    }
+
+    public List<FlowEventResult> getEventsForHeightRange(String eventType, long startHeight, long endHeight) {
+        LongRange range = new LongRange(startHeight, endHeight);
+        FlowAccessApi.AccessApiCallResponse<List<FlowEventResult>> response = accessAPI.getEventsForHeightRange(eventType, range);
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<List<FlowEventResult>>) response).getData();
+        } else if (response instanceof FlowAccessApi.AccessApiCallResponse.Error) {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        } else {
+            throw new RuntimeException("Unknown response type");
+        }
+    }
+
+    public List<FlowEventResult> getEventsForBlockIds(String eventType, List<FlowId> blockIds) {
+        Set<FlowId> blockIdSet = new HashSet<>(blockIds);
+        FlowAccessApi.AccessApiCallResponse<List<FlowEventResult>> response = accessAPI.getEventsForBlockIds(eventType, blockIdSet);
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<List<FlowEventResult>>) response).getData();
+        } else if (response instanceof FlowAccessApi.AccessApiCallResponse.Error errorResponse) {
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        } else {
+            throw new RuntimeException("Unknown response type");
+        }
+    }
+
+    public FlowTransactionResult getTransactionResult(FlowId txID) {
+        FlowAccessApi.AccessApiCallResponse<FlowTransactionResult> response = accessAPI.getTransactionResultById(txID);
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowTransactionResult>) response).getData();
+        } else if (response instanceof FlowAccessApi.AccessApiCallResponse.Error errorResponse) {
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        } else {
+            throw new RuntimeException("Unknown response type");
+        }
+    }
+
+    public List<FlowEventResult> getAccountCreatedEvents(long startHeight, long endHeight) {
+        return getEventsForHeightRange("flow.AccountCreated", startHeight, endHeight);
+    }
+}

java-example/src/main/java/org/onflow/examples/java/getNetworkParams/GetNetworkParametersAccessAPIConnector.java

@@ -0,0 +1,24 @@
+package org.onflow.examples.java.getNetworkParams;
+
+import org.onflow.flow.sdk.FlowAccessApi;
+import org.onflow.flow.sdk.FlowChainId;
+
+public class GetNetworkParametersAccessAPIConnector {
+
+    private final FlowAccessApi accessAPI;
+
+    public GetNetworkParametersAccessAPIConnector(FlowAccessApi accessAPI) {
+        this.accessAPI = accessAPI;
+    }
+
+    public FlowChainId getNetworkParameters() {
+        FlowAccessApi.AccessApiCallResponse<FlowChainId> response = accessAPI.getNetworkParameters();
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowChainId>) response).getData();
+        } else {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        }
+    }
+}
+

java-example/src/main/java/org/onflow/examples/java/getTransaction/GetTransactionAccessAPIConnector.java

@@ -0,0 +1,35 @@
+package org.onflow.examples.java.getTransaction;
+
+import org.onflow.flow.sdk.FlowAccessApi;
+import org.onflow.flow.sdk.FlowId;
+import org.onflow.flow.sdk.FlowTransaction;
+import org.onflow.flow.sdk.FlowTransactionResult;
+
+public class GetTransactionAccessAPIConnector {
+
+    private final FlowAccessApi accessAPI;
+
+    public GetTransactionAccessAPIConnector(FlowAccessApi accessAPI) {
+        this.accessAPI = accessAPI;
+    }
+
+    public FlowTransaction getTransaction(FlowId txID) {
+        FlowAccessApi.AccessApiCallResponse<FlowTransaction> response = accessAPI.getTransactionById(txID);
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowTransaction>) response).getData();
+        } else {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        }
+    }
+
+    public FlowTransactionResult getTransactionResult(FlowId txID) {
+        FlowAccessApi.AccessApiCallResponse<FlowTransactionResult> response = accessAPI.getTransactionResultById(txID);
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowTransactionResult>) response).getData();
+        } else {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        }
+    }
+}

java-example/src/test/java/org/onflow/examples/java/getAccount/GetAccountAccessAPIConnectorTest.java

@@ -0,0 +1,59 @@
+package org.onflow.examples.java.getAccount;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.onflow.flow.common.test.FlowEmulatorProjectTest;
+import org.onflow.flow.common.test.FlowServiceAccountCredentials;
+import org.onflow.flow.common.test.FlowTestClient;
+import org.onflow.flow.common.test.TestAccount;
+import org.onflow.flow.sdk.FlowAccessApi;
+import org.onflow.flow.sdk.FlowAccount;
+import org.onflow.flow.sdk.FlowAddress;
+
+import java.math.BigDecimal;
+
+@FlowEmulatorProjectTest(flowJsonLocation = "../flow/flow.json")
+public class GetAccountAccessAPIConnectorTest {
+    @FlowServiceAccountCredentials
+    private TestAccount testAccount;
+
+    @FlowTestClient
+    private FlowAccessApi accessAPI;
+
+    private GetAccountAccessAPIConnector accountConnector;
+
+    @BeforeEach
+    public void setup() {
+        accountConnector = new GetAccountAccessAPIConnector(accessAPI);
+    }
+
+    @Test
+    public void testCanFetchAccountFromLatestBlock() {
+        FlowAddress address = testAccount.getFlowAddress();
+        FlowAccount account = accountConnector.getAccountAtLatestBlock(address);
+
+        Assertions.assertNotNull(account, "Account should not be null");
+        Assertions.assertEquals(address.getBase16Value(), account.getAddress().getBase16Value(), "Address should match");
+        Assertions.assertTrue(account.getBalance().compareTo(BigDecimal.ZERO) >= 0, "Account balance should be non-negative");
+    }
+
+    @Test
+    public void testCanFetchAccountFromBlockByHeight0() {
+        FlowAddress address = testAccount.getFlowAddress();
+        FlowAccount account = accountConnector.getAccountAtBlockHeight(address, 0);
+
+        Assertions.assertNotNull(account, "Account should not be null");
+        Assertions.assertEquals(address.getBase16Value(), account.getAddress().getBase16Value(), "Address should match");
+        Assertions.assertTrue(account.getBalance().compareTo(BigDecimal.ZERO) >= 0, "Account balance should be non-negative");
+    }
+
+    @Test
+    public void testCanFetchAccountBalance() {
+        FlowAddress address = testAccount.getFlowAddress();
+        BigDecimal balance = accountConnector.getAccountBalance(address);
+
+        Assertions.assertNotNull(balance, "Balance should not be null");
+        Assertions.assertTrue(balance.compareTo(BigDecimal.ZERO) >= 0, "Balance should be non-negative");
+    }
+}