@imtbl/sdk 0.28.2 → 0.28.3

package/dist/index.js

@@ -33,10 +33,29 @@ var Environment$1;
 })(Environment$1 || (Environment$1 = {}));
 class ImmutableConfiguration {
     environment;
+    rateLimitingKey;
     apiKey;
+    clientAppId;
     constructor(options) {
         this.environment = options.environment;
-        this.apiKey = options.apiKey;
+        if (options.rateLimitingKey) {
+            this.rateLimitingKey = options.rateLimitingKey;
+            globalAxios$1.defaults.headers.common['x-api-key'] = this.rateLimitingKey;
+        }
+        if (options.apiKey) {
+            if (!options.apiKey.startsWith('sk_imapik-')) {
+                throw new Error('Invalid API key');
+            }
+            this.apiKey = options.apiKey;
+            globalAxios$1.defaults.headers.common['x-immutable-api-key'] = this.apiKey;
+        }
+        if (options.clientAppId) {
+            if (!options.clientAppId.startsWith('cai_imapik-')) {
+                throw new Error('Invalid Client App Id');
+            }
+            this.clientAppId = options.clientAppId;
+            globalAxios$1.defaults.headers.common['x-immutable-client-app-id'] = this.clientAppId;
+        }
     }
 }
 
@@ -3610,7 +3629,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.28.2' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.28.3' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3670,7 +3689,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.28.2',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.28.3',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4081,7 +4100,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.28.2',
+    sdkVersion: 'ts-immutable-sdk-0.28.3',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -9551,13 +9570,12 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, guar
             }),
             receiver: nftTransfer.receiver,
         }));
-        const getSignableTransferRequestV2 = {
-            sender_ether_key: ethAddress,
-            signable_requests: signableRequests,
-        };
         const headers = { Authorization: `Bearer ${user.accessToken}` };
         const signableResult = await transfersApi.getSignableTransfer({
-            getSignableTransferRequestV2,
+            getSignableTransferRequestV2: {
+                sender_ether_key: ethAddress,
+                signable_requests: signableRequests,
+            },
         }, { headers });
         await guardianClient.evaluateImxTransaction({
             user,
@@ -10338,36 +10356,19 @@ const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupAp
 
 const MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES = 30;
 const TRANSACTION_HASH_RETRIEVAL_WAIT = 1000;
-const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient, guardianClient, user, }) => guardianClient
-    .withConfirmationScreen({ width: 480, height: 520 })(async () => {
-    const transactionRequest = params[0];
-    if (!transactionRequest.to) {
-        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
-    }
-    const { chainId } = await jsonRpcProvider.ready;
-    const chainIdBigNumber = BigNumber$1.from(chainId);
-    const magicWeb3Provider = new Web3Provider(magicProvider);
-    const signer = magicWeb3Provider.getSigner();
-    const nonce = await getNonce(jsonRpcProvider, user.zkEvm.ethAddress);
-    const metaTransaction = {
-        to: transactionRequest.to,
-        data: transactionRequest.data,
-        nonce,
-        value: transactionRequest.value,
-        revertOnError: true,
-    };
+const getMetaTransactions = async (metaTransaction, nonce, chainId, walletAddress, signer, relayerClient) => {
     // NOTE: We sign the transaction before getting the fee options because
     // accurate estimation of a transaction gas cost is only possible if the smart
     // wallet contract can actually execute it (in a simulated environment) - and
     // it can only execute signed transactions.
-    const signedTransaction = await getSignedMetaTransactions([metaTransaction], nonce, chainIdBigNumber, user.zkEvm.ethAddress, signer);
+    const signedTransaction = await getSignedMetaTransactions([metaTransaction], nonce, chainId, walletAddress, signer);
     // TODO: ID-698 Add support for non-native gas payments (e.g ERC20, feeTransaction initialisation must change)
     // NOTE: "Fee Options" represent the multiple ways we could pay for the gas
     // used in this transaction. Each fee option has a "recipientAddress" we
     // should transfer the payment to, an amount and a currency. We choose one
     // option and build a transaction that sends the expected currency amount for
     // that option to the specified address.
-    const feeOptions = await relayerClient.imGetFeeOptions(user.zkEvm.ethAddress, signedTransaction);
+    const feeOptions = await relayerClient.imGetFeeOptions(walletAddress, signedTransaction);
     const imxFeeOption = feeOptions.find((feeOption) => feeOption.tokenSymbol === 'IMX');
     if (!imxFeeOption) {
         throw new Error('Failed to retrieve fees for IMX token');
@@ -10378,15 +10379,39 @@ const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient
         value: imxFeeOption.tokenPrice,
         revertOnError: true,
     };
+    if (BigNumber$1.from(feeMetaTransaction.value).isZero()) {
+        return [metaTransaction];
+    }
+    return [metaTransaction, feeMetaTransaction];
+};
+const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient, guardianClient, user, }) => guardianClient
+    .withConfirmationScreen({ width: 480, height: 520 })(async () => {
+    const transactionRequest = params[0];
+    if (!transactionRequest.to) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
+    }
+    const { chainId } = await jsonRpcProvider.ready;
+    const chainIdBigNumber = BigNumber$1.from(chainId);
+    const magicWeb3Provider = new Web3Provider(magicProvider);
+    const signer = magicWeb3Provider.getSigner();
+    const nonce = await getNonce(jsonRpcProvider, user.zkEvm.ethAddress);
+    const metaTransaction = {
+        to: transactionRequest.to,
+        data: transactionRequest.data,
+        nonce,
+        value: transactionRequest.value,
+        revertOnError: true,
+    };
+    const metaTransactions = await getMetaTransactions(metaTransaction, nonce, chainIdBigNumber, user.zkEvm.ethAddress, signer, relayerClient);
     await guardianClient.validateEVMTransaction({
         chainId: getEip155ChainId(chainId),
         nonce: convertBigNumberishToString(nonce),
         user,
-        metaTransactions: [metaTransaction, feeMetaTransaction],
+        metaTransactions,
     });
     // NOTE: We sign again because we now are adding the fee transaction, so the
     // whole payload is different and needs a new signature.
-    const signedTransactions = await getSignedMetaTransactions([metaTransaction, feeMetaTransaction], nonce, chainIdBigNumber, user.zkEvm.ethAddress, signer);
+    const signedTransactions = await getSignedMetaTransactions(metaTransactions, nonce, chainIdBigNumber, user.zkEvm.ethAddress, signer);
     const relayerId = await relayerClient.ethSendTransaction(user.zkEvm.ethAddress, signedTransactions);
     const retrieveRelayerTransaction = async () => {
         const tx = await relayerClient.imGetTransactionByHash(relayerId);
@@ -10725,19 +10750,9 @@ class Passport {
             passportEventEmitter: this.passportEventEmitter,
         });
     }
