@owney/sdk 0.7.26-beta.3 → 0.7.26-beta.4

package/dist/index.cjs

@@ -2309,6 +2309,21 @@ function createSwapApi(baseUrl, apiKey) {
      * Already filtered server-side to what a quote will accept, so anything
      * returned here can be paid with.
      */
+    /**
+     * Tokens the wallet holds on one chain.
+     *
+     * Already filtered upstream to non-zero balances of tokens the routing API
+     * would quote — 1inch answers with every token it knows about, zeros
+     * included, and the curation that decides what is offerable lives there.
+     */
+    walletBalances: (params) => request(
+      baseUrl,
+      apiKey,
+      `/balances?${new URLSearchParams({
+        chainId: String(params.chainId),
+        walletAddress: params.walletAddress
+      })}`
+    ),
     searchTokens: (params) => request(
       baseUrl,
       apiKey,
@@ -4712,6 +4727,39 @@ var OwneySDK = class {
   async getSwapTokens() {
     return this.swapApi().listTokens();
   }
+  /**
+   * What the wallet actually holds, across every supported chain, restricted
+   * to tokens a swap could use.
+   *
+   * `getSwapTokens` answers "what may someone pay with in principle" from a
+   * fixed list. This answers "what has this wallet got", which is a different
+   * question and the one a picker needs: a user can hold something routable —
+   * tBTC, say — that no fixed list of ours would ever mention.
+   *
+   * Each chain is asked separately because that is how the balance product is
+   * shaped, and a chain that fails contributes nothing rather than failing the
+   * lot. A picker with two chains in it beats an error. (ROUT-242)
+   */
+  async getWalletBalances(chainIds) {
+    const state = this.requireState();
+    const chains = chainIds ?? SUPPORTED_CHAIN_IDS;
+    const failedChainIds = [];
+    const results = await Promise.all(
+      chains.map(async (chainId) => {
+        try {
+          const { tokens } = await this.swapApi().walletBalances({
+            chainId,
+            walletAddress: state.walletAddress
+          });
+          return tokens.map((token) => ({ ...token, chainId }));
+        } catch {
+          failedChainIds.push(chainId);
+          return [];
+        }
+      })
+    );
+    return { tokens: results.flat(), failedChainIds };
+  }
   /**
    * Search the assets a user may pay with, across every supported chain.
    *

package/dist/index.d.cts

@@ -54,6 +54,26 @@ type SwapChainTokens = {
  * the bulk list does, and the extra fields are the ones a picker needs to let
  * someone choose safely between three tokens all called PEPE.
  */
+/**
+ * A token the wallet actually holds, as the Pay with picker needs it.
+ *
+ * The picker used to read a fixed list of (token, chain) pairs, so it could
+ * only ever offer those. This is the other direction — what is really there —
+ * already intersected server-side with what the routing API would quote, so
+ * every row can be acted on. (ROUT-242)
+ */
+type SwapWalletBalance = {
+    readonly symbol: string;
+    readonly address: `0x${string}`;
+    readonly decimals: number;
+    readonly chainId: number;
+    readonly name?: string;
+    readonly logoURI?: string;
+    readonly tags?: readonly string[];
+    readonly isNative?: true;
+    /** Smallest unit, as a decimal string. */
+    readonly balance: string;
+};
 type SwapTokenSearchResult = SwapTokenInfo & {
     readonly chainId: number;
     readonly name?: string;
@@ -925,6 +945,24 @@ declare class OwneySDK {
     getSwapTokens(): Promise<{
         chains: SwapChainTokens[];
     }>;
+    /**
+     * What the wallet actually holds, across every supported chain, restricted
+     * to tokens a swap could use.
+     *
+     * `getSwapTokens` answers "what may someone pay with in principle" from a
+     * fixed list. This answers "what has this wallet got", which is a different
+     * question and the one a picker needs: a user can hold something routable —
+     * tBTC, say — that no fixed list of ours would ever mention.
+     *
+     * Each chain is asked separately because that is how the balance product is
+     * shaped, and a chain that fails contributes nothing rather than failing the
+     * lot. A picker with two chains in it beats an error. (ROUT-242)
+     */
+    getWalletBalances(chainIds?: readonly number[]): Promise<{
+        tokens: SwapWalletBalance[];
+        /** Chains that could not be read, so the caller can say so or retry. */
+        failedChainIds: number[];
+    }>;
     /**
      * Search the assets a user may pay with, across every supported chain.
      *

package/dist/index.d.ts

@@ -54,6 +54,26 @@ type SwapChainTokens = {
  * the bulk list does, and the extra fields are the ones a picker needs to let
  * someone choose safely between three tokens all called PEPE.
  */
+/**
+ * A token the wallet actually holds, as the Pay with picker needs it.
+ *
+ * The picker used to read a fixed list of (token, chain) pairs, so it could
+ * only ever offer those. This is the other direction — what is really there —
+ * already intersected server-side with what the routing API would quote, so
+ * every row can be acted on. (ROUT-242)
+ */
+type SwapWalletBalance = {
+    readonly symbol: string;
+    readonly address: `0x${string}`;
+    readonly decimals: number;
+    readonly chainId: number;
+    readonly name?: string;
+    readonly logoURI?: string;
+    readonly tags?: readonly string[];
+    readonly isNative?: true;
+    /** Smallest unit, as a decimal string. */
+    readonly balance: string;
+};
 type SwapTokenSearchResult = SwapTokenInfo & {
     readonly chainId: number;
     readonly name?: string;
@@ -925,6 +945,24 @@ declare class OwneySDK {
     getSwapTokens(): Promise<{
         chains: SwapChainTokens[];
     }>;
+    /**
+     * What the wallet actually holds, across every supported chain, restricted
+     * to tokens a swap could use.
+     *
+     * `getSwapTokens` answers "what may someone pay with in principle" from a
+     * fixed list. This answers "what has this wallet got", which is a different
+     * question and the one a picker needs: a user can hold something routable —
+     * tBTC, say — that no fixed list of ours would ever mention.
+     *
+     * Each chain is asked separately because that is how the balance product is
+     * shaped, and a chain that fails contributes nothing rather than failing the
+     * lot. A picker with two chains in it beats an error. (ROUT-242)
+     */
+    getWalletBalances(chainIds?: readonly number[]): Promise<{
+        tokens: SwapWalletBalance[];
+        /** Chains that could not be read, so the caller can say so or retry. */
+        failedChainIds: number[];
+    }>;
     /**
      * Search the assets a user may pay with, across every supported chain.
      *

package/dist/index.js

@@ -2275,6 +2275,21 @@ function createSwapApi(baseUrl, apiKey) {
      * Already filtered server-side to what a quote will accept, so anything
      * returned here can be paid with.
      */
+    /**
+     * Tokens the wallet holds on one chain.
+     *
+     * Already filtered upstream to non-zero balances of tokens the routing API
+     * would quote — 1inch answers with every token it knows about, zeros
+     * included, and the curation that decides what is offerable lives there.
+     */
+    walletBalances: (params) => request(
+      baseUrl,
+      apiKey,
+      `/balances?${new URLSearchParams({
+        chainId: String(params.chainId),
+        walletAddress: params.walletAddress
+      })}`
+    ),
     searchTokens: (params) => request(
       baseUrl,
       apiKey,
@@ -4689,6 +4704,39 @@ var OwneySDK = class {
   async getSwapTokens() {
     return this.swapApi().listTokens();
   }
+  /**
+   * What the wallet actually holds, across every supported chain, restricted
+   * to tokens a swap could use.
+   *
+   * `getSwapTokens` answers "what may someone pay with in principle" from a
+   * fixed list. This answers "what has this wallet got", which is a different
+   * question and the one a picker needs: a user can hold something routable —
+   * tBTC, say — that no fixed list of ours would ever mention.
+   *
+   * Each chain is asked separately because that is how the balance product is
+   * shaped, and a chain that fails contributes nothing rather than failing the
+   * lot. A picker with two chains in it beats an error. (ROUT-242)
+   */
+  async getWalletBalances(chainIds) {
+    const state = this.requireState();
+    const chains = chainIds ?? SUPPORTED_CHAIN_IDS;
+    const failedChainIds = [];
+    const results = await Promise.all(
+      chains.map(async (chainId) => {
+        try {
+          const { tokens } = await this.swapApi().walletBalances({
+            chainId,
+            walletAddress: state.walletAddress
+          });
+          return tokens.map((token) => ({ ...token, chainId }));
+        } catch {
+          failedChainIds.push(chainId);
+          return [];
+        }
+      })
+    );
+    return { tokens: results.flat(), failedChainIds };
+  }
   /**
    * Search the assets a user may pay with, across every supported chain.
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owney/sdk",
-  "version": "0.7.26-beta.3",
+  "version": "0.7.26-beta.4",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",