$ proto-downloader/download-bisq-protos.sh

$ python-examples/run-setup.sh

#!/bin/bash
./bisq-cli --password=xyz --port=9998 getversion

package bisq.rpccalls;

import bisq.proto.grpc.GetVersionGrpc;
import bisq.proto.grpc.GetVersionRequest;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class GetVersion extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = GetVersionGrpc.newBlockingStub(channel).withCallCredentials(credentials);
            var request = GetVersionRequest.newBuilder().build();
            var reply = stub.getVersion(request);
            out.println(reply.getVersion());
        } catch (Throwable t) {
            handleError(t);
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

import grpc

# from getpass import getpass
import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.GetVersionStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        response = grpc_service_stub.GetVersion.with_call(
            bisq_messages.GetVersionRequest(),
            metadata=[('password', api_password)])
        print('Response: ' + response[0].version)
    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


if __name__ == '__main__':
    main()

#!/bin/bash
./bisq-cli --password=xyz --port=9998 createoffer --help

package bisq.rpccalls;// Help Service is for CLI users.

# Help Service is for CLI users.

#!/bin/bash
./bisq-cli --password=xyz --port=9998 canceloffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea

package bisq.rpccalls;

import bisq.proto.grpc.CancelOfferRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class CancelOffer extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);
            var request = CancelOfferRequest.newBuilder()
                    .setId("83e8b2e2-51b6-4f39-a748-3ebd29c22aea")
                    .build();
            var response = stub.cancelOffer(request);
            out.println(response);
        } catch (Throwable t) {
            handleError(t);
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

import grpc

# from getpass import getpass
import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.OffersStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        response = grpc_service_stub.CancelOffer.with_call(
            bisq_messages.CancelOfferRequest(id='ubwhog-fef370c3-3fe7-4ac5-b0d6-8de850916642-184'),
            metadata=[('password', api_password)])
        print('Response: ' + str(response))
    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


if __name__ == '__main__':
    main()

#!/bin/bash
./bisq-cli --password=xyz --port=9998 createoffer \
  --swap=true \
  --direction=BUY \
  --currency-code=BSQ \
  --amount=0.50 \
  --min-amount=0.25 \
  --fixed-price=0.00005

package bisq.rpccalls;

import bisq.proto.grpc.CreateBsqSwapOfferRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class CreateBsqSwapOffer extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);
            var request = CreateBsqSwapOfferRequest.newBuilder()
                    .setDirection("BUY")    // Buy BTC with BSQ
                    .setAmount(12500000)    // Satoshis
                    .setMinAmount(6250000)  // Satoshis
                    .setPrice("0.00005")    // Price of 1 BSQ in BTC
                    .build();
            var response = stub.createBsqSwapOffer(request);
            out.println(response);
        } catch (Throwable t) {
            handleError(t);
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

import grpc

# from getpass import getpass
import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.OffersStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        response = grpc_service_stub.CreateBsqSwapOffer.with_call(
            bisq_messages.CreateBsqSwapOfferRequest(
                direction='SELL',  # Buy BTC with BSQ
                price='0.00005',  # Price of 1 BSQ in BTC
                amount=6250000,  # Satoshis
                min_amount=3125000),  # Optional parameter cannot be 0 Satoshis.
            metadata=[('password', api_password)])
        print('New BSQ swap offer: ' + str(response[0].bsq_swap_offer))
    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


if __name__ == '__main__':
    main()

#!/bin/bash

# Create a fixed-price offer to buy BTC with EUR.
./bisq-cli --password=xyz --port=9998 createoffer \
  --payment-account-id=f3c1ec8b-9761-458d-b13d-9039c6892413 \
  --direction=BUY \
  --currency-code=EUR \
  --amount=0.125 \
  --min-amount=0.0625 \
  --fixed-price=34500 \
  --security-deposit=15.0 \
  --fee-currency=BSQ

# Create a market-price-margin based offer to sell BTC for JPY, at 0.5% above the current market JPY price.
./bisq-cli --password=xyz --port=9998 createoffer \
  --payment-account-id=f3c1ec8b-9761-458d-b13d-9039c6892413 \
  --direction=SELL \
  --currency-code=JPY \
  --amount=0.125 \
  --min-amount=0.0625 \
  --market-price-margin=0.5 \
  --security-deposit=15.0 \
  --fee-currency=BSQ

# Create an offer to swap 0.5 BTC for BSQ, at a price of 0.00005 BTC for 1 BSQ
./bisq-cli --password=xyz --port=9998 createoffer \
  --swap=true \
  --direction=BUY \
  --currency-code=BSQ \
  --amount=0.5 \
  --fixed-price=0.00005

package bisq.rpccalls;

import bisq.proto.grpc.CreateOfferRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class CreateOffer extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);

            var fixedPriceOfferRequest = createFixedPriceEurOfferRequest();
            var fixedPriceOfferResponse = stub.createOffer(fixedPriceOfferRequest);
            out.println(fixedPriceOfferResponse);
            waitForOfferPreparation(5_000);

            var marketBasedPriceOfferRequest = createMarketBasedPriceEurOfferRequest();
            var marketBasedPriceOfferResponse = stub.createOffer(marketBasedPriceOfferRequest);
            out.println(marketBasedPriceOfferResponse);
            waitForOfferPreparation(5_000);

            var fixedPriceXmrOfferRequest = createFixedPriceXmrOfferRequest();
            var fixedPriceXmrOfferResponse = stub.createOffer(fixedPriceXmrOfferRequest);
            out.println(fixedPriceXmrOfferResponse);
        } catch (Throwable t) {
            handleError(t);
        }
    }

    private static CreateOfferRequest createFixedPriceEurOfferRequest() {
        return CreateOfferRequest.newBuilder()
                .setCurrencyCode("EUR")
                .setDirection("BUY")                // Buy BTC with EUR
                .setPrice("34500.00")
                .setAmount(12500000)                // Satoshis
                .setMinAmount(6250000)              // Satoshis
                .setBuyerSecurityDepositPct(15.00)  // 15%
                .setPaymentAccountId("f3c1ec8b-9761-458d-b13d-9039c6892413")
                .setMakerFeeCurrencyCode("BTC")     // Pay Bisq trade fee in BTC
                .build();
    }

    private static CreateOfferRequest createMarketBasedPriceEurOfferRequest() {
        return CreateOfferRequest.newBuilder()
                .setCurrencyCode("EUR")
                .setDirection("SELL")               // Sell BTC for EUR
                .setUseMarketBasedPrice(true)
                .setMarketPriceMarginPct(3.25)      // Sell at 3.25% above market BTC price in EUR
                .setAmount(12500000)                // Satoshis
                .setMinAmount(6250000)              // Satoshis
                .setBuyerSecurityDepositPct(15.00)  // 15%
                .setTriggerPrice("0")               // No trigger price
                .setPaymentAccountId("f3c1ec8b-9761-458d-b13d-9039c6892413")
                .setMakerFeeCurrencyCode("BSQ")     // Pay Bisq trade fee in BSQ
                .build();
    }

    private static CreateOfferRequest createFixedPriceXmrOfferRequest() {
        return CreateOfferRequest.newBuilder()
                .setCurrencyCode("XMR")
                .setDirection("BUY")                // Buy BTC with XMR
                .setPrice("0.005")                  // BTC price for 1 XMR
                .setAmount(12500000)                // Satoshis
                .setMinAmount(6250000)              // Satoshis
                .setBuyerSecurityDepositPct(33.00)  // 33%
                .setPaymentAccountId("g3c8ec8b-9aa1-458d-b66d-9039c6892413")
                .setMakerFeeCurrencyCode("BSQ")     // Pay Bisq trade fee in BSQ
                .build();
    }

    private static void waitForOfferPreparation(long ms) {
        try {
            // Wait new offer's preparation and wallet updates before attempting to create another offer.
            Thread.sleep(5_000);
        } catch (InterruptedException ex) {
            // ignored
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

# from getpass import getpass
import time

import grpc

import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.OffersStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        create_offer_request = fixed_price_usd_request()
        create_offer_response = grpc_service_stub.CreateOffer.with_call(create_offer_request,
                                                                        metadata=[('password', api_password)])
        print('New fixed-price offer: ' + str(create_offer_response[0].offer))
        time.sleep(3)  # Wait for new offer preparation and wallet updates before creating another offer.

        create_offer_request = market_based_price_usd_request()
        create_offer_response = grpc_service_stub.CreateOffer.with_call(create_offer_request,
                                                                        metadata=[('password', api_password)])
        print('New mkt price margin based offer: ' + str(create_offer_response[0].offer))
        time.sleep(3)  # Wait for new offer preparation and wallet updates before creating another offer.

        create_offer_request = fixed_price_xmr_request()
        create_offer_response = grpc_service_stub.CreateOffer.with_call(create_offer_request,
                                                                        metadata=[('password', api_password)])
        print('New XMR offer: ' + str(create_offer_response[0].offer))

    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


def fixed_price_usd_request():
    # Create an offer to buy BTC with USD at a fixed price.
    return bisq_messages.CreateOfferRequest(direction='BUY',
                                            currency_code='USD',
                                            price='40000.00',
                                            amount=12500000,
                                            min_amount=6250000,
                                            buyer_security_deposit_pct=20.00,
                                            payment_account_id='af852e11-f2db-48bd-82f5-123047b41f0c',
                                            maker_fee_currency_code='BSQ')


def market_based_price_usd_request():
    # Create an offer to sell BTC for USD at a moving, market price margin.
    return bisq_messages.CreateOfferRequest(direction='SELL',
                                            currency_code='USD',
                                            use_market_based_price=True,
                                            market_price_margin_pct=2.50,
                                            amount=12500000,
                                            min_amount=6250000,
                                            buyer_security_deposit_pct=20.00,
                                            payment_account_id='af852e11-f2db-48bd-82f5-123047b41f0c',
                                            maker_fee_currency_code='BSQ')


def fixed_price_xmr_request():
    # Create an offer to buy BTC with XMR.
    return bisq_messages.CreateOfferRequest(direction='BUY',  # Buy BTC with XMR
                                            currency_code='XMR',
                                            price='0.005',  # Price of 1 XMR in BTC
                                            amount=12500000,
                                            min_amount=6250000,
                                            buyer_security_deposit_pct=20.00,
                                            payment_account_id='7d52d9b6-e943-4625-a063-f53b09381bf2',
                                            maker_fee_currency_code='BTC')


if __name__ == '__main__':
    main()

#!/bin/bash

# Warning:  Editing an offer involves removing it from the offer book, then re-publishing
# it with the changes.  This operation takes a few seconds and clients should not try
# to make rapid changes to the same offer;  there must be a delay before each edit request
# for the same offer.

# Disable an offer.
./bisq-cli --password=xyz --port=9998 editoffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea \
  --enable=false

# Enable an offer.
./bisq-cli --password=xyz --port=9998 editoffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea \
  --enable=true

# Edit the fixed-price, and/or change a market price margin based offer to a fixed-price offer.
./bisq-cli --password=xyz --port=9998 editoffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea \
  --fixed-price=35000.5555

# Edit the price margin, and/or change a fixed-price offer to a market price margin based offer.
./bisq-cli --password=xyz --port=9998 editoffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea \
  --market-price-margin=0.5

# Set the trigger price on a market price margin based offer.
# Note:  trigger prices do not apply to fixed-price offers.
./bisq-cli --password=xyz --port=9998 editoffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea \
  --trigger-price=3960000.0000

# Remove the trigger price from a market price margin based offer.
./bisq-cli --password=xyz --port=9998 editoffer \
  --trigger-price=0

# Change a disabled fixed-price offer to a market price margin based offer, set a trigger price, and enable it.
./bisq-cli --password=xyz --port=9998 editoffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea \
  --market-price-margin=0.5 \
  --trigger-price=33000.0000 \
  --enable=true

package bisq.rpccalls;

import bisq.proto.grpc.EditOfferRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static bisq.proto.grpc.EditOfferRequest.EditType.*;
import static bisq.proto.grpc.EditOfferRequest.newBuilder;
import static java.lang.System.out;

public class EditOffer extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);

            var disableOfferRequest = createDisableOfferRequest();
            stub.editOffer(disableOfferRequest);
            out.println("Offer is disabled (removed from peers' offer book).");
            waitForOfferToBeRepublished(2_500);

            var editFixedPriceRequest = createEditFixedPriceRequest();
            stub.editOffer(editFixedPriceRequest);
            out.println("Offer has been re-published with new fixed-price.");
            waitForOfferToBeRepublished(2_500);

            var editFixedPriceAndEnableRequest = createEditFixedPriceAndEnableRequest();
            stub.editOffer(editFixedPriceAndEnableRequest);
            out.println("Offer has been re-published with new fixed-price, and enabled.");
            waitForOfferToBeRepublished(2_500);

            var editPriceMarginRequest = createEditPriceMarginRequest();
            stub.editOffer(editPriceMarginRequest);
            out.println("Offer has been re-published with new price margin.");
            waitForOfferToBeRepublished(2_500);

            var editTriggerPriceRequest = createEditTriggerPriceRequest();
            stub.editOffer(editTriggerPriceRequest);
            out.println("Offer has been re-published with new trigger price.");
        } catch (Throwable t) {
            handleError(t);
        }
    }

    private static EditOfferRequest createDisableOfferRequest() {
        return newBuilder()
                .setId("83e8b2e2-51b6-4f39-a748-3ebd29c22aea")
                .setEditType(ACTIVATION_STATE_ONLY)
                .setEnable(0)   // -1 = ignore this parameter, 0 = disable offer, 1 = enable offer
                .build();
    }

    private static EditOfferRequest createEditFixedPriceRequest() {
        return newBuilder()
                .setId("83e8b2e2-51b6-4f39-a748-3ebd29c22aea")
                .setEditType(FIXED_PRICE_ONLY)
                .setPrice("30000.99")
                .build();
    }

    private static EditOfferRequest createEditFixedPriceAndEnableRequest() {
        return newBuilder()
                .setId("83e8b2e2-51b6-4f39-a748-3ebd29c22aea")
                .setEditType(FIXED_PRICE_AND_ACTIVATION_STATE)
                .setPrice("30000.99")
                .setEnable(1)
                .build();
    }

    private static EditOfferRequest createEditPriceMarginRequest() {
        return newBuilder()
                .setId("83e8b2e2-51b6-4f39-a748-3ebd29c22aea")
                .setEditType(MKT_PRICE_MARGIN_ONLY)
                .setUseMarketBasedPrice(true)
                .setMarketPriceMarginPct(2.00)  // 2.00%
                .build();
    }

    private static EditOfferRequest createEditTriggerPriceRequest() {
        return newBuilder()
                .setId("83e8b2e2-51b6-4f39-a748-3ebd29c22aea")
                .setEditType(TRIGGER_PRICE_ONLY)
                .setTriggerPrice("29000.00")    // Trigger price is disabled when set to "0".
                .build();
    }

    private static void waitForOfferToBeRepublished(long ms) {
        try {
            // Wait for edited offer to be removed from offer-book, edited, and re-published.
            Thread.sleep(ms);
        } catch (InterruptedException ex) {
            // ignored
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

# from getpass import getpass
import time

import grpc

import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service

EDITED_USD_OFFER_ID = '44736-16df6819-d98b-4f13-87dd-50087c464fac-184'


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.OffersStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        edit_offer_request = disable_offer_request()
        edit_offer_response = grpc_service_stub.EditOffer.with_call(edit_offer_request,
                                                                    metadata=[('password', api_password)])
        print('Offer is disabled.  Rpc response: ' + str(edit_offer_response))
        time.sleep(4)  # Wait for new offer preparation and wallet updates before creating another offer.

        edit_offer_request = enable_offer_request()
        edit_offer_response = grpc_service_stub.EditOffer.with_call(edit_offer_request,
                                                                    metadata=[('password', api_password)])
        print('Offer is enabled.  Rpc response: ' + str(edit_offer_response))
        time.sleep(4)  # Wait for new offer preparation and wallet updates before creating another offer.

        edit_offer_request = edit_fixed_price_request()
        edit_offer_response = grpc_service_stub.EditOffer.with_call(edit_offer_request,
                                                                    metadata=[('password', api_password)])
        print('Offer fixed-price has been changed.  Rpc response: ' + str(edit_offer_response))
        time.sleep(4)  # Wait for new offer preparation and wallet updates before creating another offer.

        edit_offer_request = edit_fixed_price_and_enable_request()
        edit_offer_response = grpc_service_stub.EditOffer.with_call(edit_offer_request,
                                                                    metadata=[('password', api_password)])
        print('Offer fixed-price has been changed, and offer is enabled.  Rpc response: ' + str(edit_offer_response))
        time.sleep(4)  # Wait for new offer preparation and wallet updates before creating another offer.

        # Change the fixed-price offer to a mkt price margin based offer
        edit_offer_request = edit_price_margin_request()
        edit_offer_response = grpc_service_stub.EditOffer.with_call(edit_offer_request,
                                                                    metadata=[('password', api_password)])
        print('Fixed-price offer is not a mkt price margin based offer.  Rpc response: ' + str(edit_offer_response))
        time.sleep(4)  # Wait for new offer preparation and wallet updates before creating another offer.

        # Set the trigger-price on a mkt price margin based offer
        edit_offer_request = edit_trigger_price_request()
        edit_offer_response = grpc_service_stub.EditOffer.with_call(edit_offer_request,
                                                                    metadata=[('password', api_password)])
        print('Offer trigger price is set.  Rpc response: ' + str(edit_offer_response))

    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


def disable_offer_request():
    return bisq_messages.EditOfferRequest(
        id=EDITED_USD_OFFER_ID,
        edit_type=bisq_messages.EditOfferRequest.EditType.ACTIVATION_STATE_ONLY,
        enable=0)  # If enable=-1: ignore enable param, enable=0: disable offer, enable=1: enable offer


def enable_offer_request():
    return bisq_messages.EditOfferRequest(
        id=EDITED_USD_OFFER_ID,
        edit_type=bisq_messages.EditOfferRequest.EditType.ACTIVATION_STATE_ONLY,
        enable=1)  # If enable=-1: ignore enable param, enable=0: disable offer, enable=1: enable offer


def edit_fixed_price_request():
    return bisq_messages.EditOfferRequest(
        id=EDITED_USD_OFFER_ID,
        price='42000.50',
        edit_type=bisq_messages.EditOfferRequest.EditType.FIXED_PRICE_ONLY,
        enable=-1)  # If enable=-1: ignore enable param, enable=0: disable offer, enable=1: enable offer


def edit_fixed_price_and_enable_request():
    return bisq_messages.EditOfferRequest(
        id=EDITED_USD_OFFER_ID,
        price='43000.50',
        edit_type=bisq_messages.EditOfferRequest.EditType.FIXED_PRICE_AND_ACTIVATION_STATE,
        enable=1)  # If enable=-1: ignore enable param, enable=0: disable offer, enable=1: enable offer


def edit_price_margin_request():
    return bisq_messages.EditOfferRequest(
        id=EDITED_USD_OFFER_ID,
        use_market_based_price=True,
        market_price_margin_pct=5.00,
        edit_type=bisq_messages.EditOfferRequest.EditType.MKT_PRICE_MARGIN_ONLY,
        enable=-1)  # If enable=-1: ignore enable param, enable=0: disable offer, enable=1: enable offer


def edit_trigger_price_request():
    return bisq_messages.EditOfferRequest(
        id=EDITED_USD_OFFER_ID,
        trigger_price='40000.0000',
        edit_type=bisq_messages.EditOfferRequest.EditType.TRIGGER_PRICE_ONLY,
        enable=-1)  # If enable=-1: ignore enable param, enable=0: disable offer, enable=1: enable offer


if __name__ == '__main__':
    main()

#!/bin/bash
./bisq-cli --password=xyz --port=9998 getoffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea

package bisq.rpccalls;

import bisq.proto.grpc.GetOfferRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class GetBsqSwapOffer extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);
            var request = GetOfferRequest.newBuilder()
                    .setId("83e8b2e2-51b6-4f39-a748-3ebd29c22aea")
                    .build();
            var response = stub.getBsqSwapOffer(request);
            out.println(response);
        } catch (Throwable t) {
            handleError(t);
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

import grpc

# from getpass import getpass
import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.OffersStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        response = grpc_service_stub.GetBsqSwapOffer.with_call(
            bisq_messages.GetOfferRequest(id='VZLGFPV-e8dd2f8c-fc90-4509-8f30-e0bb95815b46-184'),
            metadata=[('password', api_password)])
        print('Response: ' + str(response[0].bsq_swap_offer))
    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


if __name__ == '__main__':
    main()

#!/bin/bash
# Get available BSQ swap offers to buy BTC with BSQ.
./bisq-cli --password=xyz --port=9998 getoffers --direction=BUY --currency-code=BSQ
# Get available BSQ swap offers to sell BTC for BSQ.
./bisq-cli --password=xyz --port=9998 getoffers --direction=SELL --currency-code=BSQ

package bisq.rpccalls;

import bisq.proto.grpc.GetBsqSwapOffersRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class GetBsqSwapOffers extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);
            var request = GetBsqSwapOffersRequest.newBuilder()
                    .setDirection("SELL")   // Offers to sell (swap) BTC for BSQ.
                    .build();
            var response = stub.getBsqSwapOffers(request);
            out.println(response);
        } catch (Throwable t) {
            handleError(t);
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

import grpc

# from getpass import getpass
import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.OffersStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        response = grpc_service_stub.GetBsqSwapOffers.with_call(
            bisq_messages.GetBsqSwapOffersRequest(direction='SELL'),
            metadata=[('password', api_password)])
        print('Response: ' + str(response[0].bsq_swap_offers))
    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


if __name__ == '__main__':
    main()

#!/bin/bash
./bisq-cli --password=xyz --port=9998 getmyoffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea

package bisq.rpccalls;

import bisq.proto.grpc.GetMyOfferRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class GetMyBsqSwapOffer extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);
            var request = GetMyOfferRequest.newBuilder()
                    .setId("83e8b2e2-51b6-4f39-a748-3ebd29c22aea")
                    .build();
            var response = stub.getMyBsqSwapOffer(request);
            out.println(response);
        } catch (Throwable t) {
            handleError(t);
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

import grpc

# from getpass import getpass
import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.OffersStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        response = grpc_service_stub.GetMyBsqSwapOffer.with_call(
            bisq_messages.GetMyOfferRequest(id='gzcvxum-63c23b0b-6acd-49ba-a956-55e406994da1-184'),
            metadata=[('password', api_password)])
        print('Response: ' + str(response[0].bsq_swap_offer))
    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


if __name__ == '__main__':
    main()

#!/bin/bash
# Get my BSQ swap offers to buy BTC for BSQ.
./bisq-cli --password=xyz --port=9998 getmyoffers --direction=BUY --currency-code=BSQ
# Get my BSQ swap offers to sell BTC for BSQ.
./bisq-cli --password=xyz --port=9998 getmyoffers --direction=SELL --currency-code=BSQ

package bisq.rpccalls;

import bisq.proto.grpc.GetBsqSwapOffersRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class GetMyBsqSwapOffers extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);
            var request = GetBsqSwapOffersRequest.newBuilder()
                    .setDirection("BUY")   // Offers to buy (swap) BTC for BSQ.
                    .build();
            var response = stub.getBsqSwapOffers(request);
            out.println(response);
        } catch (Throwable t) {
            handleError(t);
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

import grpc

# from getpass import getpass
import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.OffersStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        response = grpc_service_stub.GetMyBsqSwapOffers.with_call(
            bisq_messages.GetBsqSwapOffersRequest(direction='BUY'),  # My buy BTC for BSQ swap offers
            metadata=[('password', api_password)])
        offers = list(response[0].bsq_swap_offers)
        print('Response: ' + str(offers))
    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


if __name__ == '__main__':
    main()

#!/bin/bash
./bisq-cli --password=xyz --port=9998 getmyoffer \
  --offer-id=83e8b2e2-51b6-4f39-a748-3ebd29c22aea

package bisq.rpccalls;

import bisq.proto.grpc.GetMyOfferRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class GetMyOffer extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);
            var request = GetMyOfferRequest.newBuilder()
                    .setId("83e8b2e2-51b6-4f39-a748-3ebd29c22aea")
                    .build();
            var response = stub.getMyOffer(request);
            out.println(response);
        } catch (Throwable t) {
            handleError(t);
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}

