@imtbl/x-provider 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/browser/index.js

@@ -2,1532 +2,11 @@ import { imx } from '@imtbl/generated-clients';
 import { convertToSignableToken, signRaw, signMessage } from '@imtbl/toolkit';
 import { ImxConfiguration, Contracts, EncodingApi, MintsApi, signRegisterEthAddress } from '@imtbl/x-client';
 import { isAxiosError } from 'axios';
-import * as encUtils from 'enc-utils';
+import * as N from 'enc-utils';
 import { parseUnits, BrowserProvider } from 'ethers';
-import detectEthereumProvider from '@metamask/detect-provider';
+import ft from '@metamask/detect-provider';
 import { Environment } from '@imtbl/config';
 
-// src/signable-actions/transfer.ts
+function Ue(t,e){return t===e.ethConfiguration.chainID}async function l(t,e){let r=(await t.provider?.getNetwork())?.chainId;if(!Ue(Number(r),e))throw new Error("The wallet used for this operation is not connected to the correct network.")}async function Y({signers:{ethSigner:t,starkSigner:e},request:r,config:n}){await l(t,n.immutableXConfig);let a=await t.getAddress(),i=new imx.TransfersApi(n.immutableXConfig.apiConfiguration),s=r.type==="ERC721"?"1":r.amount,o=await i.getSignableTransferV1({getSignableTransferRequest:{sender:a,token:convertToSignableToken(r),amount:s,receiver:r.receiver}}),{signable_message:d,payload_hash:p}=o.data,g=await signRaw(d,t),E=await e.signMessage(p),f={sender_stark_key:o.data.sender_stark_key,sender_vault_id:o.data.sender_vault_id,receiver_stark_key:o.data.receiver_stark_key,receiver_vault_id:o.data.receiver_vault_id,asset_id:o.data.asset_id,amount:o.data.amount,nonce:o.data.nonce,expiration_timestamp:o.data.expiration_timestamp,stark_signature:E},c=await i.createTransferV1({createTransferRequest:f,xImxEthAddress:a,xImxEthSignature:g});return {sent_signature:c?.data.sent_signature,status:c?.data.status?.toString(),time:c?.data.time,transfer_id:c?.data.transfer_id}}async function Q({signers:{ethSigner:t,starkSigner:e},request:r,config:n}){await l(t,n.immutableXConfig);let a=await t.getAddress(),i=new imx.TransfersApi(n.immutableXConfig.apiConfiguration),s=r.map(c=>({amount:"1",token:convertToSignableToken({type:"ERC721",tokenId:c.tokenId,tokenAddress:c.tokenAddress}),receiver:c.receiver})),o=await i.getSignableTransfer({getSignableTransferRequestV2:{sender_ether_key:a,signable_requests:s}}),d=o.data.signable_message;if(d===void 0)throw new Error("Invalid response from Signable registration offchain");let p=await signRaw(d,t),g=[];for(let c of o.data.signable_responses){let w=await e.signMessage(c.payload_hash),T={sender_vault_id:c.sender_vault_id,receiver_stark_key:c.receiver_stark_key,receiver_vault_id:c.receiver_vault_id,asset_id:c.asset_id,amount:c.amount,nonce:c.nonce,expiration_timestamp:c.expiration_timestamp,stark_signature:w};g.push(T);}let E={sender_stark_key:o.data.sender_stark_key,requests:g};return {transfer_ids:(await i.createTransfer({createTransferRequestV2:E,xImxEthAddress:a,xImxEthSignature:p}))?.data.transfer_ids}}async function j({signers:t,request:e,config:r}){await l(t.ethSigner,r.immutableXConfig);let n=await t.ethSigner.getAddress(),a=new imx.OrdersApi(r.immutableXConfig.apiConfiguration),i=e.sell.type==="ERC721"?"1":e.sell.amount,s=e.buy.type==="ERC721"?"1":e.buy.amount,o={user:n,amount_buy:s,token_buy:convertToSignableToken(e.buy),amount_sell:i,token_sell:convertToSignableToken(e.sell),fees:e.fees,expiration_timestamp:e.expiration_timestamp},d=await a.getSignableOrder({getSignableOrderRequestV3:o}),{signable_message:p,payload_hash:g}=d.data,E=await signRaw(p,t.ethSigner),f=await t.starkSigner.signMessage(g),c=d.data,w={createOrderRequest:{amount_buy:c.amount_buy,amount_sell:c.amount_sell,asset_id_buy:c.asset_id_buy,asset_id_sell:c.asset_id_sell,expiration_timestamp:c.expiration_timestamp,fees:e.fees,nonce:c.nonce,stark_key:c.stark_key,stark_signature:f,vault_id_buy:c.vault_id_buy,vault_id_sell:c.vault_id_sell},xImxEthAddress:n,xImxEthSignature:E};return {...(await a.createOrderV3(w)).data}}async function J({signers:t,request:e,config:r}){let n=new imx.OrdersApi(r.immutableXConfig.apiConfiguration),a=await n.getSignableCancelOrderV3({getSignableCancelOrderRequest:{order_id:e.order_id}}),{signable_message:i,payload_hash:s}=a.data,o=await signRaw(i,t.ethSigner),d=await t.starkSigner.signMessage(s),p=await t.ethSigner.getAddress(),g=await n.cancelOrderV3({id:e.order_id.toString(),cancelOrderRequest:{order_id:e.order_id,stark_signature:d},xImxEthAddress:p,xImxEthSignature:o});return {order_id:g.data.order_id,status:g.data.status}}async function ee(t,e){await l(t.ethSigner,e.immutableXConfig);let r=new imx.UsersApi(e.immutableXConfig.apiConfiguration),n=await t.ethSigner.getAddress(),a=await t.starkSigner.getAddress(),i=await r.getSignableRegistrationOffchain({getSignableRegistrationRequest:{ether_key:n,stark_key:a}}),{signable_message:s,payload_hash:o}=i.data,d=await signRaw(s,t.ethSigner),p=await t.starkSigner.signMessage(o);return (await r.registerUser({registerUserRequest:{eth_signature:d,ether_key:n,stark_signature:p,stark_key:a}})).data}async function te(t,e){try{let n=await new imx.UsersApi(e.immutableXConfig.apiConfiguration).getUsers({user:t}),{accounts:a}=n.data;return a?.length>0}catch(r){if(isAxiosError(r)&&r.response?.status===404)return !1;throw r}}async function _(t,e,r){await l(e,r.immutableXConfig);let n=r.immutableXConfig,a=Contracts.RegistrationV4.connect(n.ethConfiguration.registrationV4ContractAddress||n.ethConfiguration.registrationContractAddress,e);try{return await a.isRegistered(t)}catch(i){if(i.reason==="USER_UNREGISTERED")return !1;throw i}}var h=t=>{if(t!==void 0)return t;throw new Error("undefined field exception")};async function re(t,e){let{signers:{ethSigner:r,starkSigner:n}}=t;await l(r,t.config);let a=t.type==="ERC721"?"1":t.amount,i=await e.getSignableWithdrawalV2({getSignableWithdrawalRequest:{user:await r.getAddress(),token:convertToSignableToken(t),amount:a}}),{signable_message:s,payload_hash:o}=i.data,d=await n.signMessage(o),{ethAddress:p,ethSignature:g}=await signMessage(s,r);return (await e.createWithdrawalV2({createWithdrawalRequestV2:{sender_stark_key:h(i.data.sender_stark_key),sender_vault_id:h(i.data.sender_vault_id),receiver_stark_key:h(i.data.receiver_stark_key),receiver_vault_id:h(i.data.receiver_vault_id),amount:a,asset_id:h(i.data.asset_id),expiration_timestamp:h(i.data.expiration_timestamp),nonce:h(i.data.nonce),stark_signature:d},xImxEthAddress:p,xImxEthSignature:g})).data}async function C(t,e,r,n){return (await new imx.EncodingApi(r.apiConfiguration).encodeAsset({assetType:t,encodeAssetRequest:{token:{type:e,...n&&{data:n}}}})).data}async function v(t,e,r,n){return Contracts.CoreV4.connect(n.ethConfiguration.coreContractAddress,t).getWithdrawalBalance(e,r)}async function ze(t,e,r){let n=await C("asset","ETH",r);return await v(t,e,n.asset_id,r)}async function Ke(t,e,r,n){let a=await C("asset","ERC20",n,{token_address:r});return await v(t,e,a.asset_id,n)}async function je(t,e,r,n,a,i){try{let s=await a.getMintableTokenDetailsByClientTokenId({tokenAddress:r.tokenAddress,tokenId:r.tokenId}),o=await C("mintable-asset","ERC721",i,{id:r.tokenId,token_address:r.tokenAddress,...s.data.blueprint&&{blueprint:s.data.blueprint}});return await v(t,e,o.asset_id,i)}catch(s){if(s.response?.status===404){let o=await C("asset","ERC721",i,{token_id:r.tokenId,token_address:r.tokenAddress});return await v(t,e,o.asset_id,i)}throw s}}async function x(t,e,r,n,a,i){switch(r.type){case"ETH":return await ze(t,e,i);case"ERC20":return await Ke(t,e,r.tokenAddress,i);case"ERC721":return await je(t,e,r,n,a,i);default:throw new Error("Unsupported token type")}}async function I(t,e,r,n,a){let i=new EncodingApi(a.apiConfiguration),s=new MintsApi(a.apiConfiguration),o=await x(t,e,n,i,s,a),d=await x(t,r,n,i,s,a);return {v3Balance:o,v4Balance:d}}async function ae(t,e,r,n,a,i){let s=new EncodingApi(a.apiConfiguration),o=await x(t,e,n,s,i,a),d=await x(t,r,n,s,i,a);return {v3Balance:o,v4Balance:d}}var ie="ERC20";async function D(t,e,r,n,a){let i=await t.getAddress(),s=await signRegisterEthAddress(e,i,r),d=await Contracts.RegistrationV4.connect(a.ethConfiguration.registrationV4ContractAddress||a.ethConfiguration.registrationContractAddress,t).registerAndWithdrawAll.populateTransaction(i,r,s,n);return t.sendTransaction(d)}async function q(t,e,r,n){let i=await Contracts.RegistrationV4.connect(n.ethConfiguration.registrationV4ContractAddress||n.ethConfiguration.registrationContractAddress,t).withdrawAll.populateTransaction(await t.getAddress(),e,r);return t.sendTransaction(i)}async function L(t,e,r,n){let i=await Contracts.CoreV4.connect(n.ethConfiguration.coreContractAddress,t).withdraw.populateTransaction(await t.getAddress(),r);return t.sendTransaction(i)}async function se({ethSigner:t,starkSigner:e,starkPublicKey:r,token:n,config:a}){await l(t,a.immutableXConfig);let{v3Balance:i,v4Balance:s}=await I(t,r,await t.getAddress(),{type:ie,tokenAddress:n.tokenAddress},a.immutableXConfig),o=await C("asset",ie,a.immutableXConfig,{token_address:n.tokenAddress});if(i>0)return await _(r,t,a)?q(t,r,o.asset_type,a.immutableXConfig):D(t,e,r,o.asset_type,a.immutableXConfig);if(s>0)return L(t,r,o.asset_type,a.immutableXConfig);throw new Error("No balance to withdraw")}var A="ERC721";function ce(t){let{id:e}=t.data,r=t.data.blueprint||"";return N.sanitizeHex(N.utf8ToHex(`{${e}}:{${r}}`))}async function Ze(t,e,r,n){let a=await t.getAddress(),i=await e.getAddress(),s=await C("asset",A,n,{token_id:r.tokenId,token_address:r.tokenAddress}),o=await signRegisterEthAddress(e,a,i),p=await Contracts.RegistrationV4.connect(n.ethConfiguration.registrationV4ContractAddress||n.ethConfiguration.registrationContractAddress,t).registerAndWithdrawNft.populateTransaction(a,i,o,s.asset_type,r.tokenId);return t.sendTransaction(p)}async function et(t,e,r,n){let a=await t.getAddress(),i=await e.getAddress(),s=await C("mintable-asset",A,n,{id:r.data.id,token_address:r.data.tokenAddress,...r.data.blueprint&&{blueprint:r.data.blueprint}}),o=ce(r),d=await signRegisterEthAddress(e,a,i),g=await Contracts.RegistrationV4.connect(n.ethConfiguration.registrationV4ContractAddress||n.ethConfiguration.registrationContractAddress,t).registerWithdrawAndMint.populateTransaction(a,i,d,s.asset_type,o);return t.sendTransaction(g)}async function tt(t,e,r,n,a){return t.getMintableTokenDetailsByClientTokenId({tokenAddress:n.tokenAddress,tokenId:n.tokenId}).then(i=>et(e,r,{type:A,data:{id:n.tokenId,tokenAddress:n.tokenAddress,blueprint:i.data.blueprint}},a)).catch(i=>{if(i.response?.status===404)return Ze(e,r,n,a);throw i})}async function rt(t,e,r,n){let a=await C("mintable-asset",A,n,{id:r.data.id,token_address:r.data.tokenAddress,...r.data.blueprint&&{blueprint:r.data.blueprint}}),i=ce(r),o=await Contracts.CoreV4.connect(n.ethConfiguration.coreContractAddress,t).withdrawAndMint.populateTransaction(e,a.asset_type,i);return t.sendTransaction(o)}async function nt(t,e,r,n){let a=await C("asset",A,n,{token_id:r.tokenId,token_address:r.tokenAddress}),s=await Contracts.CoreV4.connect(n.ethConfiguration.coreContractAddress,t).withdrawNft.populateTransaction(e,a.asset_type,r.tokenId);return t.sendTransaction(s)}async function oe(t,e,r,n,a){return t.getMintableTokenDetailsByClientTokenId({tokenAddress:n.tokenAddress,tokenId:n.tokenId}).then(i=>rt(e,r,{type:A,data:{id:n.tokenId,tokenAddress:n.tokenAddress,blueprint:i.data.blueprint}},a)).catch(i=>{if(i.response?.status===404)return nt(e,r,n,a);throw i})}async function me({ethSigner:t,starkSigner:e,starkPublicKey:r,token:n,config:a},i){await l(t,a.immutableXConfig);let s=await t.getAddress(),{v3Balance:o,v4Balance:d}=await ae(t,r,s,{type:A,tokenAddress:n.tokenAddress,tokenId:n.tokenId},a.immutableXConfig,i);if(o>0)return await _(r,t,a)?oe(i,t,r,n,a.immutableXConfig):tt(i,t,e,n,a.immutableXConfig);if(d>0)return oe(i,t,s,n,a.immutableXConfig);throw new Error("No balance to withdraw")}var ue="ETH";async function ge({ethSigner:t,starkSigner:e,starkPublicKey:r,config:n}){await l(t,n.immutableXConfig);let{v3Balance:a,v4Balance:i}=await I(t,r,await t.getAddress(),{type:ue},n.immutableXConfig),s=await C("asset",ue,n.immutableXConfig);if(a>0)return await _(r,t,n)?q(t,r,s.asset_type,n.immutableXConfig):D(t,e,r,s.asset_type,n.immutableXConfig);if(i>0)return L(t,r,s.asset_type,n.immutableXConfig);throw new Error("No balance to withdraw")}async function le({signers:t,withdrawal:e,config:r}){let n=new imx.WithdrawalsApi(r.immutableXConfig.apiConfiguration);return re({signers:t,config:r.immutableXConfig,...e},n)}async function fe({signers:{ethSigner:t,starkSigner:e},starkPublicKey:r,token:n,config:a}){let i=new imx.MintsApi(a.immutableXConfig.apiConfiguration);switch(n.type){case"ETH":return ge({ethSigner:t,starkSigner:e,starkPublicKey:r,config:a});case"ERC20":return se({ethSigner:t,starkSigner:e,starkPublicKey:r,token:n,config:a});case"ERC721":return me({ethSigner:t,starkSigner:e,starkPublicKey:r,token:n,config:a},i)}}async function Ce({signers:{ethSigner:t,starkSigner:e},request:r,config:n}){await l(t,n.immutableXConfig);let a=await t.getAddress(),i=new imx.TradesApi(n.immutableXConfig.apiConfiguration),s=await i.getSignableTrade({getSignableTradeRequest:{user:a,order_id:r.order_id,fees:r.fees}}),{signable_message:o,payload_hash:d}=s.data,p=await signRaw(o,t),g=await e.signMessage(d);return (await i.createTradeV3({createTradeRequest:{amount_buy:s.data.amount_buy,amount_sell:s.data.amount_sell,asset_id_buy:s.data.asset_id_buy,asset_id_sell:s.data.asset_id_sell,expiration_timestamp:s.data.expiration_timestamp,fee_info:s.data.fee_info,fees:r.fees,include_fees:!0,nonce:s.data.nonce,order_id:r.order_id,stark_key:s.data.stark_key,vault_id_buy:s.data.vault_id_buy,vault_id_sell:s.data.vault_id_sell,stark_signature:g},xImxEthAddress:a,xImxEthSignature:p})).data}async function dt(t,e,r,n,a,i){let o=await Contracts.CoreV4.connect(i.ethConfiguration.coreContractAddress,t)["deposit(uint256,uint256,uint256)"].populateTransaction(n,r,a);return t.sendTransaction({...o,value:e})}async function Re({signers:{ethSigner:t},deposit:e,config:r}){await l(t,r.immutableXConfig);let n=await t.getAddress(),a={decimals:18},i=parseUnits(e.amount,"wei"),s=r.immutableXConfig,o=new imx.DepositsApi(s.apiConfiguration),d=new imx.EncodingApi(s.apiConfiguration),p={user:n,token:{type:e.type,data:a},amount:i.toString()},g=await o.getSignableDeposit({getSignableDepositRequest:p}),f=(await d.encodeAsset({assetType:"asset",encodeAssetRequest:{token:{type:e.type}}})).data.asset_type,c=g.data.stark_key,w=g.data.vault_id;return dt(t,i,f,c,w,s)}async function mt(t,e,r,n,a,i){let o=await Contracts.CoreV4.connect(i.coreContractAddress,t).depositERC20.populateTransaction(n,r,a,e);return t.sendTransaction(o)}async function _e({signers:{ethSigner:t},deposit:e,config:r}){await l(t,r.immutableXConfig);let{apiConfiguration:n,ethConfiguration:a}=r.immutableXConfig,i=await t.getAddress(),s=new imx.TokensApi(n),o=new imx.DepositsApi(n),d=new imx.EncodingApi(n),p=await s.getToken({address:e.tokenAddress}),E={decimals:parseInt(p.data.decimals),token_address:e.tokenAddress},f=parseUnits(e.amount,0),w=await Contracts.IERC20.connect(e.tokenAddress,t).approve.populateTransaction(a.coreContractAddress,f);await t.sendTransaction(w);let T={user:i,token:{type:e.type,data:E},amount:f.toString()},b=await o.getSignableDeposit({getSignableDepositRequest:T}),Xe=(await d.encodeAsset({assetType:"asset",encodeAssetRequest:{token:{type:e.type,data:{token_address:e.tokenAddress}}}})).data.asset_type,De=b.data.stark_key,qe=b.data.vault_id,Le=BigInt(b.data.amount);return mt(t,Le,Xe,De,qe,a)}async function ut(t,e,r,n,a,i){let o=await Contracts.CoreV4.connect(i.ethConfiguration.coreContractAddress,t).depositNft.populateTransaction(n,r,a,e);return t.sendTransaction(o)}async function Ae({signers:{ethSigner:t},deposit:e,config:r}){await l(t,r.immutableXConfig);let n=await t.getAddress(),{immutableXConfig:a}=r,i=new imx.DepositsApi(a.apiConfiguration),s=new imx.EncodingApi(a.apiConfiguration),o={token_address:e.tokenAddress,token_id:e.tokenId},p={user:n,token:{type:e.type,data:o},amount:"1".toString()},g=await i.getSignableDeposit({getSignableDepositRequest:p}),f=(await s.encodeAsset({assetType:"asset",encodeAssetRequest:{token:{type:e.type,data:{token_address:e.tokenAddress,token_id:e.tokenId}}}})).data.asset_type,c=g.data.stark_key,w=g.data.vault_id,T=Contracts.IERC721.connect(e.tokenAddress,t),b=a.ethConfiguration.coreContractAddress;return await T.isApprovedForAll(n,b)||await T.setApprovalForAll(b,!0),ut(t,e.tokenId,f,c,w,a)}async function be({signers:t,deposit:e,config:r}){switch(e.type){case"ETH":return Re({signers:t,deposit:e,config:r});case"ERC20":return _e({signers:t,deposit:e,config:r});case"ERC721":return Ae({signers:t,deposit:e,config:r})}}async function ye({signers:t,request:e,config:r}){await l(t.ethSigner,r.immutableXConfig);let n=new imx.ExchangesApi(r.immutableXConfig.apiConfiguration),a=await t.ethSigner.getAddress(),i=e.amount,s=await n.getExchangeSignableTransfer({id:e.transactionID,getSignableTransferRequest:{sender:a,token:convertToSignableToken(e),amount:i,receiver:e.receiver}}),{signable_message:o,payload_hash:d}=s.data,p=await signRaw(o,t.ethSigner),g=await t.starkSigner.signMessage(d),E={sender_stark_key:s.data.sender_stark_key,sender_vault_id:s.data.sender_vault_id,receiver_stark_key:s.data.receiver_stark_key,receiver_vault_id:s.data.receiver_vault_id,asset_id:s.data.asset_id,amount:s.data.amount,nonce:s.data.nonce,expiration_timestamp:s.data.expiration_timestamp,stark_signature:g},f=await n.createExchangeTransfer({id:e.transactionID,createTransferRequest:E,xImxEthAddress:a,xImxEthSignature:p});return {sent_signature:f?.data.sent_signature,status:f?.data.status?.toString(),time:f?.data.time,transfer_id:f?.data.transfer_id}}var P=class{config;signers;constructor(e,r,n){this.config=e,this.signers={ethSigner:r,starkSigner:n};}async getAddress(){return this.signers.ethSigner.getAddress()}async isRegisteredOffchain(){let e=await this.getAddress();return te(e,this.config)}registerOffchain(){return ee(this.signers,this.config)}batchNftTransfer(e){return Q({signers:this.signers,request:e,config:this.config})}cancelOrder(e){return J({signers:this.signers,request:e,config:this.config})}completeWithdrawal(e,r){return fe({config:this.config,signers:this.signers,token:r,starkPublicKey:e})}createOrder(e){return j({signers:this.signers,request:e,config:this.config})}createTrade(e){return Ce({signers:this.signers,request:e,config:this.config})}deposit(e){return be({signers:this.signers,deposit:e,config:this.config})}exchangeTransfer(e){return ye({signers:this.signers,request:e,config:this.config})}async isRegisteredOnchain(){let e=await this.signers.starkSigner.getAddress();return _(e,this.signers.ethSigner,this.config)}prepareWithdrawal(e){return le({signers:this.signers,withdrawal:e,config:this.config})}transfer(e){return Y({signers:this.signers,request:e,config:this.config})}};var Se={SWITCH_CHAIN:"wallet_switchEthereumChain",CONNECT:"eth_requestAccounts"};function ke(t){return !!t?.request}async function Pe(t,e){await t.request({method:Se.CONNECT}),e&&await t.request({method:Se.SWITCH_CHAIN,params:[{chainId:`0x${e.toString(16)}`}]});}var Et={PROVIDER_NOT_FOUND:"The Metamask provider was not found"};async function ve({chainID:t}){let e=await ft();if(!ke(e))throw new Error(Et.PROVIDER_NOT_FOUND);return await Pe(e,t),new BrowserProvider(e)}var R="message";function y(t,e){t&&t.contentWindow&&t.contentWindow.postMessage(e,new URL(t.src).origin);}function S(t,e,r,n){if(t&&e.source!==t.contentWindow)return;let a=e.data;a.type===r&&n(a.details);}var M=class{publicAddress;iframe;constructor(e,r){this.publicAddress=e,this.iframe=r;}getAddress(){return this.publicAddress}signMessage(e){return new Promise((r,n)=>{let a=i=>{S(this.iframe,i,"SIGN_MESSAGE_RESPONSE",s=>{window.removeEventListener(R,a),s.success||n(new Error(s.error?.message)),r(s.data.signedMessage);});};window.addEventListener(R,a),y(this.iframe,{type:"SIGN_MESSAGE_REQUEST",details:{starkPublicKey:this.publicAddress,message:e}});})}getIFrame(){return this.iframe}getYCoordinate(){return new Promise((e,r)=>{let n=a=>{S(this.iframe,a,"GET_Y_COORDINATE_RESPONSE",i=>{window.removeEventListener(R,n),i.success||r(new Error(i.error?.message)),e(i.data.yCoordinate);});};window.addEventListener(R,n),y(this.iframe,{type:"GET_Y_COORDINATE_REQUEST",details:{starkPublicKey:this.publicAddress}});})}};var Ie="imx-wallet-app",_t={[Environment.SANDBOX]:"https://wallets.sandbox.immutable.com",[Environment.PRODUCTION]:"https://wallets.immutable.com"},Tt="display: none;";function ht(){return document.querySelector(`iframe#${Ie}`)}async function At(t){return new Promise(e=>{let r=document.createElement("iframe");r.setAttribute("id",Ie),r.setAttribute("src",_t[t]),r.setAttribute("style",Tt),document.body.appendChild(r),r.onload=()=>e(r);})}async function Oe(t){let e=ht();return e||await At(t)}var bt="Only sign this request if you\u2019ve initiated an action with Immutable X.",yt="The L2 IMX Wallet connection has failed";async function Ne(t,e){let r=await t.getSigner(),n=await r.getAddress(),a=await r.signMessage(bt),i=await Oe(e);return new Promise((s,o)=>{let d=p=>{S(i,p,"CONNECT_WALLET_RESPONSE",g=>{window.removeEventListener(R,d),g.success||o(new Error(yt)),s(new M(g.data.starkPublicKey,i));});};window.addEventListener(R,d),y(i,{type:"CONNECT_WALLET_REQUEST",details:{ethAddress:n,signature:a}});})}async function Me(t){let e=t.getIFrame();return new Promise((r,n)=>{let a=i=>{S(e,i,"DISCONNECT_WALLET_RESPONSE",s=>{window.removeEventListener(R,a),!s.success&&s.error&&n(s.error),e.remove(),r();});};window.addEventListener(R,a),y(e,{type:"DISCONNECT_WALLET_REQUEST",details:{starkPublicKey:t.getAddress()}});})}var k=class extends Error{type;constructor(e,r){super(e),this.type=r;}},W=async(t,e)=>{try{return await t()}catch(r){let n=e.message||`${r.message}`||"UnknownError";throw new k(n,e.type)}};var V=class t extends P{static imxSigner;static async connect(e){return await W(async()=>{let r=await ve({chainID:e.immutableXConfig.ethConfiguration.chainID});return this.imxSigner=await Ne(r,e.baseConfig.environment),new t(e,await r.getSigner(),this.imxSigner)},{type:"WALLET_CONNECTION_ERROR"})}static async disconnect(){if(!this.imxSigner)throw new k("Attempted to disconnect from the MetaMask IMX provider without an established connection","PROVIDER_CONNECTION_ERROR");return W(async()=>{await Me(this.imxSigner);},{type:"PROVIDER_CONNECTION_ERROR"})}static async signMessage(e){if(!this.imxSigner)throw new k("Attempted to sign a message with the MetaMask IMX provider without an established connection","PROVIDER_CONNECTION_ERROR");return W(async()=>await this.imxSigner.signMessage(e),{type:"PROVIDER_CONNECTION_ERROR"})}};var B=class{immutableXConfig;baseConfig;constructor({baseConfig:e,overrides:r}){if(this.baseConfig=e,r)this.immutableXConfig=r.immutableXConfig;else {let n=new ImxConfiguration({baseConfig:e});this.immutableXConfig=n.immutableXConfig;}}};
 
