class IgniteProxyManager<K> extends AbstractProxyManager<K> {

    private final IgniteCache<K, byte[]> cache;

    public IgniteProxyManager(IgniteCache<K, byte[]> cache) {
        this(cache, ClientSideConfig.getDefault());
    }

    public IgniteProxyManager(IgniteCache<K, byte[]> cache, ClientSideConfig clientSideConfig) {
        super(clientSideConfig);
        this.cache = Objects.requireNonNull(cache);
    }

    @Override
    public <T> CommandResult<T> execute(K key, Request<T> request) {
        IgniteProcessor<K> entryProcessor = new IgniteProcessor<>(request);
        byte[] resultBytes = cache.invoke(key, entryProcessor);
        return deserializeResult(resultBytes, request.getBackwardCompatibilityVersion());
    }

    @Override
    public void removeProxy(K key) {
        cache.remove(key);
    }

    @Override
    public boolean isAsyncModeSupported() {
        return true;
    }

    @Override
    public <T> CompletableFuture<CommandResult<T>> executeAsync(K key, Request<T> request) {
        IgniteProcessor<K> entryProcessor = new IgniteProcessor<>(request);
        IgniteFuture<byte[]> igniteFuture = cache.invokeAsync(key, entryProcessor);
        Version backwardCompatibilityVersion = request.getBackwardCompatibilityVersion();
        CompletableFuture<CommandResult<T>> completableFuture = new CompletableFuture<>();
        igniteFuture.listen((IgniteInClosure<IgniteFuture<byte[]>>) completedIgniteFuture -> {
            try {
                byte[] resultBytes = completedIgniteFuture.get();
                CommandResult<T> result = deserializeResult(resultBytes, backwardCompatibilityVersion);
                completableFuture.complete(result);
            } catch (Throwable t) {
                completableFuture.completeExceptionally(t);
            }
        });
        return completableFuture;
    }

    @Override
    protected CompletableFuture<Void> removeAsync(K key) {<FILL_FUNCTION_BODY>}

    private static class IgniteProcessor<K> implements Serializable, CacheEntryProcessor<K, byte[], byte[]> {

        private static final long serialVersionUID = 1;

        private final byte[] requestBytes;

        private IgniteProcessor(Request<?> request) {
            this.requestBytes = serializeRequest(request);
        }

        @Override
        public byte[] process(MutableEntry<K, byte[]> entry, Object... arguments) throws EntryProcessorException {
            return new AbstractBinaryTransaction(requestBytes) {
                @Override
                public boolean exists() {
                    return entry.exists();
                }

                @Override
                protected byte[] getRawState() {
                    return entry.getValue();
                }

                @Override
                protected void setRawState(byte[] newStateBytes, RemoteBucketState newState) {
                    entry.setValue(newStateBytes);
                }
            }.execute();
        }

    }

}

        IgniteFuture<Boolean> igniteFuture = cache.removeAsync(key);
        CompletableFuture<Void> completableFuture = new CompletableFuture<>();
        igniteFuture.listen((IgniteInClosure<IgniteFuture<Boolean>>) completedIgniteFuture -> {
            try {
                completedIgniteFuture.get();
                completableFuture.complete(null);
            } catch (Throwable t) {
                completableFuture.completeExceptionally(t);
            }
        });
        return completableFuture;
    
<methods>public AsyncProxyManager<K> asAsync() ,public RemoteBucketBuilder<K> builder() ,public Optional<io.github.bucket4j.BucketConfiguration> getProxyConfiguration(K) <variables>private static final io.github.bucket4j.distributed.proxy.RecoveryStrategy DEFAULT_RECOVERY_STRATEGY,private static final io.github.bucket4j.distributed.proxy.optimization.Optimization DEFAULT_REQUEST_OPTIMIZER,private AsyncProxyManager<K> asyncView,private final non-sealed io.github.bucket4j.distributed.proxy.ClientSideConfig clientSideConfig