import grpc

# from getpass import getpass
import bisq.api.grpc_pb2 as bisq_messages
import bisq.api.grpc_pb2_grpc as bisq_service


def main():
    grpc_channel = grpc.insecure_channel('localhost:9998')
    grpc_service_stub = bisq_service.OffersStub(grpc_channel)
    api_password: str = 'xyz'  # getpass("Enter API password: ")
    try:
        response = grpc_service_stub.GetMyOffer.with_call(
            bisq_messages.GetMyOfferRequest(id='QusccrDV-47ae5521-bda1-4f3c-801b-5c193f957df7-184'),
            metadata=[('password', api_password)])
        print('Response: ' + str(response[0].offer))
    except grpc.RpcError as rpc_error:
        print('gRPC API Exception: %s', rpc_error)


if __name__ == '__main__':
    main()

#!/bin/bash
# Get my offers to buy BTC with EUR.
./bisq-cli --password=xyz --port=9998 getmyoffers --direction=BUY --currency-code=EUR
# Get my offers to sell BTC for EUR.
./bisq-cli --password=xyz --port=9998 getmyoffers --direction=SELL --currency-code=EUR

package bisq.rpccalls;

import bisq.proto.grpc.GetMyOffersRequest;
import bisq.proto.grpc.OffersGrpc;
import io.grpc.ManagedChannelBuilder;

