From fc8bc53a8c791d16010093fc3184af937db7c897 Mon Sep 17 00:00:00 2001 From: "dfnsco-dfns-sdk-sync[bot]" <275545256+dfnsco-dfns-sdk-sync[bot]@users.noreply.github.com> Date: Thu, 9 Jul 2026 16:47:50 +0000 Subject: [PATCH] chore: sync generated SDK from monorepo v1.910.1 --- .../java/co/dfns/sdk/DfnsAsyncClient.java | 6 + src/main/java/co/dfns/sdk/DfnsClient.java | 6 + .../co/dfns/sdk/DfnsDelegatedAsyncClient.java | 6 + .../java/co/dfns/sdk/DfnsDelegatedClient.java | 6 + .../payins/DelegatedPayinsAsyncClient.java | 32 ++++ .../sdk/payins/DelegatedPayinsClient.java | 31 ++++ .../co/dfns/sdk/payins/PayinsAsyncClient.java | 24 +++ .../java/co/dfns/sdk/payins/PayinsClient.java | 23 +++ .../payins/model/GetPayinRecipientQuery.java | 33 +++++ .../model/GetPayinRecipientResponse.java | 15 ++ .../model/RegisterPayinRecipientResponse.java | 15 ++ .../vaults/DelegatedVaultsAsyncClient.java | 117 +++++++++++++++ .../sdk/vaults/DelegatedVaultsClient.java | 116 +++++++++++++++ .../co/dfns/sdk/vaults/VaultsAsyncClient.java | 73 +++++++++ .../java/co/dfns/sdk/vaults/VaultsClient.java | 72 +++++++++ .../model/CreateVaultAddressRequest.java | 9 ++ .../sdk/vaults/model/CreateVaultRequest.java | 16 ++ .../model/CreateVaultTransferRequest.java | 15 ++ .../vaults/model/ListVaultAssetsQuery.java | 26 ++++ .../vaults/model/ListVaultAssetsResponse.java | 11 ++ .../vaults/model/ListVaultBalancesQuery.java | 47 ++++++ .../sdk/vaults/model/ListVaultsQuery.java | 26 ++++ .../co/dfns/sdk/vaults/model/Network.java | 139 ++++++++++++++++++ .../co/dfns/sdk/vaults/model/Requester.java | 12 ++ .../sdk/vaults/model/TagVaultRequest.java | 10 ++ .../sdk/vaults/model/TransferRequest.java | 40 +++++ .../sdk/vaults/model/UnquarantineRequest.java | 11 ++ .../vaults/model/UnquarantineResponse.java | 9 ++ .../sdk/vaults/model/UntagVaultRequest.java | 10 ++ .../sdk/vaults/model/UpdateVaultRequest.java | 13 ++ .../java/co/dfns/sdk/vaults/model/Vault.java | 21 +++ .../dfns/sdk/vaults/model/VaultAddress.java | 11 ++ .../co/dfns/sdk/vaults/model/VaultAsset.java | 23 +++ .../sdk/vaults/model/VaultBalanceEntry.java | 18 +++ .../dfns/sdk/vaults/model/VaultNetWorth.java | 13 ++ 35 files changed, 1055 insertions(+) create mode 100644 src/main/java/co/dfns/sdk/payins/DelegatedPayinsAsyncClient.java create mode 100644 src/main/java/co/dfns/sdk/payins/DelegatedPayinsClient.java create mode 100644 src/main/java/co/dfns/sdk/payins/PayinsAsyncClient.java create mode 100644 src/main/java/co/dfns/sdk/payins/PayinsClient.java create mode 100644 src/main/java/co/dfns/sdk/payins/model/GetPayinRecipientQuery.java create mode 100644 src/main/java/co/dfns/sdk/payins/model/GetPayinRecipientResponse.java create mode 100644 src/main/java/co/dfns/sdk/payins/model/RegisterPayinRecipientResponse.java create mode 100644 src/main/java/co/dfns/sdk/vaults/DelegatedVaultsAsyncClient.java create mode 100644 src/main/java/co/dfns/sdk/vaults/DelegatedVaultsClient.java create mode 100644 src/main/java/co/dfns/sdk/vaults/VaultsAsyncClient.java create mode 100644 src/main/java/co/dfns/sdk/vaults/VaultsClient.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/CreateVaultAddressRequest.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/CreateVaultRequest.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/CreateVaultTransferRequest.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/ListVaultAssetsQuery.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/ListVaultAssetsResponse.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/ListVaultBalancesQuery.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/ListVaultsQuery.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/Network.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/Requester.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/TagVaultRequest.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/TransferRequest.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/UnquarantineRequest.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/UnquarantineResponse.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/UntagVaultRequest.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/UpdateVaultRequest.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/Vault.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/VaultAddress.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/VaultAsset.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/VaultBalanceEntry.java create mode 100644 src/main/java/co/dfns/sdk/vaults/model/VaultNetWorth.java diff --git a/src/main/java/co/dfns/sdk/DfnsAsyncClient.java b/src/main/java/co/dfns/sdk/DfnsAsyncClient.java index 15cd44c..c49d907 100644 --- a/src/main/java/co/dfns/sdk/DfnsAsyncClient.java +++ b/src/main/java/co/dfns/sdk/DfnsAsyncClient.java @@ -8,12 +8,14 @@ import co.dfns.sdk.feesponsors.FeeSponsorsAsyncClient; import co.dfns.sdk.keys.KeysAsyncClient; import co.dfns.sdk.networks.NetworksAsyncClient; +import co.dfns.sdk.payins.PayinsAsyncClient; import co.dfns.sdk.payouts.PayoutsAsyncClient; import co.dfns.sdk.permissions.PermissionsAsyncClient; import co.dfns.sdk.policies.PoliciesAsyncClient; import co.dfns.sdk.signers.SignersAsyncClient; import co.dfns.sdk.staking.StakingAsyncClient; import co.dfns.sdk.swaps.SwapsAsyncClient; +import co.dfns.sdk.vaults.VaultsAsyncClient; import co.dfns.sdk.wallets.WalletsAsyncClient; import co.dfns.sdk.webhooks.WebhooksAsyncClient; @@ -27,12 +29,14 @@ public class DfnsAsyncClient implements AutoCloseable { public final FeeSponsorsAsyncClient feeSponsors; public final KeysAsyncClient keys; public final NetworksAsyncClient networks; + public final PayinsAsyncClient payins; public final PayoutsAsyncClient payouts; public final PermissionsAsyncClient permissions; public final PoliciesAsyncClient policies; public final SignersAsyncClient signers; public final StakingAsyncClient staking; public final SwapsAsyncClient swaps; + public final VaultsAsyncClient vaults; public final WalletsAsyncClient wallets; public final WebhooksAsyncClient webhooks; @@ -45,12 +49,14 @@ public DfnsAsyncClient(DfnsClientConfig config) { this.feeSponsors = new FeeSponsorsAsyncClient(httpClient); this.keys = new KeysAsyncClient(httpClient); this.networks = new NetworksAsyncClient(httpClient); + this.payins = new PayinsAsyncClient(httpClient); this.payouts = new PayoutsAsyncClient(httpClient); this.permissions = new PermissionsAsyncClient(httpClient); this.policies = new PoliciesAsyncClient(httpClient); this.signers = new SignersAsyncClient(httpClient); this.staking = new StakingAsyncClient(httpClient); this.swaps = new SwapsAsyncClient(httpClient); + this.vaults = new VaultsAsyncClient(httpClient); this.wallets = new WalletsAsyncClient(httpClient); this.webhooks = new WebhooksAsyncClient(httpClient); } diff --git a/src/main/java/co/dfns/sdk/DfnsClient.java b/src/main/java/co/dfns/sdk/DfnsClient.java index 7981c7b..63ff7e6 100644 --- a/src/main/java/co/dfns/sdk/DfnsClient.java +++ b/src/main/java/co/dfns/sdk/DfnsClient.java @@ -8,12 +8,14 @@ import co.dfns.sdk.feesponsors.FeeSponsorsClient; import co.dfns.sdk.keys.KeysClient; import co.dfns.sdk.networks.NetworksClient; +import co.dfns.sdk.payins.PayinsClient; import co.dfns.sdk.payouts.PayoutsClient; import co.dfns.sdk.permissions.PermissionsClient; import co.dfns.sdk.policies.PoliciesClient; import co.dfns.sdk.signers.SignersClient; import co.dfns.sdk.staking.StakingClient; import co.dfns.sdk.swaps.SwapsClient; +import co.dfns.sdk.vaults.VaultsClient; import co.dfns.sdk.wallets.WalletsClient; import co.dfns.sdk.webhooks.WebhooksClient; @@ -27,12 +29,14 @@ public class DfnsClient implements AutoCloseable { public final FeeSponsorsClient feeSponsors; public final KeysClient keys; public final NetworksClient networks; + public final PayinsClient payins; public final PayoutsClient payouts; public final PermissionsClient permissions; public final PoliciesClient policies; public final SignersClient signers; public final StakingClient staking; public final SwapsClient swaps; + public final VaultsClient vaults; public final WalletsClient wallets; public final WebhooksClient webhooks; @@ -45,12 +49,14 @@ public DfnsClient(DfnsClientConfig config) { this.feeSponsors = new FeeSponsorsClient(httpClient); this.keys = new KeysClient(httpClient); this.networks = new NetworksClient(httpClient); + this.payins = new PayinsClient(httpClient); this.payouts = new PayoutsClient(httpClient); this.permissions = new PermissionsClient(httpClient); this.policies = new PoliciesClient(httpClient); this.signers = new SignersClient(httpClient); this.staking = new StakingClient(httpClient); this.swaps = new SwapsClient(httpClient); + this.vaults = new VaultsClient(httpClient); this.wallets = new WalletsClient(httpClient); this.webhooks = new WebhooksClient(httpClient); } diff --git a/src/main/java/co/dfns/sdk/DfnsDelegatedAsyncClient.java b/src/main/java/co/dfns/sdk/DfnsDelegatedAsyncClient.java index e0d20f5..12a2838 100644 --- a/src/main/java/co/dfns/sdk/DfnsDelegatedAsyncClient.java +++ b/src/main/java/co/dfns/sdk/DfnsDelegatedAsyncClient.java @@ -8,12 +8,14 @@ import co.dfns.sdk.feesponsors.DelegatedFeeSponsorsAsyncClient; import co.dfns.sdk.keys.DelegatedKeysAsyncClient; import co.dfns.sdk.networks.DelegatedNetworksAsyncClient; +import co.dfns.sdk.payins.DelegatedPayinsAsyncClient; import co.dfns.sdk.payouts.DelegatedPayoutsAsyncClient; import co.dfns.sdk.permissions.DelegatedPermissionsAsyncClient; import co.dfns.sdk.policies.DelegatedPoliciesAsyncClient; import co.dfns.sdk.signers.DelegatedSignersAsyncClient; import co.dfns.sdk.staking.DelegatedStakingAsyncClient; import co.dfns.sdk.swaps.DelegatedSwapsAsyncClient; +import co.dfns.sdk.vaults.DelegatedVaultsAsyncClient; import co.dfns.sdk.wallets.DelegatedWalletsAsyncClient; import co.dfns.sdk.webhooks.DelegatedWebhooksAsyncClient; @@ -31,12 +33,14 @@ public class DfnsDelegatedAsyncClient implements AutoCloseable { public final DelegatedFeeSponsorsAsyncClient feeSponsors; public final DelegatedKeysAsyncClient keys; public final DelegatedNetworksAsyncClient networks; + public final DelegatedPayinsAsyncClient payins; public final DelegatedPayoutsAsyncClient payouts; public final DelegatedPermissionsAsyncClient permissions; public final DelegatedPoliciesAsyncClient policies; public final DelegatedSignersAsyncClient signers; public final DelegatedStakingAsyncClient staking; public final DelegatedSwapsAsyncClient swaps; + public final DelegatedVaultsAsyncClient vaults; public final DelegatedWalletsAsyncClient wallets; public final DelegatedWebhooksAsyncClient webhooks; @@ -49,12 +53,14 @@ public DfnsDelegatedAsyncClient(DfnsClientConfig config) { this.feeSponsors = new DelegatedFeeSponsorsAsyncClient(httpClient); this.keys = new DelegatedKeysAsyncClient(httpClient); this.networks = new DelegatedNetworksAsyncClient(httpClient); + this.payins = new DelegatedPayinsAsyncClient(httpClient); this.payouts = new DelegatedPayoutsAsyncClient(httpClient); this.permissions = new DelegatedPermissionsAsyncClient(httpClient); this.policies = new DelegatedPoliciesAsyncClient(httpClient); this.signers = new DelegatedSignersAsyncClient(httpClient); this.staking = new DelegatedStakingAsyncClient(httpClient); this.swaps = new DelegatedSwapsAsyncClient(httpClient); + this.vaults = new DelegatedVaultsAsyncClient(httpClient); this.wallets = new DelegatedWalletsAsyncClient(httpClient); this.webhooks = new DelegatedWebhooksAsyncClient(httpClient); } diff --git a/src/main/java/co/dfns/sdk/DfnsDelegatedClient.java b/src/main/java/co/dfns/sdk/DfnsDelegatedClient.java index 1316114..c4e3c32 100644 --- a/src/main/java/co/dfns/sdk/DfnsDelegatedClient.java +++ b/src/main/java/co/dfns/sdk/DfnsDelegatedClient.java @@ -8,12 +8,14 @@ import co.dfns.sdk.feesponsors.DelegatedFeeSponsorsClient; import co.dfns.sdk.keys.DelegatedKeysClient; import co.dfns.sdk.networks.DelegatedNetworksClient; +import co.dfns.sdk.payins.DelegatedPayinsClient; import co.dfns.sdk.payouts.DelegatedPayoutsClient; import co.dfns.sdk.permissions.DelegatedPermissionsClient; import co.dfns.sdk.policies.DelegatedPoliciesClient; import co.dfns.sdk.signers.DelegatedSignersClient; import co.dfns.sdk.staking.DelegatedStakingClient; import co.dfns.sdk.swaps.DelegatedSwapsClient; +import co.dfns.sdk.vaults.DelegatedVaultsClient; import co.dfns.sdk.wallets.DelegatedWalletsClient; import co.dfns.sdk.webhooks.DelegatedWebhooksClient; @@ -31,12 +33,14 @@ public class DfnsDelegatedClient implements AutoCloseable { public final DelegatedFeeSponsorsClient feeSponsors; public final DelegatedKeysClient keys; public final DelegatedNetworksClient networks; + public final DelegatedPayinsClient payins; public final DelegatedPayoutsClient payouts; public final DelegatedPermissionsClient permissions; public final DelegatedPoliciesClient policies; public final DelegatedSignersClient signers; public final DelegatedStakingClient staking; public final DelegatedSwapsClient swaps; + public final DelegatedVaultsClient vaults; public final DelegatedWalletsClient wallets; public final DelegatedWebhooksClient webhooks; @@ -49,12 +53,14 @@ public DfnsDelegatedClient(DfnsClientConfig config) { this.feeSponsors = new DelegatedFeeSponsorsClient(httpClient); this.keys = new DelegatedKeysClient(httpClient); this.networks = new DelegatedNetworksClient(httpClient); + this.payins = new DelegatedPayinsClient(httpClient); this.payouts = new DelegatedPayoutsClient(httpClient); this.permissions = new DelegatedPermissionsClient(httpClient); this.policies = new DelegatedPoliciesClient(httpClient); this.signers = new DelegatedSignersClient(httpClient); this.staking = new DelegatedStakingClient(httpClient); this.swaps = new DelegatedSwapsClient(httpClient); + this.vaults = new DelegatedVaultsClient(httpClient); this.wallets = new DelegatedWalletsClient(httpClient); this.webhooks = new DelegatedWebhooksClient(httpClient); } diff --git a/src/main/java/co/dfns/sdk/payins/DelegatedPayinsAsyncClient.java b/src/main/java/co/dfns/sdk/payins/DelegatedPayinsAsyncClient.java new file mode 100644 index 0000000..5ceea7a --- /dev/null +++ b/src/main/java/co/dfns/sdk/payins/DelegatedPayinsAsyncClient.java @@ -0,0 +1,32 @@ +package co.dfns.sdk.payins; + +import co.dfns.sdk.internal.DfnsHttpClient; +import co.dfns.sdk.payins.model.*; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import co.dfns.sdk.auth.UserActionChallenge; +import co.dfns.sdk.auth.CredentialAssertion; + +public class DelegatedPayinsAsyncClient { + private final DfnsHttpClient httpClient; + + public DelegatedPayinsAsyncClient(DfnsHttpClient httpClient) { + this.httpClient = httpClient; + } + + /** Get Payin Recipient */ + public CompletableFuture getPayinRecipient(GetPayinRecipientQuery query) { + return httpClient.getAsync("/payins/recipients", query.toMap(), GetPayinRecipientResponse.class); + } + + /** Delegated signing step 1 for Register Payin Recipient: returns the challenge to sign out-of-band. */ + public CompletableFuture registerPayinRecipientInit(Object body) { + return httpClient.createUserActionChallengeAsync("POST", "/payins/recipients", body); + } + + /** Delegated signing step 2 for Register Payin Recipient: submits the signed challenge and issues the request. */ + public CompletableFuture registerPayinRecipientComplete(Object body, String challengeIdentifier, CredentialAssertion assertion) { + return httpClient.completeUserActionSigningAsync(challengeIdentifier, assertion) + .thenCompose(userAction -> httpClient.executeWithUserActionAsync("POST", "/payins/recipients", java.util.Map.of(), body, RegisterPayinRecipientResponse.class, userAction)); + } +} diff --git a/src/main/java/co/dfns/sdk/payins/DelegatedPayinsClient.java b/src/main/java/co/dfns/sdk/payins/DelegatedPayinsClient.java new file mode 100644 index 0000000..51a6067 --- /dev/null +++ b/src/main/java/co/dfns/sdk/payins/DelegatedPayinsClient.java @@ -0,0 +1,31 @@ +package co.dfns.sdk.payins; + +import co.dfns.sdk.internal.DfnsHttpClient; +import co.dfns.sdk.payins.model.*; +import java.util.Map; +import co.dfns.sdk.auth.UserActionChallenge; +import co.dfns.sdk.auth.CredentialAssertion; + +public class DelegatedPayinsClient { + private final DfnsHttpClient httpClient; + + public DelegatedPayinsClient(DfnsHttpClient httpClient) { + this.httpClient = httpClient; + } + + /** Get Payin Recipient */ + public GetPayinRecipientResponse getPayinRecipient(GetPayinRecipientQuery query) { + return httpClient.get("/payins/recipients", query.toMap(), GetPayinRecipientResponse.class); + } + + /** Delegated signing step 1 for Register Payin Recipient: returns the challenge to sign out-of-band. */ + public UserActionChallenge registerPayinRecipientInit(Object body) { + return httpClient.createUserActionChallenge("POST", "/payins/recipients", body); + } + + /** Delegated signing step 2 for Register Payin Recipient: submits the signed challenge and issues the request. */ + public RegisterPayinRecipientResponse registerPayinRecipientComplete(Object body, String challengeIdentifier, CredentialAssertion assertion) { + String userAction = httpClient.completeUserActionSigning(challengeIdentifier, assertion); + return httpClient.executeWithUserAction("POST", "/payins/recipients", java.util.Map.of(), body, RegisterPayinRecipientResponse.class, userAction); + } +} diff --git a/src/main/java/co/dfns/sdk/payins/PayinsAsyncClient.java b/src/main/java/co/dfns/sdk/payins/PayinsAsyncClient.java new file mode 100644 index 0000000..bdc950f --- /dev/null +++ b/src/main/java/co/dfns/sdk/payins/PayinsAsyncClient.java @@ -0,0 +1,24 @@ +package co.dfns.sdk.payins; + +import co.dfns.sdk.internal.DfnsHttpClient; +import co.dfns.sdk.payins.model.*; +import java.util.Map; +import java.util.concurrent.CompletableFuture; + +public class PayinsAsyncClient { + private final DfnsHttpClient httpClient; + + public PayinsAsyncClient(DfnsHttpClient httpClient) { + this.httpClient = httpClient; + } + + /** Get Payin Recipient */ + public CompletableFuture getPayinRecipient(GetPayinRecipientQuery query) { + return httpClient.getAsync("/payins/recipients", query.toMap(), GetPayinRecipientResponse.class); + } + + /** Register Payin Recipient */ + public CompletableFuture registerPayinRecipient(Object body) { + return httpClient.postAsync("/payins/recipients", java.util.Map.of(), body, RegisterPayinRecipientResponse.class, true); + } +} diff --git a/src/main/java/co/dfns/sdk/payins/PayinsClient.java b/src/main/java/co/dfns/sdk/payins/PayinsClient.java new file mode 100644 index 0000000..9ea4bc1 --- /dev/null +++ b/src/main/java/co/dfns/sdk/payins/PayinsClient.java @@ -0,0 +1,23 @@ +package co.dfns.sdk.payins; + +import co.dfns.sdk.internal.DfnsHttpClient; +import co.dfns.sdk.payins.model.*; +import java.util.Map; + +public class PayinsClient { + private final DfnsHttpClient httpClient; + + public PayinsClient(DfnsHttpClient httpClient) { + this.httpClient = httpClient; + } + + /** Get Payin Recipient */ + public GetPayinRecipientResponse getPayinRecipient(GetPayinRecipientQuery query) { + return httpClient.get("/payins/recipients", query.toMap(), GetPayinRecipientResponse.class); + } + + /** Register Payin Recipient */ + public RegisterPayinRecipientResponse registerPayinRecipient(Object body) { + return httpClient.post("/payins/recipients", java.util.Map.of(), body, RegisterPayinRecipientResponse.class, true); + } +} diff --git a/src/main/java/co/dfns/sdk/payins/model/GetPayinRecipientQuery.java b/src/main/java/co/dfns/sdk/payins/model/GetPayinRecipientQuery.java new file mode 100644 index 0000000..e17fa5e --- /dev/null +++ b/src/main/java/co/dfns/sdk/payins/model/GetPayinRecipientQuery.java @@ -0,0 +1,33 @@ +package co.dfns.sdk.payins.model; + +import java.util.HashMap; +import java.util.Map; + +public class GetPayinRecipientQuery { + private String provider; + private String walletId; + private String currency; + + public GetPayinRecipientQuery provider(String provider) { + this.provider = provider; + return this; + } + + public GetPayinRecipientQuery walletId(String walletId) { + this.walletId = walletId; + return this; + } + + public GetPayinRecipientQuery currency(String currency) { + this.currency = currency; + return this; + } + + public Map toMap() { + Map map = new HashMap<>(); + if (provider != null) map.put("provider", String.valueOf(provider)); + if (walletId != null) map.put("walletId", String.valueOf(walletId)); + if (currency != null) map.put("currency", String.valueOf(currency)); + return map; + } +} diff --git a/src/main/java/co/dfns/sdk/payins/model/GetPayinRecipientResponse.java b/src/main/java/co/dfns/sdk/payins/model/GetPayinRecipientResponse.java new file mode 100644 index 0000000..c2554d0 --- /dev/null +++ b/src/main/java/co/dfns/sdk/payins/model/GetPayinRecipientResponse.java @@ -0,0 +1,15 @@ +package co.dfns.sdk.payins.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record GetPayinRecipientResponse( + @JsonProperty("provider") String provider, + @JsonProperty("walletId") String walletId, + @JsonProperty("currency") String currency, + @JsonProperty("status") String status, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("recipientAddressId") String recipientAddressId +) {} diff --git a/src/main/java/co/dfns/sdk/payins/model/RegisterPayinRecipientResponse.java b/src/main/java/co/dfns/sdk/payins/model/RegisterPayinRecipientResponse.java new file mode 100644 index 0000000..8684221 --- /dev/null +++ b/src/main/java/co/dfns/sdk/payins/model/RegisterPayinRecipientResponse.java @@ -0,0 +1,15 @@ +package co.dfns.sdk.payins.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record RegisterPayinRecipientResponse( + @JsonProperty("provider") String provider, + @JsonProperty("walletId") String walletId, + @JsonProperty("currency") String currency, + @JsonProperty("status") String status, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("recipientAddressId") String recipientAddressId +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/DelegatedVaultsAsyncClient.java b/src/main/java/co/dfns/sdk/vaults/DelegatedVaultsAsyncClient.java new file mode 100644 index 0000000..b57a369 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/DelegatedVaultsAsyncClient.java @@ -0,0 +1,117 @@ +package co.dfns.sdk.vaults; + +import co.dfns.sdk.internal.DfnsHttpClient; +import co.dfns.sdk.vaults.model.*; +import java.util.List; +import co.dfns.sdk.PaginatedList; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import co.dfns.sdk.auth.UserActionChallenge; +import co.dfns.sdk.auth.CredentialAssertion; + +public class DelegatedVaultsAsyncClient { + private final DfnsHttpClient httpClient; + + public DelegatedVaultsAsyncClient(DfnsHttpClient httpClient) { + this.httpClient = httpClient; + } + + /** List Vaults */ + public CompletableFuture> listVaults(ListVaultsQuery query) { + return httpClient.getAsync("/vaults", query.toMap(), new com.fasterxml.jackson.core.type.TypeReference>() {}); + } + + /** Delegated signing step 1 for Create Vault: returns the challenge to sign out-of-band. */ + public CompletableFuture createVaultInit(CreateVaultRequest body) { + return httpClient.createUserActionChallengeAsync("POST", "/vaults", body); + } + + /** Delegated signing step 2 for Create Vault: submits the signed challenge and issues the request. */ + public CompletableFuture createVaultComplete(CreateVaultRequest body, String challengeIdentifier, CredentialAssertion assertion) { + return httpClient.completeUserActionSigningAsync(challengeIdentifier, assertion) + .thenCompose(userAction -> httpClient.executeWithUserActionAsync("POST", "/vaults", java.util.Map.of(), body, Vault.class, userAction)); + } + + /** Delegated signing step 1 for Create Vault Address: returns the challenge to sign out-of-band. */ + public CompletableFuture createVaultAddressInit(String vaultId, CreateVaultAddressRequest body) { + return httpClient.createUserActionChallengeAsync("POST", "/vaults/" + vaultId + "/addresses", body); + } + + /** Delegated signing step 2 for Create Vault Address: submits the signed challenge and issues the request. */ + public CompletableFuture createVaultAddressComplete(String vaultId, CreateVaultAddressRequest body, String challengeIdentifier, CredentialAssertion assertion) { + return httpClient.completeUserActionSigningAsync(challengeIdentifier, assertion) + .thenCompose(userAction -> httpClient.executeWithUserActionAsync("POST", "/vaults/" + vaultId + "/addresses", java.util.Map.of(), body, VaultAddress.class, userAction)); + } + + /** Delegated signing step 1 for Create Vault Transfer: returns the challenge to sign out-of-band. */ + public CompletableFuture createVaultTransferInit(String vaultId, CreateVaultTransferRequest body) { + return httpClient.createUserActionChallengeAsync("POST", "/vaults/" + vaultId + "/transfers", body); + } + + /** Delegated signing step 2 for Create Vault Transfer: submits the signed challenge and issues the request. */ + public CompletableFuture createVaultTransferComplete(String vaultId, CreateVaultTransferRequest body, String challengeIdentifier, CredentialAssertion assertion) { + return httpClient.completeUserActionSigningAsync(challengeIdentifier, assertion) + .thenCompose(userAction -> httpClient.executeWithUserActionAsync("POST", "/vaults/" + vaultId + "/transfers", java.util.Map.of(), body, TransferRequest.class, userAction)); + } + + /** Get Vault */ + public CompletableFuture getVault(String vaultId) { + return httpClient.getAsync("/vaults/" + vaultId, java.util.Map.of(), Vault.class); + } + + /** Delegated signing step 1 for Update Vault: returns the challenge to sign out-of-band. */ + public CompletableFuture updateVaultInit(String vaultId, UpdateVaultRequest body) { + return httpClient.createUserActionChallengeAsync("PUT", "/vaults/" + vaultId, body); + } + + /** Delegated signing step 2 for Update Vault: submits the signed challenge and issues the request. */ + public CompletableFuture updateVaultComplete(String vaultId, UpdateVaultRequest body, String challengeIdentifier, CredentialAssertion assertion) { + return httpClient.completeUserActionSigningAsync(challengeIdentifier, assertion) + .thenCompose(userAction -> httpClient.executeWithUserActionAsync("PUT", "/vaults/" + vaultId, java.util.Map.of(), body, Vault.class, userAction)); + } + + /** List Vault Assets */ + public CompletableFuture listVaultAssets(String vaultId, ListVaultAssetsQuery query) { + return httpClient.getAsync("/vaults/" + vaultId + "/assets", query.toMap(), ListVaultAssetsResponse.class); + } + + /** List Vault Balances */ + public CompletableFuture> listVaultBalances(String vaultId, ListVaultBalancesQuery query) { + return httpClient.getAsync("/vaults/" + vaultId + "/balances", query.toMap(), new com.fasterxml.jackson.core.type.TypeReference>() {}); + } + + /** Delegated signing step 1 for Tag Vault: returns the challenge to sign out-of-band. */ + public CompletableFuture tagVaultInit(String vaultId, TagVaultRequest body) { + return httpClient.createUserActionChallengeAsync("PUT", "/vaults/" + vaultId + "/tags", body); + } + + /** Delegated signing step 2 for Tag Vault: submits the signed challenge and issues the request. */ + @SuppressWarnings("unchecked") + public CompletableFuture> tagVaultComplete(String vaultId, TagVaultRequest body, String challengeIdentifier, CredentialAssertion assertion) { + return httpClient.completeUserActionSigningAsync(challengeIdentifier, assertion) + .thenCompose(userAction -> httpClient.executeWithUserActionAsync("PUT", "/vaults/" + vaultId + "/tags", java.util.Map.of(), body, (Class>) (Class) Map.class, userAction)); + } + + /** Delegated signing step 1 for Untag Vault: returns the challenge to sign out-of-band. */ + public CompletableFuture untagVaultInit(String vaultId, UntagVaultRequest body) { + return httpClient.createUserActionChallengeAsync("DELETE", "/vaults/" + vaultId + "/tags", body); + } + + /** Delegated signing step 2 for Untag Vault: submits the signed challenge and issues the request. */ + @SuppressWarnings("unchecked") + public CompletableFuture> untagVaultComplete(String vaultId, UntagVaultRequest body, String challengeIdentifier, CredentialAssertion assertion) { + return httpClient.completeUserActionSigningAsync(challengeIdentifier, assertion) + .thenCompose(userAction -> httpClient.executeWithUserActionAsync("DELETE", "/vaults/" + vaultId + "/tags", java.util.Map.of(), body, (Class>) (Class) Map.class, userAction)); + } + + /** Delegated signing step 1 for Unquarantine: returns the challenge to sign out-of-band. */ + public CompletableFuture unquarantineInit(String vaultId, String quarantineId, UnquarantineRequest body) { + return httpClient.createUserActionChallengeAsync("DELETE", "/vaults/" + vaultId + "/quarantines/" + quarantineId, body); + } + + /** Delegated signing step 2 for Unquarantine: submits the signed challenge and issues the request. */ + public CompletableFuture unquarantineComplete(String vaultId, String quarantineId, UnquarantineRequest body, String challengeIdentifier, CredentialAssertion assertion) { + return httpClient.completeUserActionSigningAsync(challengeIdentifier, assertion) + .thenCompose(userAction -> httpClient.executeWithUserActionAsync("DELETE", "/vaults/" + vaultId + "/quarantines/" + quarantineId, java.util.Map.of(), body, UnquarantineResponse.class, userAction)); + } +} diff --git a/src/main/java/co/dfns/sdk/vaults/DelegatedVaultsClient.java b/src/main/java/co/dfns/sdk/vaults/DelegatedVaultsClient.java new file mode 100644 index 0000000..0a12751 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/DelegatedVaultsClient.java @@ -0,0 +1,116 @@ +package co.dfns.sdk.vaults; + +import co.dfns.sdk.internal.DfnsHttpClient; +import co.dfns.sdk.vaults.model.*; +import java.util.List; +import co.dfns.sdk.PaginatedList; +import java.util.Map; +import co.dfns.sdk.auth.UserActionChallenge; +import co.dfns.sdk.auth.CredentialAssertion; + +public class DelegatedVaultsClient { + private final DfnsHttpClient httpClient; + + public DelegatedVaultsClient(DfnsHttpClient httpClient) { + this.httpClient = httpClient; + } + + /** List Vaults */ + public PaginatedList listVaults(ListVaultsQuery query) { + return httpClient.get("/vaults", query.toMap(), new com.fasterxml.jackson.core.type.TypeReference>() {}); + } + + /** Delegated signing step 1 for Create Vault: returns the challenge to sign out-of-band. */ + public UserActionChallenge createVaultInit(CreateVaultRequest body) { + return httpClient.createUserActionChallenge("POST", "/vaults", body); + } + + /** Delegated signing step 2 for Create Vault: submits the signed challenge and issues the request. */ + public Vault createVaultComplete(CreateVaultRequest body, String challengeIdentifier, CredentialAssertion assertion) { + String userAction = httpClient.completeUserActionSigning(challengeIdentifier, assertion); + return httpClient.executeWithUserAction("POST", "/vaults", java.util.Map.of(), body, Vault.class, userAction); + } + + /** Delegated signing step 1 for Create Vault Address: returns the challenge to sign out-of-band. */ + public UserActionChallenge createVaultAddressInit(String vaultId, CreateVaultAddressRequest body) { + return httpClient.createUserActionChallenge("POST", "/vaults/" + vaultId + "/addresses", body); + } + + /** Delegated signing step 2 for Create Vault Address: submits the signed challenge and issues the request. */ + public VaultAddress createVaultAddressComplete(String vaultId, CreateVaultAddressRequest body, String challengeIdentifier, CredentialAssertion assertion) { + String userAction = httpClient.completeUserActionSigning(challengeIdentifier, assertion); + return httpClient.executeWithUserAction("POST", "/vaults/" + vaultId + "/addresses", java.util.Map.of(), body, VaultAddress.class, userAction); + } + + /** Delegated signing step 1 for Create Vault Transfer: returns the challenge to sign out-of-band. */ + public UserActionChallenge createVaultTransferInit(String vaultId, CreateVaultTransferRequest body) { + return httpClient.createUserActionChallenge("POST", "/vaults/" + vaultId + "/transfers", body); + } + + /** Delegated signing step 2 for Create Vault Transfer: submits the signed challenge and issues the request. */ + public TransferRequest createVaultTransferComplete(String vaultId, CreateVaultTransferRequest body, String challengeIdentifier, CredentialAssertion assertion) { + String userAction = httpClient.completeUserActionSigning(challengeIdentifier, assertion); + return httpClient.executeWithUserAction("POST", "/vaults/" + vaultId + "/transfers", java.util.Map.of(), body, TransferRequest.class, userAction); + } + + /** Get Vault */ + public Vault getVault(String vaultId) { + return httpClient.get("/vaults/" + vaultId, java.util.Map.of(), Vault.class); + } + + /** Delegated signing step 1 for Update Vault: returns the challenge to sign out-of-band. */ + public UserActionChallenge updateVaultInit(String vaultId, UpdateVaultRequest body) { + return httpClient.createUserActionChallenge("PUT", "/vaults/" + vaultId, body); + } + + /** Delegated signing step 2 for Update Vault: submits the signed challenge and issues the request. */ + public Vault updateVaultComplete(String vaultId, UpdateVaultRequest body, String challengeIdentifier, CredentialAssertion assertion) { + String userAction = httpClient.completeUserActionSigning(challengeIdentifier, assertion); + return httpClient.executeWithUserAction("PUT", "/vaults/" + vaultId, java.util.Map.of(), body, Vault.class, userAction); + } + + /** List Vault Assets */ + public ListVaultAssetsResponse listVaultAssets(String vaultId, ListVaultAssetsQuery query) { + return httpClient.get("/vaults/" + vaultId + "/assets", query.toMap(), ListVaultAssetsResponse.class); + } + + /** List Vault Balances */ + public PaginatedList listVaultBalances(String vaultId, ListVaultBalancesQuery query) { + return httpClient.get("/vaults/" + vaultId + "/balances", query.toMap(), new com.fasterxml.jackson.core.type.TypeReference>() {}); + } + + /** Delegated signing step 1 for Tag Vault: returns the challenge to sign out-of-band. */ + public UserActionChallenge tagVaultInit(String vaultId, TagVaultRequest body) { + return httpClient.createUserActionChallenge("PUT", "/vaults/" + vaultId + "/tags", body); + } + + /** Delegated signing step 2 for Tag Vault: submits the signed challenge and issues the request. */ + @SuppressWarnings("unchecked") + public Map tagVaultComplete(String vaultId, TagVaultRequest body, String challengeIdentifier, CredentialAssertion assertion) { + String userAction = httpClient.completeUserActionSigning(challengeIdentifier, assertion); + return httpClient.executeWithUserAction("PUT", "/vaults/" + vaultId + "/tags", java.util.Map.of(), body, (Class>) (Class) Map.class, userAction); + } + + /** Delegated signing step 1 for Untag Vault: returns the challenge to sign out-of-band. */ + public UserActionChallenge untagVaultInit(String vaultId, UntagVaultRequest body) { + return httpClient.createUserActionChallenge("DELETE", "/vaults/" + vaultId + "/tags", body); + } + + /** Delegated signing step 2 for Untag Vault: submits the signed challenge and issues the request. */ + @SuppressWarnings("unchecked") + public Map untagVaultComplete(String vaultId, UntagVaultRequest body, String challengeIdentifier, CredentialAssertion assertion) { + String userAction = httpClient.completeUserActionSigning(challengeIdentifier, assertion); + return httpClient.executeWithUserAction("DELETE", "/vaults/" + vaultId + "/tags", java.util.Map.of(), body, (Class>) (Class) Map.class, userAction); + } + + /** Delegated signing step 1 for Unquarantine: returns the challenge to sign out-of-band. */ + public UserActionChallenge unquarantineInit(String vaultId, String quarantineId, UnquarantineRequest body) { + return httpClient.createUserActionChallenge("DELETE", "/vaults/" + vaultId + "/quarantines/" + quarantineId, body); + } + + /** Delegated signing step 2 for Unquarantine: submits the signed challenge and issues the request. */ + public UnquarantineResponse unquarantineComplete(String vaultId, String quarantineId, UnquarantineRequest body, String challengeIdentifier, CredentialAssertion assertion) { + String userAction = httpClient.completeUserActionSigning(challengeIdentifier, assertion); + return httpClient.executeWithUserAction("DELETE", "/vaults/" + vaultId + "/quarantines/" + quarantineId, java.util.Map.of(), body, UnquarantineResponse.class, userAction); + } +} diff --git a/src/main/java/co/dfns/sdk/vaults/VaultsAsyncClient.java b/src/main/java/co/dfns/sdk/vaults/VaultsAsyncClient.java new file mode 100644 index 0000000..003cf89 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/VaultsAsyncClient.java @@ -0,0 +1,73 @@ +package co.dfns.sdk.vaults; + +import co.dfns.sdk.internal.DfnsHttpClient; +import co.dfns.sdk.vaults.model.*; +import java.util.List; +import co.dfns.sdk.PaginatedList; +import java.util.Map; +import java.util.concurrent.CompletableFuture; + +public class VaultsAsyncClient { + private final DfnsHttpClient httpClient; + + public VaultsAsyncClient(DfnsHttpClient httpClient) { + this.httpClient = httpClient; + } + + /** List Vaults */ + public CompletableFuture> listVaults(ListVaultsQuery query) { + return httpClient.getAsync("/vaults", query.toMap(), new com.fasterxml.jackson.core.type.TypeReference>() {}); + } + + /** Create Vault */ + public CompletableFuture createVault(CreateVaultRequest body) { + return httpClient.postAsync("/vaults", java.util.Map.of(), body, Vault.class, true); + } + + /** Create Vault Address */ + public CompletableFuture createVaultAddress(String vaultId, CreateVaultAddressRequest body) { + return httpClient.postAsync("/vaults/" + vaultId + "/addresses", java.util.Map.of(), body, VaultAddress.class, true); + } + + /** Create Vault Transfer */ + public CompletableFuture createVaultTransfer(String vaultId, CreateVaultTransferRequest body) { + return httpClient.postAsync("/vaults/" + vaultId + "/transfers", java.util.Map.of(), body, TransferRequest.class, true); + } + + /** Get Vault */ + public CompletableFuture getVault(String vaultId) { + return httpClient.getAsync("/vaults/" + vaultId, java.util.Map.of(), Vault.class); + } + + /** Update Vault */ + public CompletableFuture updateVault(String vaultId, UpdateVaultRequest body) { + return httpClient.putAsync("/vaults/" + vaultId, java.util.Map.of(), body, Vault.class, true); + } + + /** List Vault Assets */ + public CompletableFuture listVaultAssets(String vaultId, ListVaultAssetsQuery query) { + return httpClient.getAsync("/vaults/" + vaultId + "/assets", query.toMap(), ListVaultAssetsResponse.class); + } + + /** List Vault Balances */ + public CompletableFuture> listVaultBalances(String vaultId, ListVaultBalancesQuery query) { + return httpClient.getAsync("/vaults/" + vaultId + "/balances", query.toMap(), new com.fasterxml.jackson.core.type.TypeReference>() {}); + } + + /** Tag Vault */ + @SuppressWarnings("unchecked") + public CompletableFuture> tagVault(String vaultId, TagVaultRequest body) { + return httpClient.putAsync("/vaults/" + vaultId + "/tags", java.util.Map.of(), body, (Class>) (Class) Map.class, true); + } + + /** Untag Vault */ + @SuppressWarnings("unchecked") + public CompletableFuture> untagVault(String vaultId, UntagVaultRequest body) { + return httpClient.deleteAsync("/vaults/" + vaultId + "/tags", java.util.Map.of(), body, (Class>) (Class) Map.class, true); + } + + /** Unquarantine */ + public CompletableFuture unquarantine(String vaultId, String quarantineId, UnquarantineRequest body) { + return httpClient.deleteAsync("/vaults/" + vaultId + "/quarantines/" + quarantineId, java.util.Map.of(), body, UnquarantineResponse.class, true); + } +} diff --git a/src/main/java/co/dfns/sdk/vaults/VaultsClient.java b/src/main/java/co/dfns/sdk/vaults/VaultsClient.java new file mode 100644 index 0000000..c725dd5 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/VaultsClient.java @@ -0,0 +1,72 @@ +package co.dfns.sdk.vaults; + +import co.dfns.sdk.internal.DfnsHttpClient; +import co.dfns.sdk.vaults.model.*; +import java.util.List; +import co.dfns.sdk.PaginatedList; +import java.util.Map; + +public class VaultsClient { + private final DfnsHttpClient httpClient; + + public VaultsClient(DfnsHttpClient httpClient) { + this.httpClient = httpClient; + } + + /** List Vaults */ + public PaginatedList listVaults(ListVaultsQuery query) { + return httpClient.get("/vaults", query.toMap(), new com.fasterxml.jackson.core.type.TypeReference>() {}); + } + + /** Create Vault */ + public Vault createVault(CreateVaultRequest body) { + return httpClient.post("/vaults", java.util.Map.of(), body, Vault.class, true); + } + + /** Create Vault Address */ + public VaultAddress createVaultAddress(String vaultId, CreateVaultAddressRequest body) { + return httpClient.post("/vaults/" + vaultId + "/addresses", java.util.Map.of(), body, VaultAddress.class, true); + } + + /** Create Vault Transfer */ + public TransferRequest createVaultTransfer(String vaultId, CreateVaultTransferRequest body) { + return httpClient.post("/vaults/" + vaultId + "/transfers", java.util.Map.of(), body, TransferRequest.class, true); + } + + /** Get Vault */ + public Vault getVault(String vaultId) { + return httpClient.get("/vaults/" + vaultId, java.util.Map.of(), Vault.class); + } + + /** Update Vault */ + public Vault updateVault(String vaultId, UpdateVaultRequest body) { + return httpClient.put("/vaults/" + vaultId, java.util.Map.of(), body, Vault.class, true); + } + + /** List Vault Assets */ + public ListVaultAssetsResponse listVaultAssets(String vaultId, ListVaultAssetsQuery query) { + return httpClient.get("/vaults/" + vaultId + "/assets", query.toMap(), ListVaultAssetsResponse.class); + } + + /** List Vault Balances */ + public PaginatedList listVaultBalances(String vaultId, ListVaultBalancesQuery query) { + return httpClient.get("/vaults/" + vaultId + "/balances", query.toMap(), new com.fasterxml.jackson.core.type.TypeReference>() {}); + } + + /** Tag Vault */ + @SuppressWarnings("unchecked") + public Map tagVault(String vaultId, TagVaultRequest body) { + return httpClient.put("/vaults/" + vaultId + "/tags", java.util.Map.of(), body, (Class>) (Class) Map.class, true); + } + + /** Untag Vault */ + @SuppressWarnings("unchecked") + public Map untagVault(String vaultId, UntagVaultRequest body) { + return httpClient.delete("/vaults/" + vaultId + "/tags", java.util.Map.of(), body, (Class>) (Class) Map.class, true); + } + + /** Unquarantine */ + public UnquarantineResponse unquarantine(String vaultId, String quarantineId, UnquarantineRequest body) { + return httpClient.delete("/vaults/" + vaultId + "/quarantines/" + quarantineId, java.util.Map.of(), body, UnquarantineResponse.class, true); + } +} diff --git a/src/main/java/co/dfns/sdk/vaults/model/CreateVaultAddressRequest.java b/src/main/java/co/dfns/sdk/vaults/model/CreateVaultAddressRequest.java new file mode 100644 index 0000000..c3e912e --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/CreateVaultAddressRequest.java @@ -0,0 +1,9 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record CreateVaultAddressRequest( + @JsonProperty("network") String network +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/CreateVaultRequest.java b/src/main/java/co/dfns/sdk/vaults/model/CreateVaultRequest.java new file mode 100644 index 0000000..ad8cbd9 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/CreateVaultRequest.java @@ -0,0 +1,16 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; +import java.util.List; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record CreateVaultRequest( + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("name") String name, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("tags") List tags, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("externalId") String externalId +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/CreateVaultTransferRequest.java b/src/main/java/co/dfns/sdk/vaults/model/CreateVaultTransferRequest.java new file mode 100644 index 0000000..a0df3b0 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/CreateVaultTransferRequest.java @@ -0,0 +1,15 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record CreateVaultTransferRequest( + @JsonProperty("network") String network, + @JsonProperty("tid") String tid, + @JsonProperty("to") String to, + @JsonProperty("amount") String amount, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("externalId") String externalId +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/ListVaultAssetsQuery.java b/src/main/java/co/dfns/sdk/vaults/model/ListVaultAssetsQuery.java new file mode 100644 index 0000000..340ab36 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/ListVaultAssetsQuery.java @@ -0,0 +1,26 @@ +package co.dfns.sdk.vaults.model; + +import java.util.HashMap; +import java.util.Map; + +public class ListVaultAssetsQuery { + private Object showUnverified; + private String network; + + public ListVaultAssetsQuery showUnverified(Object showUnverified) { + this.showUnverified = showUnverified; + return this; + } + + public ListVaultAssetsQuery network(String network) { + this.network = network; + return this; + } + + public Map toMap() { + Map map = new HashMap<>(); + if (showUnverified != null) map.put("showUnverified", String.valueOf(showUnverified)); + if (network != null) map.put("network", String.valueOf(network)); + return map; + } +} diff --git a/src/main/java/co/dfns/sdk/vaults/model/ListVaultAssetsResponse.java b/src/main/java/co/dfns/sdk/vaults/model/ListVaultAssetsResponse.java new file mode 100644 index 0000000..cc0d4df --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/ListVaultAssetsResponse.java @@ -0,0 +1,11 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.List; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record ListVaultAssetsResponse( + @JsonProperty("items") List items, + @JsonProperty("netWorth") VaultNetWorth netWorth +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/ListVaultBalancesQuery.java b/src/main/java/co/dfns/sdk/vaults/model/ListVaultBalancesQuery.java new file mode 100644 index 0000000..a74b232 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/ListVaultBalancesQuery.java @@ -0,0 +1,47 @@ +package co.dfns.sdk.vaults.model; + +import java.util.HashMap; +import java.util.Map; + +public class ListVaultBalancesQuery { + private Long limit; + private String paginationToken; + private String kind; + private String network; + private String tid; + + public ListVaultBalancesQuery limit(Long limit) { + this.limit = limit; + return this; + } + + public ListVaultBalancesQuery paginationToken(String paginationToken) { + this.paginationToken = paginationToken; + return this; + } + + public ListVaultBalancesQuery kind(String kind) { + this.kind = kind; + return this; + } + + public ListVaultBalancesQuery network(String network) { + this.network = network; + return this; + } + + public ListVaultBalancesQuery tid(String tid) { + this.tid = tid; + return this; + } + + public Map toMap() { + Map map = new HashMap<>(); + if (limit != null) map.put("limit", String.valueOf(limit)); + if (paginationToken != null) map.put("paginationToken", String.valueOf(paginationToken)); + if (kind != null) map.put("kind", String.valueOf(kind)); + if (network != null) map.put("network", String.valueOf(network)); + if (tid != null) map.put("tid", String.valueOf(tid)); + return map; + } +} diff --git a/src/main/java/co/dfns/sdk/vaults/model/ListVaultsQuery.java b/src/main/java/co/dfns/sdk/vaults/model/ListVaultsQuery.java new file mode 100644 index 0000000..6acc3ba --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/ListVaultsQuery.java @@ -0,0 +1,26 @@ +package co.dfns.sdk.vaults.model; + +import java.util.HashMap; +import java.util.Map; + +public class ListVaultsQuery { + private Long limit; + private String paginationToken; + + public ListVaultsQuery limit(Long limit) { + this.limit = limit; + return this; + } + + public ListVaultsQuery paginationToken(String paginationToken) { + this.paginationToken = paginationToken; + return this; + } + + public Map toMap() { + Map map = new HashMap<>(); + if (limit != null) map.put("limit", String.valueOf(limit)); + if (paginationToken != null) map.put("paginationToken", String.valueOf(paginationToken)); + return map; + } +} diff --git a/src/main/java/co/dfns/sdk/vaults/model/Network.java b/src/main/java/co/dfns/sdk/vaults/model/Network.java new file mode 100644 index 0000000..9133576 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/Network.java @@ -0,0 +1,139 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; + +public enum Network { + Algorand("Algorand"), + AlgorandTestnet("AlgorandTestnet"), + Aptos("Aptos"), + AptosTestnet("AptosTestnet"), + ArbitrumOne("ArbitrumOne"), + ArbitrumSepolia("ArbitrumSepolia"), + ArcTestnet("ArcTestnet"), + AvalancheC("AvalancheC"), + AvalancheCFuji("AvalancheCFuji"), + BabylonGenesis("BabylonGenesis"), + BabylonTestnet5("BabylonTestnet5"), + Base("Base"), + BaseSepolia("BaseSepolia"), + Berachain("Berachain"), + BerachainBepolia("BerachainBepolia"), + Bitcoin("Bitcoin"), + BitcoinSignet("BitcoinSignet"), + BitcoinTestnet4("BitcoinTestnet4"), + BitcoinCash("BitcoinCash"), + Bob("Bob"), + BobSepolia("BobSepolia"), + Bsc("Bsc"), + BscTestnet("BscTestnet"), + Canton("Canton"), + CantonTestnet("CantonTestnet"), + Cardano("Cardano"), + CardanoPreprod("CardanoPreprod"), + Concordium("Concordium"), + ConcordiumTestnet("ConcordiumTestnet"), + Celo("Celo"), + CeloAlfajores("CeloAlfajores"), + Codex("Codex"), + CodexSepolia("CodexSepolia"), + CosmosHub4("CosmosHub4"), + CosmosIcsTestnet("CosmosIcsTestnet"), + Dogecoin("Dogecoin"), + DogecoinTestnet("DogecoinTestnet"), + Ethereum("Ethereum"), + EthereumClassic("EthereumClassic"), + EthereumClassicMordor("EthereumClassicMordor"), + EthereumSepolia("EthereumSepolia"), + EthereumHoodi("EthereumHoodi"), + FlareC("FlareC"), + FlareCCoston2("FlareCCoston2"), + FlowEvm("FlowEvm"), + FlowEvmTestnet("FlowEvmTestnet"), + Hedera("Hedera"), + HederaTestnet("HederaTestnet"), + Ink("Ink"), + InkSepolia("InkSepolia"), + InternetComputer("InternetComputer"), + Ion("Ion"), + IonTestnet("IonTestnet"), + Iota("Iota"), + IotaTestnet("IotaTestnet"), + Kusama("Kusama"), + KusamaAssetHub("KusamaAssetHub"), + Litecoin("Litecoin"), + LitecoinTestnet("LitecoinTestnet"), + Movement("Movement"), + MovementTestnet("MovementTestnet"), + Near("Near"), + NearTestnet("NearTestnet"), + Optimism("Optimism"), + OptimismSepolia("OptimismSepolia"), + Origyn("Origyn"), + Plasma("Plasma"), + PlasmaTestnet("PlasmaTestnet"), + Plume("Plume"), + PlumeSepolia("PlumeSepolia"), + Paseo("Paseo"), + PaseoAssetHub("PaseoAssetHub"), + Polkadot("Polkadot"), + PolkadotAssetHub("PolkadotAssetHub"), + Polygon("Polygon"), + PolygonAmoy("PolygonAmoy"), + Polymesh("Polymesh"), + PolymeshTestnet("PolymeshTestnet"), + Race("Race"), + RaceSepolia("RaceSepolia"), + Rayls("Rayls"), + RaylsTestnet("RaylsTestnet"), + Robinhood("Robinhood"), + RobinhoodSepolia("RobinhoodSepolia"), + SeiAtlantic2("SeiAtlantic2"), + SeiPacific1("SeiPacific1"), + Solana("Solana"), + SolanaDevnet("SolanaDevnet"), + Sonic("Sonic"), + SonicTestnet("SonicTestnet"), + Starknet("Starknet"), + StarknetSepolia("StarknetSepolia"), + Stellar("Stellar"), + StellarTestnet("StellarTestnet"), + Sui("Sui"), + SuiTestnet("SuiTestnet"), + Tezos("Tezos"), + TezosGhostnet("TezosGhostnet"), + TezosShadownet("TezosShadownet"), + Tempo("Tempo"), + TempoModerato("TempoModerato"), + Tsc("Tsc"), + TscTestnet1("TscTestnet1"), + Ton("Ton"), + TonTestnet("TonTestnet"), + Tron("Tron"), + TronNile("TronNile"), + Westend("Westend"), + WestendAssetHub("WestendAssetHub"), + Xdc("Xdc"), + XdcApothem("XdcApothem"), + XLayer("XLayer"), + XLayerSepolia("XLayerSepolia"), + XrpLedger("XrpLedger"), + XrpLedgerTestnet("XrpLedgerTestnet"), + UNKNOWN(null); + + + private final String value; + + Network(String value) { this.value = value; } + + @JsonValue + public String getValue() { return value; } + + @JsonCreator + public static Network fromValue(String value) { + for (Network e : values()) { + if (e.value != null && e.value.equals(value)) return e; + } + return UNKNOWN; + } +} diff --git a/src/main/java/co/dfns/sdk/vaults/model/Requester.java b/src/main/java/co/dfns/sdk/vaults/model/Requester.java new file mode 100644 index 0000000..c4c3c72 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/Requester.java @@ -0,0 +1,12 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record Requester( + @JsonProperty("userId") String userId, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("tokenId") String tokenId +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/TagVaultRequest.java b/src/main/java/co/dfns/sdk/vaults/model/TagVaultRequest.java new file mode 100644 index 0000000..8e7f948 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/TagVaultRequest.java @@ -0,0 +1,10 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.List; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record TagVaultRequest( + @JsonProperty("tags") List tags +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/TransferRequest.java b/src/main/java/co/dfns/sdk/vaults/model/TransferRequest.java new file mode 100644 index 0000000..197d676 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/TransferRequest.java @@ -0,0 +1,40 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; +import java.util.Map; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record TransferRequest( + @JsonProperty("id") String id, + @JsonProperty("walletId") String walletId, + @JsonProperty("network") Network network, + @JsonProperty("requester") Requester requester, + @JsonProperty("requestBody") Object requestBody, + @JsonProperty("metadata") Map metadata, + @JsonProperty("status") String status, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("reason") String reason, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("txHash") String txHash, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("fee") String fee, + @JsonProperty("dateRequested") String dateRequested, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("datePolicyResolved") String datePolicyResolved, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("dateBroadcasted") String dateBroadcasted, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("dateConfirmed") String dateConfirmed, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("approvalId") String approvalId, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("externalId") String externalId, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("feeSponsorId") String feeSponsorId, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("replacementId") String replacementId, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("details") Map details +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/UnquarantineRequest.java b/src/main/java/co/dfns/sdk/vaults/model/UnquarantineRequest.java new file mode 100644 index 0000000..bd12f1b --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/UnquarantineRequest.java @@ -0,0 +1,11 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record UnquarantineRequest( + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("reason") String reason +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/UnquarantineResponse.java b/src/main/java/co/dfns/sdk/vaults/model/UnquarantineResponse.java new file mode 100644 index 0000000..35b512f --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/UnquarantineResponse.java @@ -0,0 +1,9 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record UnquarantineResponse( + @JsonProperty("status") String status +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/UntagVaultRequest.java b/src/main/java/co/dfns/sdk/vaults/model/UntagVaultRequest.java new file mode 100644 index 0000000..9854bac --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/UntagVaultRequest.java @@ -0,0 +1,10 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.List; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record UntagVaultRequest( + @JsonProperty("tags") List tags +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/UpdateVaultRequest.java b/src/main/java/co/dfns/sdk/vaults/model/UpdateVaultRequest.java new file mode 100644 index 0000000..f973250 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/UpdateVaultRequest.java @@ -0,0 +1,13 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record UpdateVaultRequest( + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("name") String name, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("externalId") String externalId +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/Vault.java b/src/main/java/co/dfns/sdk/vaults/model/Vault.java new file mode 100644 index 0000000..8c73f1e --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/Vault.java @@ -0,0 +1,21 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; +import java.util.List; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record Vault( + @JsonProperty("id") String id, + @JsonProperty("orgId") String orgId, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("name") String name, + @JsonProperty("tags") List tags, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("externalId") String externalId, + @JsonProperty("dateCreated") String dateCreated, + @JsonProperty("dateUpdated") String dateUpdated, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("addresses") List addresses +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/VaultAddress.java b/src/main/java/co/dfns/sdk/vaults/model/VaultAddress.java new file mode 100644 index 0000000..d8d82cb --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/VaultAddress.java @@ -0,0 +1,11 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record VaultAddress( + @JsonProperty("walletId") String walletId, + @JsonProperty("network") String network, + @JsonProperty("address") String address +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/VaultAsset.java b/src/main/java/co/dfns/sdk/vaults/model/VaultAsset.java new file mode 100644 index 0000000..887e9ac --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/VaultAsset.java @@ -0,0 +1,23 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; +import java.util.Map; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record VaultAsset( + @JsonProperty("kind") String kind, + @JsonProperty("network") String network, + @JsonProperty("tid") String tid, + @JsonProperty("decimals") double decimals, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("symbol") String symbol, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("verified") Boolean verified, + @JsonProperty("availableBalance") String availableBalance, + @JsonProperty("quarantinedBalance") String quarantinedBalance, + @JsonProperty("lockedBalance") String lockedBalance, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("quotes") Map quotes +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/VaultBalanceEntry.java b/src/main/java/co/dfns/sdk/vaults/model/VaultBalanceEntry.java new file mode 100644 index 0000000..1fc54ba --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/VaultBalanceEntry.java @@ -0,0 +1,18 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonInclude; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record VaultBalanceEntry( + @JsonProperty("id") String id, + @JsonProperty("kind") String kind, + @JsonProperty("network") String network, + @JsonProperty("tid") String tid, + @JsonProperty("amount") String amount, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("transferId") String transferId, + @JsonInclude(JsonInclude.Include.NON_NULL) + @JsonProperty("quarantineId") String quarantineId +) {} diff --git a/src/main/java/co/dfns/sdk/vaults/model/VaultNetWorth.java b/src/main/java/co/dfns/sdk/vaults/model/VaultNetWorth.java new file mode 100644 index 0000000..9aa1359 --- /dev/null +++ b/src/main/java/co/dfns/sdk/vaults/model/VaultNetWorth.java @@ -0,0 +1,13 @@ +package co.dfns.sdk.vaults.model; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.Map; + +@JsonIgnoreProperties(ignoreUnknown = true) +public record VaultNetWorth( + @JsonProperty("available") Map available, + @JsonProperty("quarantined") Map quarantined, + @JsonProperty("locked") Map locked, + @JsonProperty("total") Map total +) {}