@p2pdotme/sdk 1.0.5 → 1.1.0

package/dist/profile.mjs

@@ -31,6 +31,381 @@ var orderFlowFacetAbi = [
     ],
     stateMutability: "view",
     type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "string", name: "_pubKey", type: "string" },
+      { internalType: "uint256", name: "_amount", type: "uint256" },
+      { internalType: "address", name: "_recipientAddr", type: "address" },
+      { internalType: "uint8", name: "_orderType", type: "uint8" },
+      { internalType: "string", name: "_userUpi", type: "string" },
+      { internalType: "string", name: "_userPubKey", type: "string" },
+      { internalType: "bytes32", name: "_currency", type: "bytes32" },
+      { internalType: "uint256", name: "preferredPaymentChannelConfigId", type: "uint256" },
+      { internalType: "uint256", name: "_circleId", type: "uint256" },
+      { internalType: "uint256", name: "_fiatAmountLimit", type: "uint256" }
+    ],
+    name: "placeOrder",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_orderId", type: "uint256" }],
+    name: "cancelOrder",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "_orderId", type: "uint256" },
+      { internalType: "string", name: "_userEncUpi", type: "string" },
+      { internalType: "uint256", name: "_updatedAmount", type: "uint256" }
+    ],
+    name: "setSellOrderUpi",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    type: "event",
+    name: "OrderPlaced",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      { indexed: true, name: "user", type: "address" },
+      { indexed: true, name: "merchant", type: "address" },
+      { indexed: false, name: "amount", type: "uint256" },
+      { indexed: false, name: "orderType", type: "uint8" },
+      { indexed: false, name: "placedTimestamp", type: "uint256" },
+      {
+        indexed: false,
+        name: "_order",
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
+          {
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
+          },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "OrderAccepted",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      { indexed: true, name: "merchant", type: "address" },
+      { indexed: false, name: "pubKey", type: "string" },
+      {
+        indexed: false,
+        name: "_order",
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
+          {
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
+          },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "BuyOrderPaid",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      { indexed: true, name: "user", type: "address" },
+      {
+        indexed: false,
+        name: "_order",
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
+          {
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
+          },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "OrderCompleted",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      { indexed: true, name: "user", type: "address" },
+      { indexed: false, name: "completedTimestamp", type: "uint256" },
+      {
+        indexed: false,
+        name: "_order",
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
+          {
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
+          },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "CancelledOrders",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "orderId", type: "uint256" },
+      {
+        indexed: false,
+        name: "_order",
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
+          {
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
+          },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  }
+];
+
+// src/contracts/abis/order-processor-facet.ts
+var orderProcessorFacetAbi = [
+  {
+    type: "function",
+    name: "getOrdersById",
+    stateMutability: "view",
+    inputs: [{ name: "orderId", type: "uint256" }],
+    outputs: [
+      {
+        type: "tuple",
+        components: [
+          { name: "amount", type: "uint256" },
+          { name: "fiatAmount", type: "uint256" },
+          { name: "placedTimestamp", type: "uint256" },
+          { name: "completedTimestamp", type: "uint256" },
+          { name: "userCompletedTimestamp", type: "uint256" },
+          { name: "acceptedMerchant", type: "address" },
+          { name: "user", type: "address" },
+          { name: "recipientAddr", type: "address" },
+          { name: "pubkey", type: "string" },
+          { name: "encUpi", type: "string" },
+          { name: "userCompleted", type: "bool" },
+          { name: "status", type: "uint8" },
+          { name: "orderType", type: "uint8" },
+          {
+            name: "disputeInfo",
+            type: "tuple",
+            components: [
+              { name: "raisedBy", type: "uint8" },
+              { name: "status", type: "uint8" },
+              { name: "redactTransId", type: "uint256" },
+              { name: "accountNumber", type: "uint256" }
+            ]
+          },
+          { name: "id", type: "uint256" },
+          { name: "userPubKey", type: "string" },
+          { name: "encMerchantUpi", type: "string" },
+          { name: "acceptedAccountNo", type: "uint256" },
+          { name: "assignedAccountNos", type: "uint256[]" },
+          { name: "currency", type: "bytes32" },
+          { name: "preferredPaymentChannelConfigId", type: "uint256" },
+          { name: "circleId", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getAdditionalOrderDetails",
+    stateMutability: "view",
+    inputs: [{ name: "orderId", type: "uint256" }],
+    outputs: [
+      {
+        type: "tuple",
+        components: [
+          { name: "fixedFeePaid", type: "uint64" },
+          { name: "tipsPaid", type: "uint64" },
+          { name: "acceptedTimestamp", type: "uint128" },
+          { name: "paidTimestamp", type: "uint128" },
+          { name: "reserved2", type: "uint128" },
+          { name: "actualUsdtAmount", type: "uint256" },
+          { name: "actualFiatAmount", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getSmallOrderThreshold",
+    stateMutability: "view",
+    inputs: [{ name: "currency", type: "bytes32" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "getSmallOrderFixedFee",
+    stateMutability: "view",
+    inputs: [{ name: "currency", type: "bytes32" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "raiseDispute",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "_orderId", type: "uint256" },
+      { name: "redactTransId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "paidBuyOrder",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "_orderId", type: "uint256" }],
+    outputs: []
   }
 ];
 
@@ -306,11 +681,16 @@ var reputationManagerAbi = [
 ];
 
 // src/contracts/abis/index.ts
-var DIAMOND_ABI = [...orderFlowFacetAbi, ...p2pConfigFacetAbi];
+var DIAMOND_ABI = [
+  ...orderFlowFacetAbi,
+  ...orderProcessorFacetAbi,
+  ...p2pConfigFacetAbi
+];
 var ABIS = {
   DIAMOND: DIAMOND_ABI,
   FACETS: {
     ORDER_FLOW: orderFlowFacetAbi,
+    ORDER_PROCESSOR: orderProcessorFacetAbi,
     CONFIG: p2pConfigFacetAbi
   },
   EXTERNAL: {
@@ -320,6 +700,9 @@ var ABIS = {
 };
 
 // src/contracts/order-flow/index.ts
+import { ResultAsync as ResultAsync2 } from "neverthrow";
+
+// src/lib/subgraph.ts
 import { ResultAsync } from "neverthrow";
 
 // src/validation/errors.validation.ts
@@ -341,7 +724,7 @@ import { err, ok } from "neverthrow";
 import { isAddress } from "viem";
 import { z } from "zod";
 
-// src/constants/currencies.constant.ts
+// src/country/currency.ts
 var CURRENCY = {
   IDR: "IDR",
   INR: "INR",
@@ -354,10 +737,11 @@ var CURRENCY = {
   USD: "USD",
   COP: "COP"
 };
+var CURRENCY_CODES = Object.values(CURRENCY);
 
 // src/validation/schemas.validation.ts
 var ZodAddressSchema = z.string().refine((s) => isAddress(s), { message: "Invalid Ethereum address" });
-var ZodCurrencySchema = z.enum(Object.values(CURRENCY));
+var ZodCurrencySchema = z.enum(CURRENCY_CODES);
 function validate(schema, data, toError) {
   const result = schema.safeParse(data);
   if (result.success) {
@@ -366,7 +750,7 @@ function validate(schema, data, toError) {
   return err(toError(z.prettifyError(result.error), result.error, data));
 }
 
-// src/order-routing/validation.ts
+// src/orders/internal/routing/validation.ts
 import { z as z2 } from "zod";
 var ZodCircleScoreStateSchema = z2.object({
   activeMerchantsCount: z2.coerce.number()
@@ -402,54 +786,47 @@ var ZodSelectCircleParamsSchema = z2.object({
   preferredPCConfigId: z2.bigint()
 });
 
-// src/contracts/p2p-config/index.ts
-import { ResultAsync as ResultAsync2 } from "neverthrow";
+// src/contracts/order-processor/index.ts
+import { ResultAsync as ResultAsync3 } from "neverthrow";
 import { stringToHex } from "viem";
 
-// src/profile/errors.ts
-var ProfileError = class extends SdkError {
+// src/contracts/p2p-config/index.ts
+import { ResultAsync as ResultAsync4 } from "neverthrow";
+import { stringToHex as stringToHex2 } from "viem";
+
+// src/prices/errors.ts
+var PricesError = class extends SdkError {
   constructor(message, options) {
     super(message, options);
-    this.name = "ProfileError";
+    this.name = "PricesError";
   }
 };
 
-// src/profile/validation.ts
+// src/prices/validation.ts
 import { z as z3 } from "zod";
-var ZodUsdcBalanceParamsSchema = z3.object({
-  address: ZodAddressSchema
-});
-var ZodGetBalancesParamsSchema = z3.object({
-  address: ZodAddressSchema,
-  currency: ZodCurrencySchema
-});
-var ZodTxLimitsParamsSchema = z3.object({
-  address: ZodAddressSchema,
-  currency: ZodCurrencySchema
-});
-var ZodPriceConfigParamsSchema = z3.object({
+var ZodCurrencyScopedParamsSchema = z3.object({
   currency: ZodCurrencySchema
 });
 
 // src/contracts/p2p-config/index.ts
 function getPriceConfig(publicClient, diamondAddress, params) {
   return validate(
-    ZodPriceConfigParamsSchema,
+    ZodCurrencyScopedParamsSchema,
     params,
-    (message, cause, data) => new ProfileError(message, {
+    (message, cause, data) => new PricesError(message, {
       code: "VALIDATION_ERROR",
       cause,
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => ResultAsync2.fromPromise(
+    (validated) => ResultAsync4.fromPromise(
       publicClient.readContract({
         address: diamondAddress,
         abi: ABIS.FACETS.CONFIG,
         functionName: "getPriceConfig",
-        args: [stringToHex(validated.currency, { size: 32 })]
+        args: [stringToHex2(validated.currency, { size: 32 })]
       }),
-      (error) => new ProfileError("Failed to read price config", {
+      (error) => new PricesError("Failed to read price config", {
         code: "CONTRACT_READ_ERROR",
         cause: error,
         context: { currency: validated.currency, diamondAddress }
@@ -535,8 +912,35 @@ var ZodZkPassportRegisterParamsSchema = z4.object({
 });
 
 // src/contracts/tx-limits/index.ts
-import { ResultAsync as ResultAsync3 } from "neverthrow";
-import { formatUnits, stringToHex as stringToHex2 } from "viem";
+import { ResultAsync as ResultAsync5 } from "neverthrow";
+import { formatUnits, stringToHex as stringToHex3 } from "viem";
+
+// src/profile/errors.ts
+var ProfileError = class extends SdkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ProfileError";
+  }
+};
+
+// src/profile/validation.ts
+import { z as z5 } from "zod";
+var ZodUsdcBalanceParamsSchema = z5.object({
+  address: ZodAddressSchema
+});
+var ZodUsdcAllowanceParamsSchema = z5.object({
+  owner: ZodAddressSchema
+});
+var ZodGetBalancesParamsSchema = z5.object({
+  address: ZodAddressSchema,
+  currency: ZodCurrencySchema
+});
+var ZodTxLimitsParamsSchema = z5.object({
+  address: ZodAddressSchema,
+  currency: ZodCurrencySchema
+});
+
+// src/contracts/tx-limits/index.ts
 function getTxLimits(publicClient, diamondAddress, params) {
   return validate(
     ZodTxLimitsParamsSchema,
@@ -547,12 +951,12 @@ function getTxLimits(publicClient, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => ResultAsync3.fromPromise(
+    (validated) => ResultAsync5.fromPromise(
       publicClient.readContract({
         address: diamondAddress,
         abi: ABIS.FACETS.ORDER_FLOW,
         functionName: "userTxLimit",
-        args: [validated.address, stringToHex2(validated.currency, { size: 32 })]
+        args: [validated.address, stringToHex3(validated.currency, { size: 32 })]
       }),
       (error) => new ProfileError("Failed to read tx limits", {
         code: "CONTRACT_READ_ERROR",
@@ -565,9 +969,13 @@ function getTxLimits(publicClient, diamondAddress, params) {
     }))
   );
 }
-function getRpPerUsdtLimitRational(publicClient, diamondAddress, params) {
+
+// src/contracts/usdc/index.ts
+import { ResultAsync as ResultAsync6 } from "neverthrow";
+import { erc20Abi as erc20Abi2 } from "viem";
+function getUsdcBalance(publicClient, usdcAddress, params) {
   return validate(
-    ZodPriceConfigParamsSchema,
+    ZodUsdcBalanceParamsSchema,
     params,
     (message, cause, data) => new ProfileError(message, {
       code: "VALIDATION_ERROR",
@@ -575,31 +983,24 @@ function getRpPerUsdtLimitRational(publicClient, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => ResultAsync3.fromPromise(
+    (validated) => ResultAsync6.fromPromise(
       publicClient.readContract({
-        address: diamondAddress,
-        abi: ABIS.DIAMOND,
-        functionName: "getRpPerUsdtLimitRational",
-        args: [stringToHex2(validated.currency, { size: 32 })]
+        address: usdcAddress,
+        abi: ABIS.EXTERNAL.USDC,
+        functionName: "balanceOf",
+        args: [validated.address]
       }),
-      (error) => new ProfileError("Failed to read RP per USDT limit rational", {
+      (error) => new ProfileError("Failed to read USDC balance", {
         code: "CONTRACT_READ_ERROR",
         cause: error,
-        context: { currency: validated.currency, diamondAddress }
+        context: { address: validated.address, usdcAddress }
       })
-    ).map(([numerator, denominator]) => ({
-      numerator,
-      denominator,
-      multiplier: numerator > 0n ? Number(denominator) / Number(numerator) : 0
-    }))
+    )
   );
 }
-
-// src/contracts/usdc/index.ts
-import { ResultAsync as ResultAsync4 } from "neverthrow";
-function getUsdcBalance(publicClient, usdcAddress, params) {
+function getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params) {
   return validate(
-    ZodUsdcBalanceParamsSchema,
+    ZodUsdcAllowanceParamsSchema,
     params,
     (message, cause, data) => new ProfileError(message, {
       code: "VALIDATION_ERROR",
@@ -607,24 +1008,24 @@ function getUsdcBalance(publicClient, usdcAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => ResultAsync4.fromPromise(
+    (validated) => ResultAsync6.fromPromise(
       publicClient.readContract({
         address: usdcAddress,
-        abi: ABIS.EXTERNAL.USDC,
-        functionName: "balanceOf",
-        args: [validated.address]
+        abi: erc20Abi2,
+        functionName: "allowance",
+        args: [validated.owner, diamondAddress]
       }),
-      (error) => new ProfileError("Failed to read USDC balance", {
+      (error) => new ProfileError("Failed to read USDC allowance", {
         code: "CONTRACT_READ_ERROR",
         cause: error,
-        context: { address: validated.address, usdcAddress }
+        context: { owner: validated.owner, usdcAddress, diamondAddress }
       })
     )
   );
 }
 
 // src/profile/contracts/actions.ts
-import { ResultAsync as ResultAsync5 } from "neverthrow";
+import { ResultAsync as ResultAsync7 } from "neverthrow";
 import { formatUnits as formatUnits2 } from "viem";
 function getBalances(publicClient, usdcAddress, diamondAddress, params) {
   return validate(
@@ -636,13 +1037,19 @@ function getBalances(publicClient, usdcAddress, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => ResultAsync5.combine([
+    (validated) => ResultAsync7.combine([
       getUsdcBalance(publicClient, usdcAddress, {
         address: validated.address
       }),
       getPriceConfig(publicClient, diamondAddress, {
         currency: validated.currency
-      })
+      }).mapErr(
+        (cause) => new ProfileError("Failed to read price config for balance conversion", {
+          code: "CONTRACT_READ_ERROR",
+          cause,
+          context: { currency: validated.currency }
+        })
+      )
     ]).map(([usdc, priceConfig]) => {
       const usdcFormatted = Number(formatUnits2(usdc, 6));
       const sellPriceFormatted = Number(formatUnits2(priceConfig.sellPrice, 6));
@@ -660,10 +1067,9 @@ function createProfile(config) {
   const { publicClient, diamondAddress, usdcAddress } = config;
   return {
     getUsdcBalance: (params) => getUsdcBalance(publicClient, usdcAddress, params),
-    getPriceConfig: (params) => getPriceConfig(publicClient, diamondAddress, params),
+    getUsdcAllowance: (params) => getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params),
     getBalances: (params) => getBalances(publicClient, usdcAddress, diamondAddress, params),
-    getTxLimits: (params) => getTxLimits(publicClient, diamondAddress, params),
-    getRpPerUsdtLimitRational: (params) => getRpPerUsdtLimitRational(publicClient, diamondAddress, params)
+    getTxLimits: (params) => getTxLimits(publicClient, diamondAddress, params)
   };
 }
 export {