import static java.lang.System.out;

public class GetMyOffers extends BaseJavaExample {

    public static void main(String[] args) {
        try {
            var channel = ManagedChannelBuilder.forAddress("localhost", 9998).usePlaintext().build();
            addChannelShutdownHook(channel);
            var credentials = buildCallCredentials(getApiPassword());
            var stub = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);
            var request = GetMyOffersRequest.newBuilder()
                    .setDirection("BUY")        // Offers to buy BTC
                    .setCurrencyCode("USD")     // with USD
                    .build();
            var response = stub.getMyOffers(request);
            out.println(response);
        } catch (Throwable t) {
            handleError(t);
        }
    }
}

//////////////////
// BaseJavaExample
//////////////////

package bisq.rpccalls;

import io.grpc.CallCredentials;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;

import java.util.Scanner;
import java.util.concurrent.Executor;

import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Status.UNAUTHENTICATED;
import static java.lang.System.*;
import static java.util.concurrent.TimeUnit.SECONDS;

public class BaseJavaExample {

    static void addChannelShutdownHook(ManagedChannel channel) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.shutdown().awaitTermination(1, SECONDS);
            } catch (InterruptedException ex) {
                throw new IllegalStateException("Error shutting down gRPC channel.", ex);
            }
        }));
    }

    static String getApiPassword() {
        Scanner scanner = new Scanner(in);
        out.println("Enter api password:");
        var apiPassword = "xyz";    // scanner.nextLine();
        scanner.close();
        return apiPassword;
    }

    static CallCredentials buildCallCredentials(String apiPassword) {
        return new CallCredentials() {
            @Override
            public void applyRequestMetadata(RequestInfo requestInfo,
                                             Executor appExecutor,
                                             MetadataApplier metadataApplier) {
                appExecutor.execute(() -> {
                    try {
                        var headers = new Metadata();
                        var passwordKey = Metadata.Key.of("password", ASCII_STRING_MARSHALLER);
                        headers.put(passwordKey, apiPassword);
                        metadataApplier.apply(headers);
                    } catch (Throwable ex) {
                        metadataApplier.fail(UNAUTHENTICATED.withCause(ex));
                    }
                });
            }

            @Override
            public void thisUsesUnstableApi() {
            }
        };
    }

    static void handleError(Throwable t) {
        if (t instanceof StatusRuntimeException) {
            var grpcErrorStatus = ((StatusRuntimeException) t).getStatus();
            err.println(grpcErrorStatus.getCode() + ": " + grpcErrorStatus.getDescription());
        } else {
            err.println("Error: " + t);
        }
    }
}