-// src/signable-actions/helpers.ts
-function isChainValid(chainID, config) {
-  return chainID === config.ethConfiguration.chainID;
-}
-async function validateChain(signer, config) {
-  const chainID = (await signer.provider?.getNetwork())?.chainId;
-  if (!isChainValid(Number(chainID), config)) {
-    throw new Error(
-      "The wallet used for this operation is not connected to the correct network."
-    );
-  }
-}
-
-// src/signable-actions/transfer.ts
-async function transfer({
-  signers: { ethSigner, starkSigner },
-  request,
-  config
-}) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const ethAddress = await ethSigner.getAddress();
-  const transfersApi = new imx.TransfersApi(
-    config.immutableXConfig.apiConfiguration
-  );
-  const transferAmount = request.type === "ERC721" ? "1" : request.amount;
-  const signableResult = await transfersApi.getSignableTransferV1({
-    getSignableTransferRequest: {
-      sender: ethAddress,
-      token: convertToSignableToken(request),
-      amount: transferAmount,
-      receiver: request.receiver
-    }
-  });
-  const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-  const ethSignature = await signRaw(signableMessage, ethSigner);
-  const starkSignature = await starkSigner.signMessage(payloadHash);
-  const transferSigningParams = {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    sender_stark_key: signableResult.data.sender_stark_key,
-    sender_vault_id: signableResult.data.sender_vault_id,
-    receiver_stark_key: signableResult.data.receiver_stark_key,
-    receiver_vault_id: signableResult.data.receiver_vault_id,
-    asset_id: signableResult.data.asset_id,
-    amount: signableResult.data.amount,
-    nonce: signableResult.data.nonce,
-    expiration_timestamp: signableResult.data.expiration_timestamp,
-    stark_signature: starkSignature
-  };
-  const response = await transfersApi.createTransferV1({
-    createTransferRequest: transferSigningParams,
-    xImxEthAddress: ethAddress,
-    xImxEthSignature: ethSignature
-  });
-  return {
-    sent_signature: response?.data.sent_signature,
-    status: response?.data.status?.toString(),
-    time: response?.data.time,
-    transfer_id: response?.data.transfer_id
-  };
-}
-async function batchTransfer({
-  signers: { ethSigner, starkSigner },
-  request,
-  config
-}) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const ethAddress = await ethSigner.getAddress();
-  const transfersApi = new imx.TransfersApi(
-    config.immutableXConfig.apiConfiguration
-  );
-  const signableRequests = request.map((nftTransfer) => ({
-    amount: "1",
-    token: convertToSignableToken({
-      type: "ERC721",
-      tokenId: nftTransfer.tokenId,
-      tokenAddress: nftTransfer.tokenAddress
-    }),
-    receiver: nftTransfer.receiver
-  }));
-  const signableResult = await transfersApi.getSignableTransfer({
-    getSignableTransferRequestV2: {
-      sender_ether_key: ethAddress,
-      signable_requests: signableRequests
-    }
-  });
-  const signableMessage = signableResult.data.signable_message;
-  if (signableMessage === void 0) {
-    throw new Error("Invalid response from Signable registration offchain");
-  }
-  const ethSignature = await signRaw(signableMessage, ethSigner);
-  const requests = [];
-  for (const resp of signableResult.data.signable_responses) {
-    const starkSignature = await starkSigner.signMessage(resp.payload_hash);
-    const req = {
-      sender_vault_id: resp.sender_vault_id,
-      receiver_stark_key: resp.receiver_stark_key,
-      receiver_vault_id: resp.receiver_vault_id,
-      asset_id: resp.asset_id,
-      amount: resp.amount,
-      nonce: resp.nonce,
-      expiration_timestamp: resp.expiration_timestamp,
-      stark_signature: starkSignature
-    };
-    requests.push(req);
-  }
-  const transferSigningParams = {
-    sender_stark_key: signableResult.data.sender_stark_key,
-    requests
-  };
-  const response = await transfersApi.createTransfer({
-    createTransferRequestV2: transferSigningParams,
-    xImxEthAddress: ethAddress,
-    xImxEthSignature: ethSignature
-  });
-  return {
-    transfer_ids: response?.data.transfer_ids
-  };
-}
-async function createOrder({
-  signers,
-  request,
-  config
-}) {
-  await validateChain(signers.ethSigner, config.immutableXConfig);
-  const ethAddress = await signers.ethSigner.getAddress();
-  const ordersApi = new imx.OrdersApi(config.immutableXConfig.apiConfiguration);
-  const amountSell = request.sell.type === "ERC721" ? "1" : request.sell.amount;
-  const amountBuy = request.buy.type === "ERC721" ? "1" : request.buy.amount;
-  const getSignableOrderRequest = {
-    user: ethAddress,
-    amount_buy: amountBuy,
-    token_buy: convertToSignableToken(request.buy),
-    amount_sell: amountSell,
-    token_sell: convertToSignableToken(request.sell),
-    fees: request.fees,
-    expiration_timestamp: request.expiration_timestamp
-  };
-  const getSignableOrderResponse = await ordersApi.getSignableOrder({
-    getSignableOrderRequestV3: getSignableOrderRequest
-  });
-  const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableOrderResponse.data;
-  const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-  const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-  const resp = getSignableOrderResponse.data;
-  const orderParams = {
-    createOrderRequest: {
-      amount_buy: resp.amount_buy,
-      amount_sell: resp.amount_sell,
-      asset_id_buy: resp.asset_id_buy,
-      asset_id_sell: resp.asset_id_sell,
-      expiration_timestamp: resp.expiration_timestamp,
-      fees: request.fees,
-      nonce: resp.nonce,
-      stark_key: resp.stark_key,
-      stark_signature: starkSignature,
-      vault_id_buy: resp.vault_id_buy,
-      vault_id_sell: resp.vault_id_sell
-    },
-    xImxEthAddress: ethAddress,
-    xImxEthSignature: ethSignature
-  };
-  const createOrderResponse = await ordersApi.createOrderV3(orderParams);
-  return {
-    ...createOrderResponse.data
-  };
-}
-async function cancelOrder({
-  signers,
-  request,
-  config
-}) {
-  const ordersApi = new imx.OrdersApi(config.immutableXConfig.apiConfiguration);
-  const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrderV3(
-    {
-      getSignableCancelOrderRequest: {
-        order_id: request.order_id
-      }
-    }
-  );
-  const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
-  const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-  const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-  const ethAddress = await signers.ethSigner.getAddress();
-  const cancelOrderResponse = await ordersApi.cancelOrderV3({
-    id: request.order_id.toString(),
-    cancelOrderRequest: {
-      order_id: request.order_id,
-      stark_signature: starkSignature
-    },
-    xImxEthAddress: ethAddress,
-    xImxEthSignature: ethSignature
-  });
-  return {
-    order_id: cancelOrderResponse.data.order_id,
-    status: cancelOrderResponse.data.status
-  };
-}
-async function registerOffchain(signers, config) {
-  await validateChain(signers.ethSigner, config.immutableXConfig);
-  const usersApi = new imx.UsersApi(config.immutableXConfig.apiConfiguration);
-  const userAddress = await signers.ethSigner.getAddress();
-  const starkPublicKey = await signers.starkSigner.getAddress();
-  const signableResult = await usersApi.getSignableRegistrationOffchain({
-    getSignableRegistrationRequest: {
-      ether_key: userAddress,
-      stark_key: starkPublicKey
-    }
-  });
-  const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-  const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-  const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-  const registeredUser = await usersApi.registerUser({
-    registerUserRequest: {
-      eth_signature: ethSignature,
-      ether_key: userAddress,
-      stark_signature: starkSignature,
-      stark_key: starkPublicKey
-    }
-  });
-  return registeredUser.data;
-}
-async function isRegisteredOffchain(ethAddress, config) {
-  try {
-    const usersApi = new imx.UsersApi(config.immutableXConfig.apiConfiguration);
-    const getUsersResult = await usersApi.getUsers({
-      user: ethAddress
-    });
-    const { accounts } = getUsersResult.data;
-    return accounts?.length > 0;
-  } catch (ex) {
-    if (isAxiosError(ex) && ex.response?.status === 404) {
-      return false;
-    }
-    throw ex;
-  }
-}
-async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const imxConfig = config.immutableXConfig;
-  const registrationContract = Contracts.RegistrationV4.connect(
-    imxConfig.ethConfiguration.registrationV4ContractAddress || imxConfig.ethConfiguration.registrationContractAddress,
-    ethSigner
-  );
-  try {
-    return await registrationContract.isRegistered(starkPublicKey);
-  } catch (ex) {
-    if (ex.reason === "USER_UNREGISTERED") {
-      return false;
-    }
-    throw ex;
-  }
-}
-var assertIsDefined = (value) => {
-  if (value !== void 0) return value;
-  throw new Error("undefined field exception");
-};
-async function prepareWithdrawalAction(params, withdrawalsApi) {
-  const {
-    signers: { ethSigner, starkSigner }
-  } = params;
-  await validateChain(ethSigner, params.config);
-  const withdrawalAmount = params.type === "ERC721" ? "1" : params.amount;
-  const signableWithdrawalResult = await withdrawalsApi.getSignableWithdrawalV2(
-    {
-      getSignableWithdrawalRequest: {
-        user: await ethSigner.getAddress(),
-        token: convertToSignableToken(params),
-        amount: withdrawalAmount
-      }
-    }
-  );
-  const { signable_message: signableMessage, payload_hash: payloadHash } = signableWithdrawalResult.data;
-  const starkSignature = await starkSigner.signMessage(payloadHash);
-  const { ethAddress, ethSignature } = await signMessage(
-    signableMessage,
-    ethSigner
-  );
-  const prepareWithdrawalResponse = await withdrawalsApi.createWithdrawalV2({
-    createWithdrawalRequestV2: {
-      sender_stark_key: assertIsDefined(
-        signableWithdrawalResult.data.sender_stark_key
-      ),
-      sender_vault_id: assertIsDefined(
-        signableWithdrawalResult.data.sender_vault_id
-      ),
-      receiver_stark_key: assertIsDefined(
-        signableWithdrawalResult.data.receiver_stark_key
-      ),
-      receiver_vault_id: assertIsDefined(
-        signableWithdrawalResult.data.receiver_vault_id
-      ),
-      amount: withdrawalAmount,
-      asset_id: assertIsDefined(signableWithdrawalResult.data.asset_id),
-      expiration_timestamp: assertIsDefined(
-        signableWithdrawalResult.data.expiration_timestamp
-      ),
-      nonce: assertIsDefined(signableWithdrawalResult.data.nonce),
-      stark_signature: starkSignature
-    },
-    xImxEthAddress: ethAddress,
-    xImxEthSignature: ethSignature
-  });
-  return prepareWithdrawalResponse.data;
-}
-async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
-  const encodingApi = new imx.EncodingApi(config.apiConfiguration);
-  const result = await encodingApi.encodeAsset({
-    assetType,
-    encodeAssetRequest: {
-      token: {
-        type: tokenType,
-        ...tokenData && { data: tokenData }
-      }
-    }
-  });
-  return result.data;
-}
-async function getWithdrawalBalance(signer, ownerKey, assetId, config) {
-  const coreContract = Contracts.CoreV4.connect(
-    config.ethConfiguration.coreContractAddress,
-    signer
-  );
-  return coreContract.getWithdrawalBalance(ownerKey, assetId);
-}
-async function getETHWithdrawalBalance(signer, ownerKey, config) {
-  const assetType = await getEncodeAssetInfo("asset", "ETH", config);
-  return await getWithdrawalBalance(
-    signer,
-    ownerKey,
-    assetType.asset_id,
-    config
-  );
-}
-async function getERC20WithdrawalBalance(signer, ownerKey, tokenAddress, config) {
-  const assetType = await getEncodeAssetInfo("asset", "ERC20", config, {
-    token_address: tokenAddress
-  });
-  return await getWithdrawalBalance(
-    signer,
-    ownerKey,
-    assetType.asset_id,
-    config
-  );
-}
-async function getERC721WithdrawalBalance(signer, ownerKey, token, encodingApi, mintsApi, config) {
-  try {
-    const mintableToken = await mintsApi.getMintableTokenDetailsByClientTokenId({
-      tokenAddress: token.tokenAddress,
-      tokenId: token.tokenId
-    });
-    const assetType = await getEncodeAssetInfo(
-      "mintable-asset",
-      "ERC721",
-      config,
-      {
-        id: token.tokenId,
-        token_address: token.tokenAddress,
-        ...mintableToken.data.blueprint && {
-          blueprint: mintableToken.data.blueprint
-        }
-      }
-    );
-    return await getWithdrawalBalance(
-      signer,
-      ownerKey,
-      assetType.asset_id,
-      config
-    );
-  } catch (error) {
-    if (error.response?.status === 404) {
-      const assetType = await getEncodeAssetInfo(
-        "asset",
-        "ERC721",
-        config,
-        {
-          token_id: token.tokenId,
-          token_address: token.tokenAddress
-        }
-      );
-      return await getWithdrawalBalance(
-        signer,
-        ownerKey,
-        assetType.asset_id,
-        config
-      );
-    }
-    throw error;
-  }
-}
-async function getWithdrawalBalanceWorkflow(signer, ownerKey, token, encodingApi, mintsApi, config) {
-  switch (token.type) {
-    case "ETH":
-      return await getETHWithdrawalBalance(
-        signer,
-        ownerKey,
-        config
-      );
-    case "ERC20":
-      return await getERC20WithdrawalBalance(
-        signer,
-        ownerKey,
-        token.tokenAddress,
-        config
-      );
-    case "ERC721":
-      return await getERC721WithdrawalBalance(
-        signer,
-        ownerKey,
-        token,
-        encodingApi,
-        mintsApi,
-        config
-      );
-    default:
-      throw new Error("Unsupported token type");
-  }
-}
-async function getWithdrawalBalances(signer, starkPublicKey, ethAddress, token, config) {
-  const encodingApi = new EncodingApi(config.apiConfiguration);
-  const mintsApi = new MintsApi(config.apiConfiguration);
-  const v3Balance = await getWithdrawalBalanceWorkflow(
-    signer,
-    starkPublicKey,
-    token,
-    encodingApi,
-    mintsApi,
-    config
-  );
-  const v4Balance = await getWithdrawalBalanceWorkflow(
-    signer,
-    ethAddress,
-    token,
-    encodingApi,
-    mintsApi,
-    config
-  );
-  return {
-    v3Balance,
-    v4Balance
-  };
-}
-async function getWithdrawalBalancesERC721(signer, starkPublicKey, ethAddress, token, config, mintsApi) {
-  const encodingApi = new EncodingApi(config.apiConfiguration);
-  const v3Balance = await getWithdrawalBalanceWorkflow(
-    signer,
-    starkPublicKey,
-    token,
-    encodingApi,
-    mintsApi,
-    config
-  );
-  const v4Balance = await getWithdrawalBalanceWorkflow(
-    signer,
-    ethAddress,
-    token,
-    encodingApi,
-    mintsApi,
-    config
-  );
-  return {
-    v3Balance,
-    v4Balance
-  };
-}
-
-// src/signable-actions/withdrawal-actions/completeERC20Withdrawal.ts
-var ERC20TokenType = "ERC20";
-async function executeRegisterAndWithdrawAllFungible(ethSigner, starkSigner, starkPublicKey, assetType, config) {
-  const etherKey = await ethSigner.getAddress();
-  const starkSignature = await signRegisterEthAddress(
-    starkSigner,
-    etherKey,
-    starkPublicKey
-  );
-  const contract = Contracts.RegistrationV4.connect(
-    config.ethConfiguration.registrationV4ContractAddress || config.ethConfiguration.registrationContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await contract.registerAndWithdrawAll.populateTransaction(
-    etherKey,
-    starkPublicKey,
-    starkSignature,
-    assetType
-  );
-  return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawAllFungible(ethSigner, starkPublicKey, assetType, config) {
-  const contract = Contracts.RegistrationV4.connect(
-    config.ethConfiguration.registrationV4ContractAddress || config.ethConfiguration.registrationContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await contract.withdrawAll.populateTransaction(
-    await ethSigner.getAddress(),
-    starkPublicKey,
-    assetType
-  );
-  return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawFungible(ethSigner, starkPublicKey, assetType, config) {
-  const contract = Contracts.CoreV4.connect(
-    config.ethConfiguration.coreContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await contract.withdraw.populateTransaction(
-    await ethSigner.getAddress(),
-    assetType
-  );
-  return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeERC20WithdrawalAction({
-  ethSigner,
-  starkSigner,
-  starkPublicKey,
-  token,
-  config
-}) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const {
-    v3Balance,
-    v4Balance
-  } = await getWithdrawalBalances(
-    ethSigner,
-    starkPublicKey,
-    await ethSigner.getAddress(),
-    {
-      type: ERC20TokenType,
-      tokenAddress: token.tokenAddress
-    },
-    config.immutableXConfig
-  );
-  const assetType = await getEncodeAssetInfo("asset", ERC20TokenType, config.immutableXConfig, {
-    token_address: token.tokenAddress
-  });
-  if (v3Balance > 0) {
-    const isRegistered = await isRegisteredOnChain(
-      starkPublicKey,
-      ethSigner,
-      config
-    );
-    if (isRegistered) {
-      return executeWithdrawAllFungible(ethSigner, starkPublicKey, assetType.asset_type, config.immutableXConfig);
-    }
-    return executeRegisterAndWithdrawAllFungible(
-      ethSigner,
-      starkSigner,
-      starkPublicKey,
-      assetType.asset_type,
-      config.immutableXConfig
-    );
-  }
-  if (v4Balance > 0) {
-    return executeWithdrawFungible(ethSigner, starkPublicKey, assetType.asset_type, config.immutableXConfig);
-  }
-  throw new Error("No balance to withdraw");
-}
-var ERC721TokenType = "ERC721";
-function getMintingBlob(token) {
-  const { id } = token.data;
-  const blueprint = token.data.blueprint || "";
-  return encUtils.sanitizeHex(encUtils.utf8ToHex(`{${id}}:{${blueprint}}`));
-}
-async function executeERC721RegisterAndWithdraw(ethSigner, starkSigner, token, config) {
-  const etherKey = await ethSigner.getAddress();
-  const starkPublicKey = await starkSigner.getAddress();
-  const assetType = await getEncodeAssetInfo("asset", ERC721TokenType, config, {
-    token_id: token.tokenId,
-    token_address: token.tokenAddress
-  });
-  const registrationStarkSignature = await signRegisterEthAddress(
-    starkSigner,
-    etherKey,
-    starkPublicKey
-  );
-  const contract = Contracts.RegistrationV4.connect(
-    config.ethConfiguration.registrationV4ContractAddress || config.ethConfiguration.registrationContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await contract.registerAndWithdrawNft.populateTransaction(
-    etherKey,
-    starkPublicKey,
-    registrationStarkSignature,
-    assetType.asset_type,
-    token.tokenId
-  );
-  return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeMintableERC721RegisterAndWithdraw(ethSigner, starkSigner, token, config) {
-  const etherKey = await ethSigner.getAddress();
-  const starkPublicKey = await starkSigner.getAddress();
-  const assetType = await getEncodeAssetInfo(
-    "mintable-asset",
-    ERC721TokenType,
-    config,
-    {
-      id: token.data.id,
-      token_address: token.data.tokenAddress,
-      ...token.data.blueprint && { blueprint: token.data.blueprint }
-    }
-  );
-  const mintingBlob = getMintingBlob(token);
-  const starkSignature = await signRegisterEthAddress(
-    starkSigner,
-    etherKey,
-    starkPublicKey
-  );
-  const contract = Contracts.RegistrationV4.connect(
-    config.ethConfiguration.registrationV4ContractAddress || config.ethConfiguration.registrationContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await contract.registerWithdrawAndMint.populateTransaction(
-    etherKey,
-    starkPublicKey,
-    starkSignature,
-    assetType.asset_type,
-    mintingBlob
-  );
-  return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeERC721RegisterAndWithdrawal(mintsApi, ethSigner, starkSigner, token, config) {
-  return mintsApi.getMintableTokenDetailsByClientTokenId({
-    tokenAddress: token.tokenAddress,
-    tokenId: token.tokenId
-  }).then((mintableToken) => executeMintableERC721RegisterAndWithdraw(ethSigner, starkSigner, {
-    type: ERC721TokenType,
-    data: {
-      id: token.tokenId,
-      tokenAddress: token.tokenAddress,
-      blueprint: mintableToken.data.blueprint
-    }
-  }, config)).catch((error) => {
-    if (error.response?.status === 404) {
-      return executeERC721RegisterAndWithdraw(ethSigner, starkSigner, token, config);
-    }
-    throw error;
-  });
-}
-async function executeMintableERC721Withdrawal(ethSigner, ownerKey, token, config) {
-  const assetType = await getEncodeAssetInfo(
-    "mintable-asset",
-    ERC721TokenType,
-    config,
-    {
-      id: token.data.id,
-      token_address: token.data.tokenAddress,
-      ...token.data.blueprint && { blueprint: token.data.blueprint }
-    }
-  );
-  const mintingBlob = getMintingBlob(token);
-  const contract = Contracts.CoreV4.connect(
-    config.ethConfiguration.coreContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await contract.withdrawAndMint.populateTransaction(
-    ownerKey,
-    assetType.asset_type,
-    mintingBlob
-  );
-  return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeERC721Withdrawal(ethSigner, ownerKey, token, config) {
-  const assetType = await getEncodeAssetInfo("asset", ERC721TokenType, config, {
-    token_id: token.tokenId,
-    token_address: token.tokenAddress
-  });
-  const contract = Contracts.CoreV4.connect(
-    config.ethConfiguration.coreContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await contract.withdrawNft.populateTransaction(
-    ownerKey,
-    assetType.asset_type,
-    token.tokenId
-  );
-  return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeERC721Withdrawal(mintsApi, ethSigner, ownerKey, token, config) {
-  return mintsApi.getMintableTokenDetailsByClientTokenId({
-    tokenAddress: token.tokenAddress,
-    tokenId: token.tokenId
-  }).then((mintableToken) => executeMintableERC721Withdrawal(
-    ethSigner,
-    ownerKey,
-    {
-      type: ERC721TokenType,
-      data: {
-        id: token.tokenId,
-        tokenAddress: token.tokenAddress,
-        blueprint: mintableToken.data.blueprint
-      }
-    },
-    config
-  )).catch((error) => {
-    if (error.response?.status === 404) {
-      return executeERC721Withdrawal(
-        ethSigner,
-        ownerKey,
-        token,
-        config
-      );
-    }
-    throw error;
-  });
-}
-async function completeERC721WithdrawalAction({
-  ethSigner,
-  starkSigner,
-  starkPublicKey,
-  token,
-  config
-}, mintsApi) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const ethAddress = await ethSigner.getAddress();
-  const {
-    v3Balance,
-    v4Balance
-  } = await getWithdrawalBalancesERC721(
-    ethSigner,
-    starkPublicKey,
-    ethAddress,
-    {
-      type: ERC721TokenType,
-      tokenAddress: token.tokenAddress,
-      tokenId: token.tokenId
-    },
-    config.immutableXConfig,
-    mintsApi
-  );
-  if (v3Balance > 0) {
-    const isRegistered = await isRegisteredOnChain(
-      starkPublicKey,
-      ethSigner,
-      config
-    );
-    if (isRegistered) {
-      return completeERC721Withdrawal(mintsApi, ethSigner, starkPublicKey, token, config.immutableXConfig);
-    }
-    return completeERC721RegisterAndWithdrawal(
-      mintsApi,
-      ethSigner,
-      starkSigner,
-      token,
-      config.immutableXConfig
-    );
-  }
-  if (v4Balance > 0) {
-    return completeERC721Withdrawal(mintsApi, ethSigner, ethAddress, token, config.immutableXConfig);
-  }
-  throw new Error("No balance to withdraw");
-}
-
-// src/signable-actions/withdrawal-actions/completeEthWithdrawal.ts
-var EthTokenType = "ETH";
-async function completeEthWithdrawalAction({
-  ethSigner,
-  starkSigner,
-  starkPublicKey,
-  config
-}) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const {
-    v3Balance,
-    v4Balance
-  } = await getWithdrawalBalances(
-    ethSigner,
-    starkPublicKey,
-    await ethSigner.getAddress(),
-    { type: EthTokenType },
-    config.immutableXConfig
-  );
-  const assetType = await getEncodeAssetInfo("asset", EthTokenType, config.immutableXConfig);
-  if (v3Balance > 0) {
-    const isRegistered = await isRegisteredOnChain(
-      starkPublicKey,
-      ethSigner,
-      config
-    );
-    if (isRegistered) {
-      return executeWithdrawAllFungible(ethSigner, starkPublicKey, assetType.asset_type, config.immutableXConfig);
-    }
-    return executeRegisterAndWithdrawAllFungible(
-      ethSigner,
-      starkSigner,
-      starkPublicKey,
-      assetType.asset_type,
-      config.immutableXConfig
-    );
-  }
-  if (v4Balance > 0) {
-    return executeWithdrawFungible(ethSigner, starkPublicKey, assetType.asset_type, config.immutableXConfig);
-  }
-  throw new Error("No balance to withdraw");
-}
-
-// src/signable-actions/withdrawal.ts
-async function prepareWithdrawal({
-  signers,
-  withdrawal,
-  config
-}) {
-  const withdrawalsApi = new imx.WithdrawalsApi(config.immutableXConfig.apiConfiguration);
-  return prepareWithdrawalAction({
-    signers,
-    config: config.immutableXConfig,
-    ...withdrawal
-  }, withdrawalsApi);
-}
-async function completeWithdrawal({
-  signers: { ethSigner, starkSigner },
-  starkPublicKey,
-  token,
-  config
-}) {
-  const mintsApi = new imx.MintsApi(config.immutableXConfig.apiConfiguration);
-  switch (token.type) {
-    case "ETH":
-      return completeEthWithdrawalAction({
-        ethSigner,
-        starkSigner,
-        starkPublicKey,
-        config
-      });
-    case "ERC20":
-      return completeERC20WithdrawalAction({
-        ethSigner,
-        starkSigner,
-        starkPublicKey,
-        token,
-        config
-      });
-    case "ERC721":
-      return completeERC721WithdrawalAction({
-        ethSigner,
-        starkSigner,
-        starkPublicKey,
-        token,
-        config
-      }, mintsApi);
-  }
-}
-async function createTrade({
-  signers: { ethSigner, starkSigner },
-  request,
-  config
-}) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const ethAddress = await ethSigner.getAddress();
-  const tradesApi = new imx.TradesApi(config.immutableXConfig.apiConfiguration);
-  const signableResult = await tradesApi.getSignableTrade({
-    getSignableTradeRequest: {
-      user: ethAddress,
-      order_id: request.order_id,
-      fees: request.fees
-    }
-  });
-  const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-  const ethSignature = await signRaw(signableMessage, ethSigner);
-  const starkSignature = await starkSigner.signMessage(payloadHash);
-  const createTradeResponse = await tradesApi.createTradeV3({
-    createTradeRequest: {
-      amount_buy: signableResult.data.amount_buy,
-      amount_sell: signableResult.data.amount_sell,
-      asset_id_buy: signableResult.data.asset_id_buy,
-      asset_id_sell: signableResult.data.asset_id_sell,
-      expiration_timestamp: signableResult.data.expiration_timestamp,
-      fee_info: signableResult.data.fee_info,
-      fees: request.fees,
-      include_fees: true,
-      nonce: signableResult.data.nonce,
-      order_id: request.order_id,
-      stark_key: signableResult.data.stark_key,
-      vault_id_buy: signableResult.data.vault_id_buy,
-      vault_id_sell: signableResult.data.vault_id_sell,
-      stark_signature: starkSignature
-    },
-    xImxEthAddress: ethAddress,
-    xImxEthSignature: ethSignature
-  });
-  return createTradeResponse.data;
-}
-async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
-  const coreContract = Contracts.CoreV4.connect(
-    config.ethConfiguration.coreContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await coreContract["deposit(uint256,uint256,uint256)"].populateTransaction(
-    starkPublicKey,
-    assetType,
-    vaultId
-  );
-  return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
-}
-async function depositEth({
-  signers: { ethSigner },
-  deposit: deposit2,
-  config
-}) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const user = await ethSigner.getAddress();
-  const data = {
-    decimals: 18
-  };
-  const amount = parseUnits(deposit2.amount, "wei");
-  const imxConfig = config.immutableXConfig;
-  const depositsApi = new imx.DepositsApi(imxConfig.apiConfiguration);
-  const encodingApi = new imx.EncodingApi(imxConfig.apiConfiguration);
-  const getSignableDepositRequest = {
-    user,
-    token: {
-      type: deposit2.type,
-      data
-    },
-    amount: amount.toString()
-  };
-  const signableDepositResult = await depositsApi.getSignableDeposit({
-    getSignableDepositRequest
-  });
-  const encodingResult = await encodingApi.encodeAsset({
-    assetType: "asset",
-    encodeAssetRequest: {
-      token: {
-        type: deposit2.type
-      }
-    }
-  });
-  const assetType = encodingResult.data.asset_type;
-  const starkPublicKey = signableDepositResult.data.stark_key;
-  const vaultId = signableDepositResult.data.vault_id;
-  return executeDepositEth(
-    ethSigner,
-    amount,
-    assetType,
-    starkPublicKey,
-    vaultId,
-    imxConfig
-  );
-}
-async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
-  const coreContract = Contracts.CoreV4.connect(
-    config.coreContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await coreContract.depositERC20.populateTransaction(
-    starkPublicKey,
-    assetType,
-    vaultId,
-    quantizedAmount
-  );
-  return ethSigner.sendTransaction(populatedTransaction);
-}
-async function depositERC20({
-  signers: { ethSigner },
-  deposit: deposit2,
-  config
-}) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
-  const user = await ethSigner.getAddress();
-  const tokensApi = new imx.TokensApi(apiConfiguration);
-  const depositsApi = new imx.DepositsApi(apiConfiguration);
-  const encodingApi = new imx.EncodingApi(apiConfiguration);
-  const token = await tokensApi.getToken({ address: deposit2.tokenAddress });
-  const decimals = parseInt(token.data.decimals);
-  const data = {
-    decimals,
-    token_address: deposit2.tokenAddress
-  };
-  const amount = parseUnits(deposit2.amount, 0);
-  const tokenContract = Contracts.IERC20.connect(
-    deposit2.tokenAddress,
-    ethSigner
-  );
-  const approveTransaction = await tokenContract.approve.populateTransaction(
-    ethConfiguration.coreContractAddress,
-    amount
-  );
-  await ethSigner.sendTransaction(approveTransaction);
-  const getSignableDepositRequest = {
-    user,
-    token: {
-      type: deposit2.type,
-      data
-    },
-    amount: amount.toString()
-  };
-  const signableDepositResult = await depositsApi.getSignableDeposit({
-    getSignableDepositRequest
-  });
-  const encodingResult = await encodingApi.encodeAsset({
-    assetType: "asset",
-    encodeAssetRequest: {
-      token: {
-        type: deposit2.type,
-        data: {
-          token_address: deposit2.tokenAddress
-        }
-      }
-    }
-  });
-  const assetType = encodingResult.data.asset_type;
-  const starkPublicKey = signableDepositResult.data.stark_key;
-  const vaultId = signableDepositResult.data.vault_id;
-  const quantizedAmount = BigInt(signableDepositResult.data.amount);
-  return executeDepositERC20(
-    ethSigner,
-    quantizedAmount,
-    assetType,
-    starkPublicKey,
-    vaultId,
-    ethConfiguration
-  );
-}
-async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
-  const coreContract = Contracts.CoreV4.connect(
-    config.ethConfiguration.coreContractAddress,
-    ethSigner
-  );
-  const populatedTransaction = await coreContract.depositNft.populateTransaction(
-    starkPublicKey,
-    assetType,
-    vaultId,
-    tokenId
-  );
-  return ethSigner.sendTransaction(populatedTransaction);
-}
-async function depositERC721({
-  signers: { ethSigner },
-  deposit: deposit2,
-  config
-}) {
-  await validateChain(ethSigner, config.immutableXConfig);
-  const user = await ethSigner.getAddress();
-  const { immutableXConfig } = config;
-  const depositsApi = new imx.DepositsApi(immutableXConfig.apiConfiguration);
-  const encodingApi = new imx.EncodingApi(immutableXConfig.apiConfiguration);
-  const data = {
-    token_address: deposit2.tokenAddress,
-    token_id: deposit2.tokenId
-  };
-  const amount = "1";
-  const getSignableDepositRequest = {
-    user,
-    token: {
-      type: deposit2.type,
-      data
-    },
-    amount: amount.toString()
-  };
-  const signableDepositResult = await depositsApi.getSignableDeposit({
-    getSignableDepositRequest
-  });
-  const encodingResult = await encodingApi.encodeAsset({
-    assetType: "asset",
-    encodeAssetRequest: {
-      token: {
-        type: deposit2.type,
-        data: {
-          token_address: deposit2.tokenAddress,
-          token_id: deposit2.tokenId
-        }
-      }
-    }
-  });
-  const assetType = encodingResult.data.asset_type;
-  const starkPublicKey = signableDepositResult.data.stark_key;
-  const vaultId = signableDepositResult.data.vault_id;
-  const tokenContract = Contracts.IERC721.connect(
-    deposit2.tokenAddress,
-    ethSigner
-  );
-  const operator = immutableXConfig.ethConfiguration.coreContractAddress;
-  const isApprovedForAll = await tokenContract.isApprovedForAll(user, operator);
-  if (!isApprovedForAll) {
-    await tokenContract.setApprovalForAll(operator, true);
-  }
-  return executeDepositERC721(
-    ethSigner,
-    deposit2.tokenId,
-    assetType,
-    starkPublicKey,
-    vaultId,
-    immutableXConfig
-  );
-}
-
-// src/signable-actions/deposit.ts
-async function deposit({ signers, deposit: deposit2, config }) {
-  switch (deposit2.type) {
-    case "ETH":
-      return depositEth({ signers, deposit: deposit2, config });
-    case "ERC20":
-      return depositERC20({ signers, deposit: deposit2, config });
-    case "ERC721":
-      return depositERC721({ signers, deposit: deposit2, config });
-  }
-}
-async function exchangeTransfer({
-  signers,
-  request,
-  config
-}) {
-  await validateChain(signers.ethSigner, config.immutableXConfig);
-  const exchangeApi = new imx.ExchangesApi(
-    config.immutableXConfig.apiConfiguration
-  );
-  const ethAddress = await signers.ethSigner.getAddress();
-  const transferAmount = request.amount;
-  const signableResult = await exchangeApi.getExchangeSignableTransfer({
-    id: request.transactionID,
-    getSignableTransferRequest: {
-      sender: ethAddress,
-      token: convertToSignableToken(request),
-      amount: transferAmount,
-      receiver: request.receiver
-    }
-  });
-  const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-  const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-  const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-  const transferSigningParams = {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    sender_stark_key: signableResult.data.sender_stark_key,
-    sender_vault_id: signableResult.data.sender_vault_id,
-    receiver_stark_key: signableResult.data.receiver_stark_key,
-    receiver_vault_id: signableResult.data.receiver_vault_id,
-    asset_id: signableResult.data.asset_id,
-    amount: signableResult.data.amount,
-    nonce: signableResult.data.nonce,
-    expiration_timestamp: signableResult.data.expiration_timestamp,
-    stark_signature: starkSignature
-  };
-  const response = await exchangeApi.createExchangeTransfer({
-    id: request.transactionID,
-    createTransferRequest: transferSigningParams,
-    xImxEthAddress: ethAddress,
-    xImxEthSignature: ethSignature
-  });
-  return {
-    sent_signature: response?.data.sent_signature,
-    status: response?.data.status?.toString(),
-    time: response?.data.time,
-    transfer_id: response?.data.transfer_id
-  };
-}
-
-// src/genericImxProvider.ts
-var GenericIMXProvider = class {
-  config;
-  signers;
-  constructor(config, ethSigner, starkSigner) {
-    this.config = config;
-    this.signers = { ethSigner, starkSigner };
-  }
-  async getAddress() {
-    return this.signers.ethSigner.getAddress();
-  }
-  async isRegisteredOffchain() {
-    const ethAddress = await this.getAddress();
-    return isRegisteredOffchain(
-      ethAddress,
-      this.config
-    );
-  }
-  registerOffchain() {
-    return registerOffchain(this.signers, this.config);
-  }
-  batchNftTransfer(request) {
-    return batchTransfer({
-      signers: this.signers,
-      request,
-      config: this.config
-    });
-  }
-  cancelOrder(request) {
-    return cancelOrder({
-      signers: this.signers,
-      request,
-      config: this.config
-    });
-  }
-  completeWithdrawal(starkPublicKey, token) {
-    return completeWithdrawal({
-      config: this.config,
-      signers: this.signers,
-      token,
-      starkPublicKey
-    });
-  }
-  createOrder(request) {
-    return createOrder({
-      signers: this.signers,
-      request,
-      config: this.config
-    });
-  }
-  createTrade(request) {
-    return createTrade({
-      signers: this.signers,
-      request,
-      config: this.config
-    });
-  }
-  deposit(tokenAmount) {
-    return deposit({
-      signers: this.signers,
-      deposit: tokenAmount,
-      config: this.config
-    });
-  }
-  exchangeTransfer(request) {
-    return exchangeTransfer({
-      signers: this.signers,
-      request,
-      config: this.config
-    });
-  }
-  async isRegisteredOnchain() {
-    const starkPublicKey = await this.signers.starkSigner.getAddress();
-    return isRegisteredOnChain(
-      starkPublicKey,
-      this.signers.ethSigner,
-      this.config
-    );
-  }
-  prepareWithdrawal(request) {
-    return prepareWithdrawal({
-      signers: this.signers,
-      withdrawal: request,
-      config: this.config
-    });
-  }
-  transfer(request) {
-    return transfer({
-      signers: this.signers,
-      request,
-      config: this.config
-    });
-  }
-};
-
-// src/l1-providers/rpc.ts
-var WALLET_ACTION = {
-  // TODO: remove once fixed - consider using an enum
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  SWITCH_CHAIN: "wallet_switchEthereumChain",
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  CONNECT: "eth_requestAccounts"
-};
-function isRequestableProvider(provider) {
-  return !!provider?.request;
-}
-async function connectProvider(provider, chainID) {
-  await provider.request({ method: WALLET_ACTION.CONNECT });
-  if (chainID) {
-    await provider.request({
-      method: WALLET_ACTION.SWITCH_CHAIN,
-      params: [{ chainId: `0x${chainID.toString(16)}` }]
-    });
-  }
-}
-
-// src/l1-providers/metaMask.ts
-var ERRORS = {
-  // TODO: remove once fixed - consider using something in line with the naming convention
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  PROVIDER_NOT_FOUND: "The Metamask provider was not found"
-};
-async function connect({
-  chainID
-}) {
-  const provider = await detectEthereumProvider();
-  if (!isRequestableProvider(provider)) {
-    throw new Error(ERRORS.PROVIDER_NOT_FOUND);
-  }
-  await connectProvider(provider, chainID);
-  return new BrowserProvider(provider);
-}
-
-// src/imx-wallet/events.ts
-var COMMUNICATION_TYPE = "message";
-
-// src/imx-wallet/postRequestMessage.ts
-function postRequestMessage(iframe, payload) {
-  if (iframe && iframe.contentWindow) {
-    iframe.contentWindow.postMessage(payload, new URL(iframe.src).origin);
-  }
-}
-
-// src/imx-wallet/messageResponseListener.ts
-function messageResponseListener(iframe, event, eventType, callback) {
-  if (iframe && event.source !== iframe.contentWindow) {
-    return;
-  }
-  const l2WalletMessage = event.data;
-  if (l2WalletMessage.type !== eventType) {
-    return;
-  }
-  callback(l2WalletMessage.details);
-}
-
-// src/imx-wallet/ImxSigner.ts
-var ImxSigner = class {
-  publicAddress;
-  iframe;
-  constructor(publicAddress, iframe) {
-    this.publicAddress = publicAddress;
-    this.iframe = iframe;
-  }
-  getAddress() {
-    return this.publicAddress;
-  }
-  signMessage(rawMessage) {
-    return new Promise((resolve, reject) => {
-      const listener = (event) => {
-        messageResponseListener(
-          this.iframe,
-          event,
-          "SIGN_MESSAGE_RESPONSE" /* SIGN_MESSAGE_RESPONSE */,
-          (messageDetails) => {
-            window.removeEventListener(COMMUNICATION_TYPE, listener);
-            if (!messageDetails.success) {
-              reject(new Error(messageDetails.error?.message));
-            }
-            resolve(messageDetails.data.signedMessage);
-          }
-        );
-      };
-      window.addEventListener(COMMUNICATION_TYPE, listener);
-      postRequestMessage(this.iframe, {
-        type: "SIGN_MESSAGE_REQUEST" /* SIGN_MESSAGE_REQUEST */,
-        details: { starkPublicKey: this.publicAddress, message: rawMessage }
-      });
-    });
-  }
-  getIFrame() {
-    return this.iframe;
-  }
-  getYCoordinate() {
-    return new Promise((resolve, reject) => {
-      const listener = (event) => {
-        messageResponseListener(
-          this.iframe,
-          event,
-          "GET_Y_COORDINATE_RESPONSE" /* GET_Y_COORDINATE_RESPONSE */,
-          (messageDetails) => {
-            window.removeEventListener(COMMUNICATION_TYPE, listener);
-            if (!messageDetails.success) {
-              reject(new Error(messageDetails.error?.message));
-            }
-            resolve(messageDetails.data.yCoordinate);
-          }
-        );
-      };
-      window.addEventListener(COMMUNICATION_TYPE, listener);
-      postRequestMessage(this.iframe, {
-        type: "GET_Y_COORDINATE_REQUEST" /* GET_Y_COORDINATE_REQUEST */,
-        details: { starkPublicKey: this.publicAddress }
-      });
-    });
-  }
-};
-var IMX_WALLET_IFRAME_ID = "imx-wallet-app";
-var IMX_WALLET_IFRAME_HOSTS = {
-  [Environment.SANDBOX]: "https://wallets.sandbox.immutable.com",
-  [Environment.PRODUCTION]: "https://wallets.immutable.com"
-};
-var IMX_WALLET_IFRAME_STYLE = "display: none;";
-function getIFrame() {
-  return document.querySelector(`iframe#${IMX_WALLET_IFRAME_ID}`);
-}
-async function setupIFrame(env) {
-  return new Promise((resolve) => {
-    const iframe = document.createElement("iframe");
-    iframe.setAttribute("id", IMX_WALLET_IFRAME_ID);
-    iframe.setAttribute("src", IMX_WALLET_IFRAME_HOSTS[env]);
-    iframe.setAttribute("style", IMX_WALLET_IFRAME_STYLE);
-    document.body.appendChild(iframe);
-    iframe.onload = () => resolve(iframe);
-  });
-}
-async function getOrSetupIFrame(env) {
-  const iframe = getIFrame();
-  if (iframe) return iframe;
-  return await setupIFrame(env);
-}
-
-// src/imx-wallet/imxWallet.ts
-var DEFAULT_CONNECTION_MESSAGE = "Only sign this request if you\u2019ve initiated an action with Immutable X.";
-var CONNECTION_FAILED_ERROR = "The L2 IMX Wallet connection has failed";
-async function connect2(l1Provider, env) {
-  const l1Signer = await l1Provider.getSigner();
-  const address = await l1Signer.getAddress();
-  const signature = await l1Signer.signMessage(DEFAULT_CONNECTION_MESSAGE);
-  const iframe = await getOrSetupIFrame(env);
-  return new Promise((resolve, reject) => {
-    const listener = (event) => {
-      messageResponseListener(
-        iframe,
-        event,
-        "CONNECT_WALLET_RESPONSE" /* CONNECT_WALLET_RESPONSE */,
-        (messageDetails) => {
-          window.removeEventListener(COMMUNICATION_TYPE, listener);
-          if (!messageDetails.success) {
-            reject(new Error(CONNECTION_FAILED_ERROR));
-          }
-          resolve(new ImxSigner(messageDetails.data.starkPublicKey, iframe));
-        }
-      );
-    };
-    window.addEventListener(COMMUNICATION_TYPE, listener);
-    postRequestMessage(iframe, {
-      type: "CONNECT_WALLET_REQUEST" /* CONNECT_WALLET_REQUEST */,
-      details: { ethAddress: address, signature }
-    });
-  });
-}
-async function disconnect(imxSigner) {
-  const iframe = imxSigner.getIFrame();
-  return new Promise((resolve, reject) => {
-    const listener = (event) => {
-      messageResponseListener(
-        iframe,
-        event,
-        "DISCONNECT_WALLET_RESPONSE" /* DISCONNECT_WALLET_RESPONSE */,
-        (messageDetails) => {
-          window.removeEventListener(COMMUNICATION_TYPE, listener);
-          if (!messageDetails.success && messageDetails.error) {
-            reject(messageDetails.error);
-          }
-          iframe.remove();
-          resolve();
-        }
-      );
-    };
-    window.addEventListener(COMMUNICATION_TYPE, listener);
-    postRequestMessage(iframe, {
-      type: "DISCONNECT_WALLET_REQUEST" /* DISCONNECT_WALLET_REQUEST */,
-      details: { starkPublicKey: imxSigner.getAddress() }
-    });
-  });
-}
-
-// src/errors/providerError.ts
-var ProviderError = class extends Error {
-  type;
-  constructor(message, type) {
-    super(message);
-    this.type = type;
-  }
-};
-var withProviderError = async (fn, customError) => {
-  try {
-    return await fn();
-  } catch (error) {
-    const errorMessage = customError.message || `${error.message}` || "UnknownError";
-    throw new ProviderError(errorMessage, customError.type);
-  }
-};
-
-// src/l1-providers/metaMaskWrapper.ts
-var MetaMaskIMXProvider = class _MetaMaskIMXProvider extends GenericIMXProvider {
-  static imxSigner;
-  static async connect(config) {
-    return await withProviderError(
-      async () => {
-        const metaMaskProvider = await connect({
-          chainID: config.immutableXConfig.ethConfiguration.chainID
-        });
-        this.imxSigner = await connect2(
-          metaMaskProvider,
-          config.baseConfig.environment
-        );
-        return new _MetaMaskIMXProvider(
-          config,
-          await metaMaskProvider.getSigner(),
-          this.imxSigner
-        );
-      },
-      { type: "WALLET_CONNECTION_ERROR" /* WALLET_CONNECTION_ERROR */ }
-    );
-  }
-  static async disconnect() {
-    if (!this.imxSigner) {
-      throw new ProviderError(
-        "Attempted to disconnect from the MetaMask IMX provider without an established connection",
-        "PROVIDER_CONNECTION_ERROR" /* PROVIDER_CONNECTION_ERROR */
-      );
-    }
-    return withProviderError(
-      async () => {
-        await disconnect(this.imxSigner);
-      },
-      { type: "PROVIDER_CONNECTION_ERROR" /* PROVIDER_CONNECTION_ERROR */ }
-    );
-  }
-  static async signMessage(message) {
-    if (!this.imxSigner) {
-      throw new ProviderError(
-        "Attempted to sign a message with the MetaMask IMX provider without an established connection",
-        "PROVIDER_CONNECTION_ERROR" /* PROVIDER_CONNECTION_ERROR */
-      );
-    }
-    return withProviderError(
-      async () => await this.imxSigner.signMessage(message),
-      { type: "PROVIDER_CONNECTION_ERROR" /* PROVIDER_CONNECTION_ERROR */ }
-    );
-  }
-};
-var ProviderConfiguration = class {
-  immutableXConfig;
-  baseConfig;
-  constructor({ baseConfig, overrides }) {
-    this.baseConfig = baseConfig;
-    if (overrides) {
-      this.immutableXConfig = overrides.immutableXConfig;
-    } else {
-      const clientConfig = new ImxConfiguration({ baseConfig });
-      this.immutableXConfig = clientConfig.immutableXConfig;
-    }
-  }
-};
-
-export { GenericIMXProvider, MetaMaskIMXProvider, ProviderConfiguration };
+export { P as GenericIMXProvider, V as MetaMaskIMXProvider, B as ProviderConfiguration };