-    async signIn(options) {
-        const { useCachedSession = false } = options || {};
-        let user = await this.authManager.loginSilent();
-        if (!user && !useCachedSession) {
-            user = await this.authManager.login();
-        }
-        if (!user) {
-            return null;
-        }
-        return user.profile;
-    }
     /**
-     * @deprecated The method connectImx(useCachedSession) should be used instead
+     * @deprecated The method `login` with an argument of `{ useCachedSession: true }` should be used in conjunction with
+     * `connectImx` instead.
      */
     async connectImxSilent() {
         return this.passportImxProviderFactory.getProviderSilent();
@@ -10745,9 +10760,6 @@ class Passport {
     async connectImx() {
         return this.passportImxProviderFactory.getProvider();
     }
-    async loginWithDeviceFlow() {
-        return this.authManager.loginWithDeviceFlow();
-    }
     async connectImxDeviceFlow(deviceCode, interval, timeoutMs) {
         return this.passportImxProviderFactory.getProviderWithDeviceFlow(deviceCode, interval, timeoutMs);
     }
@@ -10779,6 +10791,25 @@ class Passport {
             multiRollupApiClients: this.multiRollupApiClients,
         });
     }
+    /**
+     *
+     * Initiates the authorisation flow.
+     *
+     * @param options.useCachedSession = false - If true, and no active session exists, then the user will not be
+     * prompted to log in and the Promise will resolve with a null value.
+     * @returns {Promise<UserProfile | null>} the user profile if the user is logged in, otherwise null
+     */
+    async login(options) {
+        const { useCachedSession = false } = options || {};
+        let user = await this.authManager.loginSilent();
+        if (!user && !useCachedSession) {
+            user = await this.authManager.login();
+        }
+        return user ? user.profile : null;
+    }
+    async loginWithDeviceFlow() {
+        return this.authManager.loginWithDeviceFlow();
+    }
     async loginCallback() {
         return this.authManager.loginCallback();
     }
@@ -12641,6 +12672,8 @@ async function getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi
     return {
         operator_signature: response.data.operator_signature,
         payload_hash: response.data.payload_hash,
+        readable_transaction: response.data.readable_transaction,
+        verification_signature: response.data.verification_signature,
     };
 }
 
@@ -33532,7 +33565,7 @@ var $045213b18e9f1f94$export$75be0f6af9650f2c;
 })($045213b18e9f1f94$export$75be0f6af9650f2c || ($045213b18e9f1f94$export$75be0f6af9650f2c = {}));
 
 
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.28.2";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.28.3";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/orderbook.d.ts

@@ -5,10 +5,14 @@ declare enum Environment {
 }
 declare class ImmutableConfiguration {
     readonly environment: Environment;
+    readonly rateLimitingKey?: string;
     readonly apiKey?: string;
+    readonly clientAppId?: string;
     constructor(options: {
         environment: Environment;
+        rateLimitingKey?: string;
         apiKey?: string;
+        clientAppId?: string;
     });
 }
 interface ModuleConfiguration<T> {