@debridge-finance/solana-utils 5.3.2 → 5.4.1

package/dist/browser/index.js

@@ -7434,24 +7434,24 @@ var memoize = microMemoize.exports;
 
 const TOKEN_2022_PROGRAM_ID = new PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
 const TOKEN_METADATA_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
-const TOKEN_PROGRAM_ID = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const TOKEN_PROGRAM_ID$1 = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
 const WRAPPED_SOL_MINT = new PublicKey("So11111111111111111111111111111111111111112");
-function findAssociatedTokenAddress(wallet, tokenMint, tokenProgramId = TOKEN_PROGRAM_ID, associatedTokenProramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+function findAssociatedTokenAddress(wallet, tokenMint, tokenProgramId = TOKEN_PROGRAM_ID$1, associatedTokenProramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
     return PublicKey.findProgramAddressSync([wallet.toBytes(), tokenProgramId.toBytes(), tokenMint.toBytes()], associatedTokenProramId);
 }
 /**
  * @deprecated same as findAssociatedTokenAddress
  */
-function findAssociatedTokenAddressSync(wallet, tokenMint, tokenProgramId = TOKEN_PROGRAM_ID, associatedTokenProramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+function findAssociatedTokenAddressSync(wallet, tokenMint, tokenProgramId = TOKEN_PROGRAM_ID$1, associatedTokenProramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
     return PublicKey.findProgramAddressSync([wallet.toBytes(), tokenProgramId.toBytes(), tokenMint.toBytes()], associatedTokenProramId);
 }
-function getTokenMetadataAddress(tokenMint, tokenMetedataProgramId) {
+function getTokenMetadataAddress(tokenMint, tokenMetadataProgramId) {
     return PublicKey.findProgramAddressSync([
         buffer.Buffer.from("metadata"),
-        tokenMetedataProgramId.toBytes(),
+        tokenMetadataProgramId.toBytes(),
         tokenMint.toBytes(),
-    ], tokenMetedataProgramId);
+    ], tokenMetadataProgramId);
 }
 const deBridge$1 = {
     getClaimMarkerAddress: (DEBRIDGE_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(deBridge$2.Seeds.CLAIM_MARKER)], DEBRIDGE_PROGRAM_ID),
@@ -7593,6 +7593,17 @@ const dlnDstResolver = (programId) => {
     return new Resolver(programId, DlnDst, dstMemoizeList);
 };
 
+/** Address of the SPL Token program */
+const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+/** Address of the SPL Token 2022 program */
+new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
+/** Address of the SPL Associated Token Account program */
+new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+/** Address of the special mint for wrapped native SOL in spl-token */
+new PublicKey('So11111111111111111111111111111111111111112');
+/** Address of the special mint for wrapped native SOL in spl-token-2022 */
+new PublicKey('9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP');
+
 var Layout$4 = {};
 
 /* The MIT License (MIT)
@@ -9992,903 +10003,439 @@ const publicKey$4 = (property) => {
     return publicKeyLayout;
 };
 
+/** Base class for errors */
+class TokenError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+/** Thrown if an account is not found at the expected address */
+class TokenAccountNotFoundError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenAccountNotFoundError';
+    }
+}
+/** Thrown if a program state account is not owned by the expected token program */
+class TokenInvalidAccountOwnerError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidAccountOwnerError';
+    }
+}
+/** Thrown if the byte length of an program state account doesn't match the expected size */
+class TokenInvalidAccountSizeError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidAccountSizeError';
+    }
+}
+/** Thrown if the mint of a token account doesn't match the expected mint */
+class TokenInvalidMintError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidMintError';
+    }
+}
+
+/** Instructions defined by the program */
+var TokenInstruction;
+(function (TokenInstruction) {
+    TokenInstruction[TokenInstruction["InitializeMint"] = 0] = "InitializeMint";
+    TokenInstruction[TokenInstruction["InitializeAccount"] = 1] = "InitializeAccount";
+    TokenInstruction[TokenInstruction["InitializeMultisig"] = 2] = "InitializeMultisig";
+    TokenInstruction[TokenInstruction["Transfer"] = 3] = "Transfer";
+    TokenInstruction[TokenInstruction["Approve"] = 4] = "Approve";
+    TokenInstruction[TokenInstruction["Revoke"] = 5] = "Revoke";
+    TokenInstruction[TokenInstruction["SetAuthority"] = 6] = "SetAuthority";
+    TokenInstruction[TokenInstruction["MintTo"] = 7] = "MintTo";
+    TokenInstruction[TokenInstruction["Burn"] = 8] = "Burn";
+    TokenInstruction[TokenInstruction["CloseAccount"] = 9] = "CloseAccount";
+    TokenInstruction[TokenInstruction["FreezeAccount"] = 10] = "FreezeAccount";
+    TokenInstruction[TokenInstruction["ThawAccount"] = 11] = "ThawAccount";
+    TokenInstruction[TokenInstruction["TransferChecked"] = 12] = "TransferChecked";
+    TokenInstruction[TokenInstruction["ApproveChecked"] = 13] = "ApproveChecked";
+    TokenInstruction[TokenInstruction["MintToChecked"] = 14] = "MintToChecked";
+    TokenInstruction[TokenInstruction["BurnChecked"] = 15] = "BurnChecked";
+    TokenInstruction[TokenInstruction["InitializeAccount2"] = 16] = "InitializeAccount2";
+    TokenInstruction[TokenInstruction["SyncNative"] = 17] = "SyncNative";
+    TokenInstruction[TokenInstruction["InitializeAccount3"] = 18] = "InitializeAccount3";
+    TokenInstruction[TokenInstruction["InitializeMultisig2"] = 19] = "InitializeMultisig2";
+    TokenInstruction[TokenInstruction["InitializeMint2"] = 20] = "InitializeMint2";
+    TokenInstruction[TokenInstruction["GetAccountDataSize"] = 21] = "GetAccountDataSize";
+    TokenInstruction[TokenInstruction["InitializeImmutableOwner"] = 22] = "InitializeImmutableOwner";
+    TokenInstruction[TokenInstruction["AmountToUiAmount"] = 23] = "AmountToUiAmount";
+    TokenInstruction[TokenInstruction["UiAmountToAmount"] = 24] = "UiAmountToAmount";
+    TokenInstruction[TokenInstruction["InitializeMintCloseAuthority"] = 25] = "InitializeMintCloseAuthority";
+    TokenInstruction[TokenInstruction["TransferFeeExtension"] = 26] = "TransferFeeExtension";
+    TokenInstruction[TokenInstruction["ConfidentialTransferExtension"] = 27] = "ConfidentialTransferExtension";
+    TokenInstruction[TokenInstruction["DefaultAccountStateExtension"] = 28] = "DefaultAccountStateExtension";
+    TokenInstruction[TokenInstruction["Reallocate"] = 29] = "Reallocate";
+    TokenInstruction[TokenInstruction["MemoTransferExtension"] = 30] = "MemoTransferExtension";
+    TokenInstruction[TokenInstruction["CreateNativeMint"] = 31] = "CreateNativeMint";
+    TokenInstruction[TokenInstruction["InitializeNonTransferableMint"] = 32] = "InitializeNonTransferableMint";
+    TokenInstruction[TokenInstruction["InterestBearingMintExtension"] = 33] = "InterestBearingMintExtension";
+    TokenInstruction[TokenInstruction["CpiGuardExtension"] = 34] = "CpiGuardExtension";
+    TokenInstruction[TokenInstruction["InitializePermanentDelegate"] = 35] = "InitializePermanentDelegate";
+    TokenInstruction[TokenInstruction["TransferHookExtension"] = 36] = "TransferHookExtension";
+    // ConfidentialTransferFeeExtension = 37,
+    // WithdrawalExcessLamports = 38,
+    TokenInstruction[TokenInstruction["MetadataPointerExtension"] = 39] = "MetadataPointerExtension";
+    TokenInstruction[TokenInstruction["GroupPointerExtension"] = 40] = "GroupPointerExtension";
+    TokenInstruction[TokenInstruction["GroupMemberPointerExtension"] = 41] = "GroupMemberPointerExtension";
+    // ConfidentialMintBurnExtension = 42,
+    TokenInstruction[TokenInstruction["ScaledUiAmountExtension"] = 43] = "ScaledUiAmountExtension";
+    TokenInstruction[TokenInstruction["PausableExtension"] = 44] = "PausableExtension";
+})(TokenInstruction || (TokenInstruction = {}));
+
+/** TODO: docs */
+struct$1([
+    u8$1('instruction'),
+    u64$1('amount'),
+]);
+
+var AccountType$1;
+(function (AccountType) {
+    AccountType[AccountType["Uninitialized"] = 0] = "Uninitialized";
+    AccountType[AccountType["Mint"] = 1] = "Mint";
+    AccountType[AccountType["Account"] = 2] = "Account";
+})(AccountType$1 || (AccountType$1 = {}));
+const ACCOUNT_TYPE_SIZE = 1;
+
+/** Buffer layout for de/serializing a multisig */
+const MultisigLayout = struct$1([
+    u8$1('m'),
+    u8$1('n'),
+    bool$1('isInitialized'),
+    publicKey$4('signer1'),
+    publicKey$4('signer2'),
+    publicKey$4('signer3'),
+    publicKey$4('signer4'),
+    publicKey$4('signer5'),
+    publicKey$4('signer6'),
+    publicKey$4('signer7'),
+    publicKey$4('signer8'),
+    publicKey$4('signer9'),
+    publicKey$4('signer10'),
+    publicKey$4('signer11'),
+]);
+/** Byte length of a multisig */
+const MULTISIG_SIZE = MultisigLayout.span;
+
+/** Token account state as stored by the program */
 var AccountState$1;
 (function (AccountState) {
     AccountState[AccountState["Uninitialized"] = 0] = "Uninitialized";
     AccountState[AccountState["Initialized"] = 1] = "Initialized";
     AccountState[AccountState["Frozen"] = 2] = "Frozen";
 })(AccountState$1 || (AccountState$1 = {}));
+/** Buffer layout for de/serializing a token account */
 const AccountLayout$1 = struct$1([
-    publicKey$4("mint"),
-    publicKey$4("owner"),
-    u64$1("amount"),
-    u32$1("delegateOption"),
-    publicKey$4("delegate"),
-    u8$1("state"),
-    u32$1("isNativeOption"),
-    u64$1("isNative"),
-    u64$1("delegatedAmount"),
-    u32$1("closeAuthorityOption"),
-    publicKey$4("closeAuthority"),
+    publicKey$4('mint'),
+    publicKey$4('owner'),
+    u64$1('amount'),
+    u32$1('delegateOption'),
+    publicKey$4('delegate'),
+    u8$1('state'),
+    u32$1('isNativeOption'),
+    u64$1('isNative'),
+    u64$1('delegatedAmount'),
+    u32$1('closeAuthorityOption'),
+    publicKey$4('closeAuthority'),
 ]);
-var AccountType$1;
-(function (AccountType) {
-    AccountType[AccountType["System"] = 0] = "System";
-    AccountType[AccountType["Token"] = 1] = "Token";
-    AccountType[AccountType["CorrectATA"] = 2] = "CorrectATA";
-    AccountType[AccountType["Unknown"] = 3] = "Unknown";
-    AccountType[AccountType["NotExists"] = 4] = "NotExists";
-})(AccountType$1 || (AccountType$1 = {}));
-/**
- * Get name, symbol and decimals for provided token
- * @param connection solana web3 connection
- * @param tokenAddress address to get metaplex info for
- * @returns
- */
-function getTokenInfo(connection, tokenAddress) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const tokenMetaProgramId = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
-        const findMetaplexMetadataPda = (tokenMint) => PublicKey.findProgramAddressSync([
-            buffer.Buffer.from("metadata", "utf-8"),
-            tokenMetaProgramId.toBuffer(),
-            tokenMint.toBuffer(),
-        ], tokenMetaProgramId)[0];
-        const decodeMetaplexMetadataPartial = (data) => {
-            const rawName = data.subarray(65 + 4, 65 + 36); // omit first 4 bytes, size is already hardcoded
-            const rawSymbol = data.subarray(101 + 4, 115); // omit first 4 bytes, size is already hardcoded
-            const rawUri = data.subarray(115 + 4, 204); // omit first 4 bytes, size is already hardcoded
-            return {
-                uri: rawUri.toString("utf-8").replace(/\u0000/g, ""),
-                symbol: rawSymbol.toString("utf-8").replace(/\u0000/g, ""),
-                name: rawName.toString("utf-8").replace(/\u0000/g, ""),
-            };
-        };
-        const pda = findMetaplexMetadataPda(tokenAddress);
-        const [tokenAccount, pdaAccount] = yield connection.getMultipleAccountsInfo([
-            tokenAddress,
-            pda,
-        ]);
-        if (tokenAccount === null ||
-            pdaAccount === null ||
-            (pdaAccount === null || pdaAccount === void 0 ? void 0 : pdaAccount.lamports) === 0) {
-            return null;
-        }
-        // parse token account
-        // mint_authority - coption(pubkey) = 4 or 36
-        // supply - u64 = 8
-        // decimals - u8
-        let decimalsOffset = 12;
-        if (tokenAccount.data[0] === 1)
-            decimalsOffset += 32;
-        const decimals = tokenAccount.data[decimalsOffset];
-        const { name, symbol, uri } = decodeMetaplexMetadataPartial(pdaAccount.data);
-        return {
-            address: tokenAddress,
-            decimals,
-            name,
-            symbol,
-            json: uri,
-        };
-    });
+/** Byte length of a token account */
+const ACCOUNT_SIZE = AccountLayout$1.span;
+
+var CpiGuardInstruction;
+(function (CpiGuardInstruction) {
+    CpiGuardInstruction[CpiGuardInstruction["Enable"] = 0] = "Enable";
+    CpiGuardInstruction[CpiGuardInstruction["Disable"] = 1] = "Disable";
+})(CpiGuardInstruction || (CpiGuardInstruction = {}));
+/** TODO: docs */
+struct$1([u8$1('instruction'), u8$1('cpiGuardInstruction')]);
+
+/** Buffer layout for de/serializing a CPI Guard extension */
+const CpiGuardLayout = struct$1([bool$1('lockCpi')]);
+CpiGuardLayout.span;
+
+var DefaultAccountStateInstruction;
+(function (DefaultAccountStateInstruction) {
+    DefaultAccountStateInstruction[DefaultAccountStateInstruction["Initialize"] = 0] = "Initialize";
+    DefaultAccountStateInstruction[DefaultAccountStateInstruction["Update"] = 1] = "Update";
+})(DefaultAccountStateInstruction || (DefaultAccountStateInstruction = {}));
+/** TODO: docs */
+struct$1([
+    u8$1('instruction'),
+    u8$1('defaultAccountStateInstruction'),
+    u8$1('accountState'),
+]);
+
+/** Buffer layout for de/serializing a transfer fee config extension */
+const DefaultAccountStateLayout = struct$1([u8$1('state')]);
+DefaultAccountStateLayout.span;
+
+// src/codes.ts
+var SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$1 = 8078e3;
+var SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$1 = 8078001;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$1 = 8078004;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$1 = 8078005;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$1 = 8078006;
+var SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS$1 = 8078007;
+var SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$1 = 8078011;
+
+// src/context.ts
+function encodeValue$1(value) {
+  if (Array.isArray(value)) {
+    const commaSeparatedValues = value.map(encodeValue$1).join(
+      "%2C%20"
+      /* ", " */
+    );
+    return "%5B" + commaSeparatedValues + /* "]" */
+    "%5D";
+  } else if (typeof value === "bigint") {
+    return `${value}n`;
+  } else {
+    return encodeURIComponent(
+      String(
+        value != null && Object.getPrototypeOf(value) === null ? (
+          // Plain objects with no prototype don't have a `toString` method.
+          // Convert them before stringifying them.
+          { ...value }
+        ) : value
+      )
+    );
+  }
 }
-/**
- * Builds instruction for creation of associated wallet for specified token
- * @param tokenMint mint account of SPL-token
- * @param associatedAccount associated account address
- * @param owner owner of the associated account
- * @param payer who pays for account creation
- */
-function createAssociatedWalletInstruction(tokenMint, associatedAccount, owner, payer, associatedTokenProramId) {
-    tokenMint = new PublicKey(tokenMint);
-    payer = new PublicKey(payer);
-    owner = new PublicKey(owner);
-    return new TransactionInstruction({
-        programId: associatedTokenProramId || ASSOCIATED_TOKEN_PROGRAM_ID,
-        data: buffer.Buffer.from([1]),
-        keys: [
-            {
-                pubkey: payer,
-                isSigner: true,
-                isWritable: true,
-            },
-            {
-                pubkey: associatedAccount,
-                isSigner: false,
-                isWritable: true,
-            },
-            {
-                pubkey: owner,
-                isSigner: false,
-                isWritable: false,
-            },
-            {
-                pubkey: tokenMint,
-                isSigner: false,
-                isWritable: false,
-            },
-            {
-                pubkey: SystemProgram.programId,
-                isSigner: false,
-                isWritable: false,
-            },
-            {
-                pubkey: TOKEN_PROGRAM_ID,
-                isSigner: false,
-                isWritable: false,
-            },
-        ],
-    });
+function encodeObjectContextEntry$1([key, value]) {
+  return `${key}=${encodeValue$1(value)}`;
 }
-function parseSplAccount(dataOrInfo) {
-    if (dataOrInfo === null) {
-        return null;
-    }
-    const data = "executable" in dataOrInfo ? dataOrInfo.data : dataOrInfo;
-    // if (data.length === 82) return null; // token mint
-    try {
-        return AccountLayout$1.decode(data);
+function encodeContextObject$1(context) {
+  const searchParamsString = Object.entries(context).map(encodeObjectContextEntry$1).join("&");
+  return btoa(searchParamsString);
+}
+function getErrorMessage$1(code, context = {}) {
+  {
+    let decodingAdviceMessage = `Solana error #${code}; Decode this error by running \`npx @solana/errors decode -- ${code}`;
+    if (Object.keys(context).length) {
+      decodingAdviceMessage += ` '${encodeContextObject$1(context)}'`;
     }
-    catch (e) {
-        console.error(e);
+    return `${decodingAdviceMessage}\``;
+  }
+}
+var SolanaError$1 = class extends Error {
+  cause = this.cause;
+  context;
+  constructor(...[code, contextAndErrorOptions]) {
+    let context;
+    let errorOptions;
+    if (contextAndErrorOptions) {
+      const { cause, ...contextRest } = contextAndErrorOptions;
+      if (cause) {
+        errorOptions = { cause };
+      }
+      if (Object.keys(contextRest).length > 0) {
+        context = contextRest;
+      }
     }
-    return null;
+    const message = getErrorMessage$1(code, context);
+    super(message, errorOptions);
+    this.context = {
+      __code: code,
+      ...context
+    };
+    this.name = "SolanaError";
+  }
+};
+
+var padBytes$1 = (bytes, length) => {
+  if (bytes.length >= length) return bytes;
+  const paddedBytes = new Uint8Array(length).fill(0);
+  paddedBytes.set(bytes);
+  return paddedBytes;
+};
+var fixBytes$1 = (bytes, length) => padBytes$1(bytes.length <= length ? bytes : bytes.slice(0, length), length);
+function getEncodedSize$1(value, encoder) {
+  return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
 }
-function isWalletCorrectATA(walletAddress, data) {
-    const decoded = parseSplAccount(data);
-    if (!decoded)
-        return false;
-    const [realAta] = findAssociatedTokenAddress(decoded.owner, decoded.mint);
-    return realAta.equals(new PublicKey(walletAddress));
+function createEncoder$1(encoder) {
+  return Object.freeze({
+    ...encoder,
+    encode: (value) => {
+      const bytes = new Uint8Array(getEncodedSize$1(value, encoder));
+      encoder.write(value, bytes, 0);
+      return bytes;
+    }
+  });
 }
-/**
- * Requests account from blockchain and returns result with account type
- * @param account address of account
- * @returns account info and account type
- */
-function getAccountWithType(connection, account) {
-    return __awaiter(this, void 0, void 0, function* () {
-        account = new PublicKey(account);
-        const accountData = yield getAccountInfo(connection, account);
-        if (!accountData)
-            return [null, AccountType$1.NotExists];
-        if (accountData.owner.equals(TOKEN_PROGRAM_ID)) {
-            return isWalletCorrectATA(account, accountData.data)
-                ? [accountData, AccountType$1.CorrectATA]
-                : [accountData, AccountType$1.Token];
-        }
-        if (accountData.owner.equals(SystemProgram.programId))
-            return [accountData, AccountType$1.System];
-        return [accountData, AccountType$1.Unknown];
-    });
+function createDecoder$1(decoder) {
+  return Object.freeze({
+    ...decoder,
+    decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
+  });
 }
-/**
- * Returns balance of specified wallet in native tokens
- * @param wallet wallet to inspect
- */
-function getNativeWalletBalance(connection, wallet) {
-    return __awaiter(this, void 0, void 0, function* () {
-        wallet = new PublicKey(wallet);
-        const result = yield connection.getBalance(wallet);
-        return new BN(result.toString());
-    });
+function isFixedSize$1(codec) {
+  return "fixedSize" in codec && typeof codec.fixedSize === "number";
 }
-/**
- * Returns balance of associated wallet in SPL-tokens
- * @param originalWallet native tokens wallet address
- * @param tokenMint mint of SPL-Token
- */
-function getAssocSPLWalletBalance(connection, originalWallet, tokenMint) {
-    return __awaiter(this, void 0, void 0, function* () {
-        originalWallet = new PublicKey(originalWallet);
-        tokenMint = new PublicKey(tokenMint);
-        const [wallet] = findAssociatedTokenAddress(originalWallet, tokenMint);
-        const result = yield connection.getTokenAccountBalance(wallet, "finalized");
-        return new BN(result.value.amount);
+function combineCodec$1(encoder, decoder) {
+  if (isFixedSize$1(encoder) !== isFixedSize$1(decoder)) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$1);
+  }
+  if (isFixedSize$1(encoder) && isFixedSize$1(decoder) && encoder.fixedSize !== decoder.fixedSize) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$1, {
+      decoderFixedSize: decoder.fixedSize,
+      encoderFixedSize: encoder.fixedSize
     });
-}
-/**
- * Returns balance of specified wallet in SPL-tokens
- * @param wallet spl-tokens wallet address
- */
-function getSPLWalletBalance(connection, wallet) {
-    return __awaiter(this, void 0, void 0, function* () {
-        wallet = new PublicKey(wallet);
-        const result = yield connection.getTokenAccountBalance(wallet, "finalized");
-        return new BN(result.value.amount);
+  }
+  if (!isFixedSize$1(encoder) && !isFixedSize$1(decoder) && encoder.maxSize !== decoder.maxSize) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$1, {
+      decoderMaxSize: decoder.maxSize,
+      encoderMaxSize: encoder.maxSize
     });
+  }
+  return {
+    ...decoder,
+    ...encoder,
+    decode: decoder.decode,
+    encode: encoder.encode,
+    read: decoder.read,
+    write: encoder.write
+  };
 }
-/**
- * Gets list of user's SPL-token accounts
- * @param owner owner of the SPL wallets
- * @returns list of accounts with amount on them
- */
-function getAllTokenAccountsWithBalances(connection, owner) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const walletsData = yield connection.getParsedTokenAccountsByOwner(new PublicKey(owner), { programId: TOKEN_PROGRAM_ID });
-        const wallets = walletsData.value;
-        return wallets.map((wallet) => {
-            const tokenInfo = wallet.account.data.parsed;
-            return {
-                address: wallet.pubkey,
-                mint: new PublicKey(tokenInfo.info.mint),
-                amount: new BN(tokenInfo.info.tokenAmount.amount),
-                decimals: tokenInfo.info.tokenAmount.decimals,
-                isInitialized: true,
-                isNative: tokenInfo.info.isNative,
-                owner: new PublicKey(tokenInfo.info.owner),
-            };
-        });
+function assertByteArrayIsNotEmptyForCodec$1(codecDescription, bytes, offset = 0) {
+  if (bytes.length - offset <= 0) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$1, {
+      codecDescription
     });
+  }
 }
-/**
- * Gets list of user's tokenMint token accounts
- * @param tokenMint
- * @param owner owner of the wallets
- * @returns list of accounts with amount on them
- */
-function getTokenAccountsWithBalance(connection, tokenMint, owner) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const walletsData = yield connection.getParsedTokenAccountsByOwner(new PublicKey(owner), { mint: new PublicKey(tokenMint) });
-        const wallets = walletsData.value;
-        return wallets.map((wallet) => {
-            const tokenInfo = wallet.account.data.parsed;
-            return {
-                address: wallet.pubkey,
-                mint: new PublicKey(tokenInfo.info.mint),
-                amount: new BN(tokenInfo.info.tokenAmount.amount),
-                decimals: tokenInfo.info.tokenAmount.decimals,
-                isInitialized: true,
-                isNative: tokenInfo.info.isNative,
-                owner: new PublicKey(tokenInfo.info.owner),
-            };
-        });
+function assertByteArrayHasEnoughBytesForCodec$1(codecDescription, expected, bytes, offset = 0) {
+  const bytesLength = bytes.length - offset;
+  if (bytesLength < expected) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$1, {
+      bytesLength,
+      codecDescription,
+      expected
     });
+  }
 }
-/**
- * Builds transaction to transfer&wrap native sol from src wallet to dst wallet
- * @param amount number of lamports to transfer and wrap
- * @param transferFrom source native account
- * @param transferTo destination wallet
- * @returns transaction to transfer&wrap sol
- */
-function buildReplenishWsolBalanceTransaction(amount, transferFrom, transferTo) {
-    transferFrom = new PublicKey(transferFrom);
-    transferTo = new PublicKey(transferTo);
-    const tx = new Transaction();
-    tx.add(SystemProgram.transfer({
-        fromPubkey: transferFrom,
-        toPubkey: transferTo,
-        lamports: new BN(amount).toNumber(),
-    }));
-    tx.add(
-    // sync native
-    new TransactionInstruction({
-        keys: [{ pubkey: transferTo, isSigner: false, isWritable: true }],
-        programId: TOKEN_PROGRAM_ID,
-        data: buffer.Buffer.from([17]),
-    }));
-    tx.feePayer = transferFrom;
-    return tx;
+
+// src/add-codec-size-prefix.ts
+function addEncoderSizePrefix(encoder, prefix) {
+  const write = (value, bytes, offset) => {
+    const encoderBytes = encoder.encode(value);
+    offset = prefix.write(encoderBytes.length, bytes, offset);
+    bytes.set(encoderBytes, offset);
+    return offset + encoderBytes.length;
+  };
+  if (isFixedSize$1(prefix) && isFixedSize$1(encoder)) {
+    return createEncoder$1({ ...encoder, fixedSize: prefix.fixedSize + encoder.fixedSize, write });
+  }
+  const prefixMaxSize = isFixedSize$1(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
+  const encoderMaxSize = isFixedSize$1(encoder) ? encoder.fixedSize : encoder.maxSize ?? null;
+  const maxSize = prefixMaxSize !== null && encoderMaxSize !== null ? prefixMaxSize + encoderMaxSize : null;
+  return createEncoder$1({
+    ...encoder,
+    ...maxSize !== null ? { maxSize } : {},
+    getSizeFromValue: (value) => {
+      const encoderSize = getEncodedSize$1(value, encoder);
+      return getEncodedSize$1(encoderSize, prefix) + encoderSize;
+    },
+    write
+  });
 }
-/**
- * Builds transaction that wraps specified amount of lamports into spl, if account is missing will create it
- * @param amount lamports to wrap, ATA will contain exact amount of lamports
- * @param owner owner of created wallet
- */
-function updateWsolBalance(connection, amount, owner) {
-    return __awaiter(this, void 0, void 0, function* () {
-        owner = new PublicKey(owner);
-        const tx = new Transaction();
-        const [wSolATA] = findAssociatedTokenAddress(owner, WRAPPED_SOL_MINT);
-        const existingATA = yield getAccountInfo(connection, wSolATA);
-        let amountToWrap = new BN(amount);
-        if (existingATA === null) {
-            tx.add(createAssociatedWalletInstruction(WRAPPED_SOL_MINT, wSolATA, owner, owner));
-        }
-        else {
-            const parsed = parseSplAccount(existingATA.data);
-            if (!parsed)
-                throw new Error("WSol account exists, but failed to decode its content");
-            const parsedAmount = new BN(parsed.amount.toString());
-            if (amountToWrap.lte(parsedAmount))
-                return null; // don't need to wrap
-            amountToWrap = amountToWrap.sub(parsedAmount);
-        }
-        const replenishTx = buildReplenishWsolBalanceTransaction(amountToWrap, owner, wSolATA);
-        tx.add(replenishTx);
-        return tx;
-    });
+function addDecoderSizePrefix(decoder, prefix) {
+  const read = (bytes, offset) => {
+    const [bigintSize, decoderOffset] = prefix.read(bytes, offset);
+    const size = Number(bigintSize);
+    offset = decoderOffset;
+    if (offset > 0 || bytes.length > size) {
+      bytes = bytes.slice(offset, offset + size);
+    }
+    assertByteArrayHasEnoughBytesForCodec$1("addDecoderSizePrefix", size, bytes);
+    return [decoder.decode(bytes), offset + size];
+  };
+  if (isFixedSize$1(prefix) && isFixedSize$1(decoder)) {
+    return createDecoder$1({ ...decoder, fixedSize: prefix.fixedSize + decoder.fixedSize, read });
+  }
+  const prefixMaxSize = isFixedSize$1(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
+  const decoderMaxSize = isFixedSize$1(decoder) ? decoder.fixedSize : decoder.maxSize ?? null;
+  const maxSize = prefixMaxSize !== null && decoderMaxSize !== null ? prefixMaxSize + decoderMaxSize : null;
+  return createDecoder$1({ ...decoder, ...maxSize !== null ? { maxSize } : {}, read });
 }
-/**
- * Checks existance of associated wallet for specified token
- * @param mintAccount mint account of SPL-token
- * @param originalWallet account of solana wallet
- * @returns true if account exists
- */
-function checkIfAssociatedWalletExists(connection, mintAccount, originalWallet) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const [walletAccount] = findAssociatedTokenAddress(originalWallet, mintAccount);
-        const accountData = yield getAccountInfo(connection, walletAccount);
-        return accountData !== null;
-    });
+function addCodecSizePrefix(codec, prefix) {
+  return combineCodec$1(addEncoderSizePrefix(codec, prefix), addDecoderSizePrefix(codec, prefix));
 }
-function getTransactionAccountsForSimulationDiff(connection, tx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const result = new Set();
-        if ("version" in tx) {
-            const ALTs = tx.message.addressTableLookups.map((alt) => alt.accountKey);
-            const fetchedALTs = yield connection.getMultipleAccountsInfo(ALTs);
-            const parsedALTs = fetchedALTs
-                .map((fetched, i) => fetched
-                ? new AddressLookupTableAccount({
-                    state: AddressLookupTableAccount.deserialize(fetched.data),
-                    key: ALTs[i],
-                })
-                : null)
-                .filter((x) => x != null);
-            const accGetter = tx.message.getAccountKeys({
-                addressLookupTableAccounts: parsedALTs,
-            });
-            const staticWritableOrSignerAccounts = [];
-            for (let idx = 0; idx < accGetter.staticAccountKeys.length; idx += 1) {
-                if (tx.message.isAccountSigner(idx) || tx.message.isAccountWritable(idx))
-                    staticWritableOrSignerAccounts.push(accGetter.staticAccountKeys[idx]);
-            }
-            for (const acc of [
-                ...staticWritableOrSignerAccounts,
-                ...((_b = (_a = accGetter.accountKeysFromLookups) === null || _a === void 0 ? void 0 : _a.writable) !== null && _b !== void 0 ? _b : []),
-            ]) {
-                result.add(acc.toBase58());
-            }
-        }
-        else {
-            const compiled = tx.compileMessage();
-            for (let idx = 0; idx < compiled.accountKeys.length; idx += 1) {
-                if (compiled.isAccountSigner(idx) || compiled.isAccountWritable(idx))
-                    result.add(compiled.staticAccountKeys[idx].toBase58());
-            }
-        }
-        return Array.from(result);
-    });
+
+// src/fix-codec-size.ts
+function fixEncoderSize$1(encoder, fixedBytes) {
+  return createEncoder$1({
+    fixedSize: fixedBytes,
+    write: (value, bytes, offset) => {
+      const variableByteArray = encoder.encode(value);
+      const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
+      bytes.set(fixedByteArray, offset);
+      return offset + fixedBytes;
+    }
+  });
 }
-function parseMultipleAccounts(accounts) {
-    return accounts.map((account) => {
-        var _a, _b;
-        let parsedSplAccount;
-        if (account) {
-            const owner = new PublicKey(account.owner);
-            if (owner.equals(TOKEN_PROGRAM_ID)) {
-                if (account.data instanceof buffer.Buffer) {
-                    parsedSplAccount = parseSplAccount(account.data);
-                }
-                else if (account.data instanceof Array) {
-                    parsedSplAccount = parseSplAccount(buffer.Buffer.from(account.data[0], account.data[1]));
-                }
-            }
-        }
-        const parsedAccount = {
-            balance: (_a = account === null || account === void 0 ? void 0 : account.lamports) !== null && _a !== void 0 ? _a : 0,
-        };
-        if (parsedSplAccount) {
-            parsedAccount.spl = {
-                mint: parsedSplAccount.mint,
-                owner: parsedSplAccount.owner,
-                balance: (_b = parsedSplAccount.amount) !== null && _b !== void 0 ? _b : BigInt(0),
-            };
-        }
-        return parsedAccount;
-    });
+function fixDecoderSize$1(decoder, fixedBytes) {
+  return createDecoder$1({
+    fixedSize: fixedBytes,
+    read: (bytes, offset) => {
+      assertByteArrayHasEnoughBytesForCodec$1("fixCodecSize", fixedBytes, bytes, offset);
+      if (offset > 0 || bytes.length > fixedBytes) {
+        bytes = bytes.slice(offset, offset + fixedBytes);
+      }
+      if (isFixedSize$1(decoder)) {
+        bytes = fixBytes$1(bytes, decoder.fixedSize);
+      }
+      const [value] = decoder.read(bytes, 0);
+      return [value, offset + fixedBytes];
+    }
+  });
 }
-function getSplDiff(pre, post) {
-    var _a, _b, _c, _d, _e, _f;
-    const preBalance = (_a = pre === null || pre === void 0 ? void 0 : pre.balance) !== null && _a !== void 0 ? _a : BigInt(0);
-    const postBalance = (_b = post === null || post === void 0 ? void 0 : post.balance) !== null && _b !== void 0 ? _b : BigInt(0);
-    return {
-        mint: (_c = pre === null || pre === void 0 ? void 0 : pre.mint) !== null && _c !== void 0 ? _c : post === null || post === void 0 ? void 0 : post.mint,
-        owner: (_d = pre === null || pre === void 0 ? void 0 : pre.owner) !== null && _d !== void 0 ? _d : post === null || post === void 0 ? void 0 : post.owner,
-        preBalance: (_e = pre === null || pre === void 0 ? void 0 : pre.balance) !== null && _e !== void 0 ? _e : 0,
-        postBalance: (_f = post === null || post === void 0 ? void 0 : post.balance) !== null && _f !== void 0 ? _f : 0,
-        diff: postBalance - preBalance,
-    };
+function fixCodecSize$1(codec, fixedBytes) {
+  return combineCodec$1(fixEncoderSize$1(codec, fixedBytes), fixDecoderSize$1(codec, fixedBytes));
 }
-function getTransactionDiff(connection, tx, txAccounts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const accountsStrings = txAccounts
-            ? txAccounts.map((acc) => acc.toBase58())
-            : yield getTransactionAccountsForSimulationDiff(connection, tx);
-        const accountsPubKeys = txAccounts !== null && txAccounts !== void 0 ? txAccounts : accountsStrings.map((key) => new PublicKey(key));
-        let [accountsInfo, simulatedTx] = yield Promise.all([
-            connection.getMultipleAccountsInfo(accountsPubKeys),
-            connection.simulateTransaction(tx, {
-                replaceRecentBlockhash: true,
-                accounts: {
-                    encoding: "base64",
-                    addresses: accountsStrings,
-                },
-            }),
-        ]);
-        if (simulatedTx.value.err !== null)
-            throw new Error(JSON.stringify({
-                err: simulatedTx.value.err,
-                logs: simulatedTx.value.logs,
-            }));
-        const simulatesInfo = simulatedTx.value.accounts;
-        const preBalances = parseMultipleAccounts(accountsInfo);
-        const postBalances = parseMultipleAccounts(simulatesInfo);
-        const balancesDiff = accountsPubKeys.reduce((map, pubKey, i) => {
-            var _a;
-            if ((_a = accountsInfo[i]) === null || _a === void 0 ? void 0 : _a.executable) {
-                return map;
-            }
-            const preBalance = preBalances[i];
-            const postBalance = postBalances[i];
-            const diff = {
-                pubKey: pubKey,
-                preBalance: preBalance.balance,
-                postBalance: postBalance.balance,
-                diff: postBalance.balance - preBalance.balance,
-            };
-            if (preBalance.spl || postBalance.spl) {
-                const splDiff = getSplDiff(preBalance.spl, postBalance.spl);
-                if (splDiff.diff) {
-                    diff.spl = splDiff;
-                }
-            }
-            if (diff.diff || diff.spl) {
-                map.set(pubKey.toString(), diff);
-            }
-            return map;
-        }, new Map());
-        return balancesDiff;
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec$1(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$1, {
+      codecDescription,
+      max,
+      min,
+      value
     });
+  }
 }
-
-var spl = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	get AccountType () { return AccountType$1; },
-	getTokenInfo: getTokenInfo,
-	createAssociatedWalletInstruction: createAssociatedWalletInstruction,
-	parseSplAccount: parseSplAccount,
-	isWalletCorrectATA: isWalletCorrectATA,
-	getAccountWithType: getAccountWithType,
-	getNativeWalletBalance: getNativeWalletBalance,
-	getAssocSPLWalletBalance: getAssocSPLWalletBalance,
-	getSPLWalletBalance: getSPLWalletBalance,
-	getAllTokenAccountsWithBalances: getAllTokenAccountsWithBalances,
-	getTokenAccountsWithBalance: getTokenAccountsWithBalance,
-	buildReplenishWsolBalanceTransaction: buildReplenishWsolBalanceTransaction,
-	updateWsolBalance: updateWsolBalance,
-	checkIfAssociatedWalletExists: checkIfAssociatedWalletExists,
-	getTransactionAccountsForSimulationDiff: getTransactionAccountsForSimulationDiff,
-	parseMultipleAccounts: parseMultipleAccounts,
-	getSplDiff: getSplDiff,
-	getTransactionDiff: getTransactionDiff
-});
-
-const deBridge = "DEbrdGj3HsRsAzx6uH4MKyREKxVAfBydijLUF3ygsFfh";
-const settings = "DeSetTwWhjZq6Pz9Kfdo1KoS5NqtsM6G8ERbX4SSCSft";
-const dlnSrc = "src5qyZHqTqecJV4aY6Cb6zDZLMDzrDKKezs22MPHr4";
-const dlnDst = "dst5MGcFPoBeREFAA5E3tU5ij8m5uVYwkzkSAbsLbNo";
-const dlnExecutor = "exe59FS5cojZkPJVDFDV8RnXCC7wd6yoBjsUtqH7Zai";
-
-var programs = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	deBridge: deBridge,
-	settings: settings,
-	dlnSrc: dlnSrc,
-	dlnDst: dlnDst,
-	dlnExecutor: dlnExecutor
-});
-
-/** Address of the SPL Token program */
-new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
-/** Address of the SPL Token 2022 program */
-new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
-/** Address of the SPL Associated Token Account program */
-new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
-/** Address of the special mint for wrapped native SOL in spl-token */
-new PublicKey('So11111111111111111111111111111111111111112');
-/** Address of the special mint for wrapped native SOL in spl-token-2022 */
-new PublicKey('9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP');
-
-/** Instructions defined by the program */
-var TokenInstruction;
-(function (TokenInstruction) {
-    TokenInstruction[TokenInstruction["InitializeMint"] = 0] = "InitializeMint";
-    TokenInstruction[TokenInstruction["InitializeAccount"] = 1] = "InitializeAccount";
-    TokenInstruction[TokenInstruction["InitializeMultisig"] = 2] = "InitializeMultisig";
-    TokenInstruction[TokenInstruction["Transfer"] = 3] = "Transfer";
-    TokenInstruction[TokenInstruction["Approve"] = 4] = "Approve";
-    TokenInstruction[TokenInstruction["Revoke"] = 5] = "Revoke";
-    TokenInstruction[TokenInstruction["SetAuthority"] = 6] = "SetAuthority";
-    TokenInstruction[TokenInstruction["MintTo"] = 7] = "MintTo";
-    TokenInstruction[TokenInstruction["Burn"] = 8] = "Burn";
-    TokenInstruction[TokenInstruction["CloseAccount"] = 9] = "CloseAccount";
-    TokenInstruction[TokenInstruction["FreezeAccount"] = 10] = "FreezeAccount";
-    TokenInstruction[TokenInstruction["ThawAccount"] = 11] = "ThawAccount";
-    TokenInstruction[TokenInstruction["TransferChecked"] = 12] = "TransferChecked";
-    TokenInstruction[TokenInstruction["ApproveChecked"] = 13] = "ApproveChecked";
-    TokenInstruction[TokenInstruction["MintToChecked"] = 14] = "MintToChecked";
-    TokenInstruction[TokenInstruction["BurnChecked"] = 15] = "BurnChecked";
-    TokenInstruction[TokenInstruction["InitializeAccount2"] = 16] = "InitializeAccount2";
-    TokenInstruction[TokenInstruction["SyncNative"] = 17] = "SyncNative";
-    TokenInstruction[TokenInstruction["InitializeAccount3"] = 18] = "InitializeAccount3";
-    TokenInstruction[TokenInstruction["InitializeMultisig2"] = 19] = "InitializeMultisig2";
-    TokenInstruction[TokenInstruction["InitializeMint2"] = 20] = "InitializeMint2";
-    TokenInstruction[TokenInstruction["GetAccountDataSize"] = 21] = "GetAccountDataSize";
-    TokenInstruction[TokenInstruction["InitializeImmutableOwner"] = 22] = "InitializeImmutableOwner";
-    TokenInstruction[TokenInstruction["AmountToUiAmount"] = 23] = "AmountToUiAmount";
-    TokenInstruction[TokenInstruction["UiAmountToAmount"] = 24] = "UiAmountToAmount";
-    TokenInstruction[TokenInstruction["InitializeMintCloseAuthority"] = 25] = "InitializeMintCloseAuthority";
-    TokenInstruction[TokenInstruction["TransferFeeExtension"] = 26] = "TransferFeeExtension";
-    TokenInstruction[TokenInstruction["ConfidentialTransferExtension"] = 27] = "ConfidentialTransferExtension";
-    TokenInstruction[TokenInstruction["DefaultAccountStateExtension"] = 28] = "DefaultAccountStateExtension";
-    TokenInstruction[TokenInstruction["Reallocate"] = 29] = "Reallocate";
-    TokenInstruction[TokenInstruction["MemoTransferExtension"] = 30] = "MemoTransferExtension";
-    TokenInstruction[TokenInstruction["CreateNativeMint"] = 31] = "CreateNativeMint";
-    TokenInstruction[TokenInstruction["InitializeNonTransferableMint"] = 32] = "InitializeNonTransferableMint";
-    TokenInstruction[TokenInstruction["InterestBearingMintExtension"] = 33] = "InterestBearingMintExtension";
-    TokenInstruction[TokenInstruction["CpiGuardExtension"] = 34] = "CpiGuardExtension";
-    TokenInstruction[TokenInstruction["InitializePermanentDelegate"] = 35] = "InitializePermanentDelegate";
-    TokenInstruction[TokenInstruction["TransferHookExtension"] = 36] = "TransferHookExtension";
-    // ConfidentialTransferFeeExtension = 37,
-    // WithdrawalExcessLamports = 38,
-    TokenInstruction[TokenInstruction["MetadataPointerExtension"] = 39] = "MetadataPointerExtension";
-    TokenInstruction[TokenInstruction["GroupPointerExtension"] = 40] = "GroupPointerExtension";
-    TokenInstruction[TokenInstruction["GroupMemberPointerExtension"] = 41] = "GroupMemberPointerExtension";
-    // ConfidentialMintBurnExtension = 42,
-    TokenInstruction[TokenInstruction["ScaledUiAmountExtension"] = 43] = "ScaledUiAmountExtension";
-    TokenInstruction[TokenInstruction["PausableExtension"] = 44] = "PausableExtension";
-})(TokenInstruction || (TokenInstruction = {}));
-
-/** TODO: docs */
-struct$1([
-    u8$1('instruction'),
-    u64$1('amount'),
-]);
-
-var AccountType;
-(function (AccountType) {
-    AccountType[AccountType["Uninitialized"] = 0] = "Uninitialized";
-    AccountType[AccountType["Mint"] = 1] = "Mint";
-    AccountType[AccountType["Account"] = 2] = "Account";
-})(AccountType || (AccountType = {}));
-
-/** Buffer layout for de/serializing a multisig */
-const MultisigLayout = struct$1([
-    u8$1('m'),
-    u8$1('n'),
-    bool$1('isInitialized'),
-    publicKey$4('signer1'),
-    publicKey$4('signer2'),
-    publicKey$4('signer3'),
-    publicKey$4('signer4'),
-    publicKey$4('signer5'),
-    publicKey$4('signer6'),
-    publicKey$4('signer7'),
-    publicKey$4('signer8'),
-    publicKey$4('signer9'),
-    publicKey$4('signer10'),
-    publicKey$4('signer11'),
-]);
-/** Byte length of a multisig */
-MultisigLayout.span;
-
-/** Token account state as stored by the program */
-var AccountState;
-(function (AccountState) {
-    AccountState[AccountState["Uninitialized"] = 0] = "Uninitialized";
-    AccountState[AccountState["Initialized"] = 1] = "Initialized";
-    AccountState[AccountState["Frozen"] = 2] = "Frozen";
-})(AccountState || (AccountState = {}));
-/** Buffer layout for de/serializing a token account */
-const AccountLayout = struct$1([
-    publicKey$4('mint'),
-    publicKey$4('owner'),
-    u64$1('amount'),
-    u32$1('delegateOption'),
-    publicKey$4('delegate'),
-    u8$1('state'),
-    u32$1('isNativeOption'),
-    u64$1('isNative'),
-    u64$1('delegatedAmount'),
-    u32$1('closeAuthorityOption'),
-    publicKey$4('closeAuthority'),
-]);
-/** Byte length of a token account */
-AccountLayout.span;
-
-var CpiGuardInstruction;
-(function (CpiGuardInstruction) {
-    CpiGuardInstruction[CpiGuardInstruction["Enable"] = 0] = "Enable";
-    CpiGuardInstruction[CpiGuardInstruction["Disable"] = 1] = "Disable";
-})(CpiGuardInstruction || (CpiGuardInstruction = {}));
-/** TODO: docs */
-struct$1([u8$1('instruction'), u8$1('cpiGuardInstruction')]);
-
-/** Buffer layout for de/serializing a CPI Guard extension */
-const CpiGuardLayout = struct$1([bool$1('lockCpi')]);
-CpiGuardLayout.span;
-
-var DefaultAccountStateInstruction;
-(function (DefaultAccountStateInstruction) {
-    DefaultAccountStateInstruction[DefaultAccountStateInstruction["Initialize"] = 0] = "Initialize";
-    DefaultAccountStateInstruction[DefaultAccountStateInstruction["Update"] = 1] = "Update";
-})(DefaultAccountStateInstruction || (DefaultAccountStateInstruction = {}));
-/** TODO: docs */
-struct$1([
-    u8$1('instruction'),
-    u8$1('defaultAccountStateInstruction'),
-    u8$1('accountState'),
-]);
-
-/** Buffer layout for de/serializing a transfer fee config extension */
-const DefaultAccountStateLayout = struct$1([u8$1('state')]);
-DefaultAccountStateLayout.span;
-
-// src/codes.ts
-var SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$1 = 8078e3;
-var SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$1 = 8078001;
-var SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$1 = 8078004;
-var SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$1 = 8078005;
-var SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$1 = 8078006;
-var SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS$1 = 8078007;
-var SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$1 = 8078011;
-
-// src/context.ts
-function encodeValue$1(value) {
-  if (Array.isArray(value)) {
-    const commaSeparatedValues = value.map(encodeValue$1).join(
-      "%2C%20"
-      /* ", " */
-    );
-    return "%5B" + commaSeparatedValues + /* "]" */
-    "%5D";
-  } else if (typeof value === "bigint") {
-    return `${value}n`;
-  } else {
-    return encodeURIComponent(
-      String(
-        value != null && Object.getPrototypeOf(value) === null ? (
-          // Plain objects with no prototype don't have a `toString` method.
-          // Convert them before stringifying them.
-          { ...value }
-        ) : value
-      )
-    );
-  }
-}
-function encodeObjectContextEntry$1([key, value]) {
-  return `${key}=${encodeValue$1(value)}`;
+function isLittleEndian$1(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
 }
-function encodeContextObject$1(context) {
-  const searchParamsString = Object.entries(context).map(encodeObjectContextEntry$1).join("&");
-  return btoa(searchParamsString);
+function numberEncoderFactory$1(input) {
+  return createEncoder$1({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec$1(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian$1(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
 }
-function getErrorMessage$1(code, context = {}) {
-  {
-    let decodingAdviceMessage = `Solana error #${code}; Decode this error by running \`npx @solana/errors decode -- ${code}`;
-    if (Object.keys(context).length) {
-      decodingAdviceMessage += ` '${encodeContextObject$1(context)}'`;
+function numberDecoderFactory$1(input) {
+  return createDecoder$1({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      assertByteArrayIsNotEmptyForCodec$1(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec$1(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer$1(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian$1(input.config)), offset + input.size];
     }
-    return `${decodingAdviceMessage}\``;
-  }
-}
-var SolanaError$1 = class extends Error {
-  cause = this.cause;
-  context;
-  constructor(...[code, contextAndErrorOptions]) {
-    let context;
-    let errorOptions;
-    if (contextAndErrorOptions) {
-      const { cause, ...contextRest } = contextAndErrorOptions;
-      if (cause) {
-        errorOptions = { cause };
-      }
-      if (Object.keys(contextRest).length > 0) {
-        context = contextRest;
-      }
-    }
-    const message = getErrorMessage$1(code, context);
-    super(message, errorOptions);
-    this.context = {
-      __code: code,
-      ...context
-    };
-    this.name = "SolanaError";
-  }
-};
-
-var padBytes$1 = (bytes, length) => {
-  if (bytes.length >= length) return bytes;
-  const paddedBytes = new Uint8Array(length).fill(0);
-  paddedBytes.set(bytes);
-  return paddedBytes;
-};
-var fixBytes$1 = (bytes, length) => padBytes$1(bytes.length <= length ? bytes : bytes.slice(0, length), length);
-function getEncodedSize$1(value, encoder) {
-  return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
-}
-function createEncoder$1(encoder) {
-  return Object.freeze({
-    ...encoder,
-    encode: (value) => {
-      const bytes = new Uint8Array(getEncodedSize$1(value, encoder));
-      encoder.write(value, bytes, 0);
-      return bytes;
-    }
-  });
-}
-function createDecoder$1(decoder) {
-  return Object.freeze({
-    ...decoder,
-    decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
-  });
-}
-function isFixedSize$1(codec) {
-  return "fixedSize" in codec && typeof codec.fixedSize === "number";
-}
-function combineCodec$1(encoder, decoder) {
-  if (isFixedSize$1(encoder) !== isFixedSize$1(decoder)) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$1);
-  }
-  if (isFixedSize$1(encoder) && isFixedSize$1(decoder) && encoder.fixedSize !== decoder.fixedSize) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$1, {
-      decoderFixedSize: decoder.fixedSize,
-      encoderFixedSize: encoder.fixedSize
-    });
-  }
-  if (!isFixedSize$1(encoder) && !isFixedSize$1(decoder) && encoder.maxSize !== decoder.maxSize) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$1, {
-      decoderMaxSize: decoder.maxSize,
-      encoderMaxSize: encoder.maxSize
-    });
-  }
-  return {
-    ...decoder,
-    ...encoder,
-    decode: decoder.decode,
-    encode: encoder.encode,
-    read: decoder.read,
-    write: encoder.write
-  };
-}
-function assertByteArrayIsNotEmptyForCodec$1(codecDescription, bytes, offset = 0) {
-  if (bytes.length - offset <= 0) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$1, {
-      codecDescription
-    });
-  }
-}
-function assertByteArrayHasEnoughBytesForCodec$1(codecDescription, expected, bytes, offset = 0) {
-  const bytesLength = bytes.length - offset;
-  if (bytesLength < expected) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$1, {
-      bytesLength,
-      codecDescription,
-      expected
-    });
-  }
-}
-
-// src/add-codec-size-prefix.ts
-function addEncoderSizePrefix(encoder, prefix) {
-  const write = (value, bytes, offset) => {
-    const encoderBytes = encoder.encode(value);
-    offset = prefix.write(encoderBytes.length, bytes, offset);
-    bytes.set(encoderBytes, offset);
-    return offset + encoderBytes.length;
-  };
-  if (isFixedSize$1(prefix) && isFixedSize$1(encoder)) {
-    return createEncoder$1({ ...encoder, fixedSize: prefix.fixedSize + encoder.fixedSize, write });
-  }
-  const prefixMaxSize = isFixedSize$1(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
-  const encoderMaxSize = isFixedSize$1(encoder) ? encoder.fixedSize : encoder.maxSize ?? null;
-  const maxSize = prefixMaxSize !== null && encoderMaxSize !== null ? prefixMaxSize + encoderMaxSize : null;
-  return createEncoder$1({
-    ...encoder,
-    ...maxSize !== null ? { maxSize } : {},
-    getSizeFromValue: (value) => {
-      const encoderSize = getEncodedSize$1(value, encoder);
-      return getEncodedSize$1(encoderSize, prefix) + encoderSize;
-    },
-    write
-  });
-}
-function addDecoderSizePrefix(decoder, prefix) {
-  const read = (bytes, offset) => {
-    const [bigintSize, decoderOffset] = prefix.read(bytes, offset);
-    const size = Number(bigintSize);
-    offset = decoderOffset;
-    if (offset > 0 || bytes.length > size) {
-      bytes = bytes.slice(offset, offset + size);
-    }
-    assertByteArrayHasEnoughBytesForCodec$1("addDecoderSizePrefix", size, bytes);
-    return [decoder.decode(bytes), offset + size];
-  };
-  if (isFixedSize$1(prefix) && isFixedSize$1(decoder)) {
-    return createDecoder$1({ ...decoder, fixedSize: prefix.fixedSize + decoder.fixedSize, read });
-  }
-  const prefixMaxSize = isFixedSize$1(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
-  const decoderMaxSize = isFixedSize$1(decoder) ? decoder.fixedSize : decoder.maxSize ?? null;
-  const maxSize = prefixMaxSize !== null && decoderMaxSize !== null ? prefixMaxSize + decoderMaxSize : null;
-  return createDecoder$1({ ...decoder, ...maxSize !== null ? { maxSize } : {}, read });
-}
-function addCodecSizePrefix(codec, prefix) {
-  return combineCodec$1(addEncoderSizePrefix(codec, prefix), addDecoderSizePrefix(codec, prefix));
-}
-
-// src/fix-codec-size.ts
-function fixEncoderSize$1(encoder, fixedBytes) {
-  return createEncoder$1({
-    fixedSize: fixedBytes,
-    write: (value, bytes, offset) => {
-      const variableByteArray = encoder.encode(value);
-      const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
-      bytes.set(fixedByteArray, offset);
-      return offset + fixedBytes;
-    }
-  });
-}
-function fixDecoderSize$1(decoder, fixedBytes) {
-  return createDecoder$1({
-    fixedSize: fixedBytes,
-    read: (bytes, offset) => {
-      assertByteArrayHasEnoughBytesForCodec$1("fixCodecSize", fixedBytes, bytes, offset);
-      if (offset > 0 || bytes.length > fixedBytes) {
-        bytes = bytes.slice(offset, offset + fixedBytes);
-      }
-      if (isFixedSize$1(decoder)) {
-        bytes = fixBytes$1(bytes, decoder.fixedSize);
-      }
-      const [value] = decoder.read(bytes, 0);
-      return [value, offset + fixedBytes];
-    }
-  });
-}
-function fixCodecSize$1(codec, fixedBytes) {
-  return combineCodec$1(fixEncoderSize$1(codec, fixedBytes), fixDecoderSize$1(codec, fixedBytes));
-}
-
-// src/assertions.ts
-function assertNumberIsBetweenForCodec$1(codecDescription, min, max, value) {
-  if (value < min || value > max) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$1, {
-      codecDescription,
-      max,
-      min,
-      value
-    });
-  }
-}
-function isLittleEndian$1(config) {
-  return config?.endian === 1 /* Big */ ? false : true;
-}
-function numberEncoderFactory$1(input) {
-  return createEncoder$1({
-    fixedSize: input.size,
-    write(value, bytes, offset) {
-      if (input.range) {
-        assertNumberIsBetweenForCodec$1(input.name, input.range[0], input.range[1], value);
-      }
-      const arrayBuffer = new ArrayBuffer(input.size);
-      input.set(new DataView(arrayBuffer), value, isLittleEndian$1(input.config));
-      bytes.set(new Uint8Array(arrayBuffer), offset);
-      return offset + input.size;
-    }
-  });
-}
-function numberDecoderFactory$1(input) {
-  return createDecoder$1({
-    fixedSize: input.size,
-    read(bytes, offset = 0) {
-      assertByteArrayIsNotEmptyForCodec$1(input.name, bytes, offset);
-      assertByteArrayHasEnoughBytesForCodec$1(input.name, input.size, bytes, offset);
-      const view = new DataView(toArrayBuffer$1(bytes, offset, input.size));
-      return [input.get(view, isLittleEndian$1(input.config)), offset + input.size];
-    }
-  });
+  });
 }
 function toArrayBuffer$1(bytes, offset, length) {
   const bytesOffset = bytes.byteOffset + (offset ?? 0);
@@ -11206,6 +10753,20 @@ const MetadataPointerLayout = struct$1([
     publicKey$4('metadataAddress'),
 ]);
 MetadataPointerLayout.span;
+function getMetadataPointerState(mint) {
+    const extensionData = getExtensionData(ExtensionType.MetadataPointer, mint.tlvData);
+    if (extensionData !== null) {
+        const { authority, metadataAddress } = MetadataPointerLayout.decode(extensionData);
+        // Explicitly set None/Zero keys to null
+        return {
+            authority: authority.equals(PublicKey.default) ? null : authority,
+            metadataAddress: metadataAddress.equals(PublicKey.default) ? null : metadataAddress,
+        };
+    }
+    else {
+        return null;
+    }
+}
 
 /** Buffer layout for de/serializing a mint */
 const MintCloseAuthorityLayout = struct$1([publicKey$4('closeAuthority')]);
@@ -11446,6 +11007,35 @@ var ExtensionType;
     ExtensionType[ExtensionType["PausableConfig"] = 26] = "PausableConfig";
     ExtensionType[ExtensionType["PausableAccount"] = 27] = "PausableAccount";
 })(ExtensionType || (ExtensionType = {}));
+const TYPE_SIZE = 2;
+const LENGTH_SIZE = 2;
+function addTypeAndLengthToLen(len) {
+    return len + TYPE_SIZE + LENGTH_SIZE;
+}
+function getExtensionData(extension, tlvData) {
+    let extensionTypeIndex = 0;
+    while (addTypeAndLengthToLen(extensionTypeIndex) <= tlvData.length) {
+        const entryType = tlvData.readUInt16LE(extensionTypeIndex);
+        const entryLength = tlvData.readUInt16LE(extensionTypeIndex + TYPE_SIZE);
+        const typeIndex = addTypeAndLengthToLen(extensionTypeIndex);
+        if (entryType == extension) {
+            return tlvData.slice(typeIndex, typeIndex + entryLength);
+        }
+        extensionTypeIndex = typeIndex + entryLength;
+    }
+    return null;
+}
+function getExtensionTypes(tlvData) {
+    const extensionTypes = [];
+    let extensionTypeIndex = 0;
+    while (extensionTypeIndex < tlvData.length) {
+        const entryType = tlvData.readUInt16LE(extensionTypeIndex);
+        extensionTypes.push(entryType);
+        const entryLength = tlvData.readUInt16LE(extensionTypeIndex + TYPE_SIZE);
+        extensionTypeIndex += addTypeAndLengthToLen(entryLength);
+    }
+    return extensionTypes;
+}
 
 /** Buffer layout for de/serializing a mint */
 const MintLayout = struct$1([
@@ -11458,7 +11048,46 @@ const MintLayout = struct$1([
     publicKey$4('freezeAuthority'),
 ]);
 /** Byte length of a mint */
-MintLayout.span;
+const MINT_SIZE = MintLayout.span;
+/**
+ * Unpack a mint
+ *
+ * @param address   Mint account
+ * @param info      Mint account data
+ * @param programId SPL Token program account
+ *
+ * @return Unpacked mint
+ */
+function unpackMint(address, info, programId = TOKEN_PROGRAM_ID) {
+    if (!info)
+        throw new TokenAccountNotFoundError();
+    if (!info.owner.equals(programId))
+        throw new TokenInvalidAccountOwnerError();
+    if (info.data.length < MINT_SIZE)
+        throw new TokenInvalidAccountSizeError();
+    const rawMint = MintLayout.decode(info.data.slice(0, MINT_SIZE));
+    let tlvData = Buffer.alloc(0);
+    if (info.data.length > MINT_SIZE) {
+        if (info.data.length <= ACCOUNT_SIZE)
+            throw new TokenInvalidAccountSizeError();
+        if (info.data.length === MULTISIG_SIZE)
+            throw new TokenInvalidAccountSizeError();
+        if (info.data[ACCOUNT_SIZE] != AccountType$1.Mint)
+            throw new TokenInvalidMintError();
+        tlvData = info.data.slice(ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);
+    }
+    return {
+        address,
+        mintAuthority: rawMint.mintAuthorityOption ? rawMint.mintAuthority : null,
+        supply: rawMint.supply,
+        decimals: rawMint.decimals,
+        isInitialized: rawMint.isInitialized,
+        freezeAuthority: rawMint.freezeAuthorityOption ? rawMint.freezeAuthority : null,
+        tlvData,
+    };
+}
+
+new PublicKey('SysvarC1ock11111111111111111111111111111111');
 
 /** TODO: docs */
 struct$1([u8$1('instruction'), u64$1('amount')]);
@@ -11650,46 +11279,600 @@ Buffer.from([112, 132, 90, 90, 11, 88, 157, 87]);
 function getStringCodec() {
     return addCodecSizePrefix(getUtf8Codec$1(), getU32Codec());
 }
-getStructCodec$1([
-    ['updateAuthority', fixCodecSize$1(getBytesCodec$1(), 32)],
-    ['mint', fixCodecSize$1(getBytesCodec$1(), 32)],
-    ['name', getStringCodec()],
-    ['symbol', getStringCodec()],
-    ['uri', getStringCodec()],
-    ['additionalMetadata', getArrayCodec$1(getTupleCodec$1([getStringCodec(), getStringCodec()]))],
-]);
-
-struct$1([
-    u8$1('instruction'),
-    publicKey$4('owner'),
-]);
-
-struct$1([
-    u8$1('instruction'),
-    publicKey$4('owner'),
-]);
-
-/** The struct that represents the instruction data as it is read by the program */
-struct$1([
-    u8$1('instruction'),
-]);
+const tokenMetadataCodec = getStructCodec$1([
+    ['updateAuthority', fixCodecSize$1(getBytesCodec$1(), 32)],
+    ['mint', fixCodecSize$1(getBytesCodec$1(), 32)],
+    ['name', getStringCodec()],
+    ['symbol', getStringCodec()],
+    ['uri', getStringCodec()],
+    ['additionalMetadata', getArrayCodec$1(getTupleCodec$1([getStringCodec(), getStringCodec()]))],
+]);
+// Checks if all elements in the array are 0
+function isNonePubkey(buffer) {
+    for (let i = 0; i < buffer.length; i++) {
+        if (buffer[i] !== 0) {
+            return false;
+        }
+    }
+    return true;
+}
+// unpack byte slab into TokenMetadata
+function unpack(buffer) {
+    const data = tokenMetadataCodec.decode(buffer);
+    return isNonePubkey(data.updateAuthority)
+        ? {
+            mint: new PublicKey(data.mint),
+            name: data.name,
+            symbol: data.symbol,
+            uri: data.uri,
+            additionalMetadata: data.additionalMetadata,
+        }
+        : {
+            updateAuthority: new PublicKey(data.updateAuthority),
+            mint: new PublicKey(data.mint),
+            name: data.name,
+            symbol: data.symbol,
+            uri: data.uri,
+            additionalMetadata: data.additionalMetadata,
+        };
+}
+
+struct$1([
+    u8$1('instruction'),
+    publicKey$4('owner'),
+]);
+
+struct$1([
+    u8$1('instruction'),
+    publicKey$4('owner'),
+]);
+
+/** The struct that represents the instruction data as it is read by the program */
+struct$1([
+    u8$1('instruction'),
+]);
+
+/** TODO: docs */
+struct$1([
+    u8$1('instruction'),
+    new COptionPublicKeyLayout('closeAuthority'),
+]);
+
+/** The struct that represents the instruction data as it is read by the program */
+struct$1([
+    u8$1('instruction'),
+]);
+
+/** TODO: docs */
+struct$1([
+    u8$1('instruction'),
+    publicKey$4('delegate'),
+]);
+
+var AccountState;
+(function (AccountState) {
+    AccountState[AccountState["Uninitialized"] = 0] = "Uninitialized";
+    AccountState[AccountState["Initialized"] = 1] = "Initialized";
+    AccountState[AccountState["Frozen"] = 2] = "Frozen";
+})(AccountState || (AccountState = {}));
+const AccountLayout = struct$1([
+    publicKey$4("mint"),
+    publicKey$4("owner"),
+    u64$1("amount"),
+    u32$1("delegateOption"),
+    publicKey$4("delegate"),
+    u8$1("state"),
+    u32$1("isNativeOption"),
+    u64$1("isNative"),
+    u64$1("delegatedAmount"),
+    u32$1("closeAuthorityOption"),
+    publicKey$4("closeAuthority"),
+]);
+var AccountType;
+(function (AccountType) {
+    AccountType[AccountType["System"] = 0] = "System";
+    AccountType[AccountType["Token"] = 1] = "Token";
+    AccountType[AccountType["CorrectATA"] = 2] = "CorrectATA";
+    AccountType[AccountType["Unknown"] = 3] = "Unknown";
+    AccountType[AccountType["NotExists"] = 4] = "NotExists";
+})(AccountType || (AccountType = {}));
+/**
+ * Get name, symbol and decimals for provided token
+ * @param connection solana web3 connection
+ * @param tokenAddress address to get metaplex info for
+ * @returns
+ */
+function getTokenInfo(connection, tokenAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const tokenMetaProgramId = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+        const findMetaplexMetadataPda = (tokenMint) => PublicKey.findProgramAddressSync([
+            buffer.Buffer.from("metadata", "utf-8"),
+            tokenMetaProgramId.toBuffer(),
+            tokenMint.toBuffer(),
+        ], tokenMetaProgramId)[0];
+        const decodeMetaplexMetadataPartial = (data) => {
+            const rawName = data.subarray(65 + 4, 65 + 36); // omit first 4 bytes, size is already hardcoded
+            const rawSymbol = data.subarray(101 + 4, 115); // omit first 4 bytes, size is already hardcoded
+            const rawUri = data.subarray(115 + 4, 204); // omit first 4 bytes, size is already hardcoded
+            return {
+                uri: rawUri.toString("utf-8").replace(/\u0000/g, ""),
+                symbol: rawSymbol.toString("utf-8").replace(/\u0000/g, ""),
+                name: rawName.toString("utf-8").replace(/\u0000/g, ""),
+            };
+        };
+        const pda = findMetaplexMetadataPda(tokenAddress);
+        const [tokenAccount, pdaAccount] = yield connection.getMultipleAccountsInfo([
+            tokenAddress,
+            pda,
+        ]);
+        if (tokenAccount === null) {
+            return null;
+        }
+        const mint2022 = unpackMint(tokenAddress, tokenAccount, tokenAccount.owner);
+        const extTypes = getExtensionTypes((_a = mint2022.tlvData) !== null && _a !== void 0 ? _a : buffer.Buffer.alloc(0));
+        const tokenMetaBuf = extTypes.includes(ExtensionType.TokenMetadata)
+            ? getExtensionData(ExtensionType.TokenMetadata, mint2022.tlvData)
+            : null;
+        if (tokenMetaBuf) {
+            const meta = unpack(tokenMetaBuf);
+            return {
+                address: tokenAddress,
+                decimals: mint2022.decimals,
+                name: meta.name,
+                symbol: meta.symbol,
+                json: meta.uri,
+            };
+        }
+        if (extTypes.includes(ExtensionType.MetadataPointer)) {
+            const mpState = getMetadataPointerState(mint2022);
+            if ((mpState === null || mpState === void 0 ? void 0 : mpState.metadataAddress) &&
+                mpState.metadataAddress.equals(tokenAddress)) {
+                const inlineMetaBuf = getExtensionData(ExtensionType.TokenMetadata, mint2022.tlvData);
+                if (inlineMetaBuf) {
+                    const meta = unpack(inlineMetaBuf);
+                    return {
+                        address: tokenAddress,
+                        decimals: mint2022.decimals,
+                        name: meta.name,
+                        symbol: meta.symbol,
+                        json: meta.uri,
+                    };
+                }
+            }
+        }
+        if (pdaAccount === null || (pdaAccount === null || pdaAccount === void 0 ? void 0 : pdaAccount.lamports) === 0) {
+            return null;
+        }
+        // parse token account
+        // mint_authority - coption(pubkey) = 4 or 36
+        // supply - u64 = 8
+        // decimals - u8
+        let decimalsOffset = 12;
+        if (tokenAccount.data[0] === 1)
+            decimalsOffset += 32;
+        const decimals = tokenAccount.data[decimalsOffset];
+        const { name, symbol, uri } = decodeMetaplexMetadataPartial(pdaAccount.data);
+        return {
+            address: tokenAddress,
+            decimals,
+            name,
+            symbol,
+            json: uri,
+        };
+    });
+}
+/**
+ * Builds instruction for creation of associated wallet for specified token
+ * @param tokenMint mint account of SPL-token
+ * @param associatedAccount associated account address
+ * @param owner owner of the associated account
+ * @param payer who pays for account creation
+ */
+function createAssociatedWalletInstruction(tokenMint, associatedAccount, owner, payer, associatedTokenProramId) {
+    tokenMint = new PublicKey(tokenMint);
+    payer = new PublicKey(payer);
+    owner = new PublicKey(owner);
+    return new TransactionInstruction({
+        programId: associatedTokenProramId || ASSOCIATED_TOKEN_PROGRAM_ID,
+        data: buffer.Buffer.from([1]),
+        keys: [
+            {
+                pubkey: payer,
+                isSigner: true,
+                isWritable: true,
+            },
+            {
+                pubkey: associatedAccount,
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: owner,
+                isSigner: false,
+                isWritable: false,
+            },
+            {
+                pubkey: tokenMint,
+                isSigner: false,
+                isWritable: false,
+            },
+            {
+                pubkey: SystemProgram.programId,
+                isSigner: false,
+                isWritable: false,
+            },
+            {
+                pubkey: TOKEN_PROGRAM_ID$1,
+                isSigner: false,
+                isWritable: false,
+            },
+        ],
+    });
+}
+function parseSplAccount(dataOrInfo) {
+    if (dataOrInfo === null) {
+        return null;
+    }
+    const data = "executable" in dataOrInfo ? dataOrInfo.data : dataOrInfo;
+    data.subarray(0, 165); // only use static part
+    // if (data.length === 82) return null; // token mint
+    try {
+        return AccountLayout.decode(data);
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return null;
+}
+function isWalletCorrectATA(walletAddress, data) {
+    const decoded = parseSplAccount(data);
+    if (!decoded)
+        return false;
+    const [realAta] = findAssociatedTokenAddress(decoded.owner, decoded.mint);
+    return realAta.equals(new PublicKey(walletAddress));
+}
+/**
+ * Requests account from blockchain and returns result with account type
+ * @param account address of account
+ * @returns account info and account type
+ */
+function getAccountWithType(connection, account) {
+    return __awaiter(this, void 0, void 0, function* () {
+        account = new PublicKey(account);
+        const accountData = yield getAccountInfo(connection, account);
+        if (!accountData)
+            return [null, AccountType.NotExists];
+        if (accountData.owner.equals(TOKEN_PROGRAM_ID$1)) {
+            return isWalletCorrectATA(account, accountData.data)
+                ? [accountData, AccountType.CorrectATA]
+                : [accountData, AccountType.Token];
+        }
+        if (accountData.owner.equals(SystemProgram.programId))
+            return [accountData, AccountType.System];
+        return [accountData, AccountType.Unknown];
+    });
+}
+/**
+ * Returns balance of specified wallet in native tokens
+ * @param wallet wallet to inspect
+ */
+function getNativeWalletBalance(connection, wallet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        wallet = new PublicKey(wallet);
+        const result = yield connection.getBalance(wallet);
+        return new BN(result.toString());
+    });
+}
+/**
+ * Returns balance of associated wallet in SPL-tokens
+ * @param originalWallet native tokens wallet address
+ * @param tokenMint mint of SPL-Token
+ */
+function getAssocSPLWalletBalance(connection, originalWallet, tokenMint) {
+    return __awaiter(this, void 0, void 0, function* () {
+        originalWallet = new PublicKey(originalWallet);
+        tokenMint = new PublicKey(tokenMint);
+        const [wallet] = findAssociatedTokenAddress(originalWallet, tokenMint);
+        const result = yield connection.getTokenAccountBalance(wallet, "finalized");
+        return new BN(result.value.amount);
+    });
+}
+/**
+ * Returns balance of specified wallet in SPL-tokens
+ * @param wallet spl-tokens wallet address
+ */
+function getSPLWalletBalance(connection, wallet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        wallet = new PublicKey(wallet);
+        const result = yield connection.getTokenAccountBalance(wallet, "finalized");
+        return new BN(result.value.amount);
+    });
+}
+/**
+ * Gets list of user's SPL-token accounts
+ * @param owner owner of the SPL wallets
+ * @returns list of accounts with amount on them
+ */
+function getAllTokenAccountsWithBalances(connection, owner) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const walletsData = yield connection.getParsedTokenAccountsByOwner(new PublicKey(owner), { programId: TOKEN_PROGRAM_ID$1 });
+        const wallets = walletsData.value;
+        return wallets.map((wallet) => {
+            const tokenInfo = wallet.account.data.parsed;
+            return {
+                address: wallet.pubkey,
+                mint: new PublicKey(tokenInfo.info.mint),
+                amount: new BN(tokenInfo.info.tokenAmount.amount),
+                decimals: tokenInfo.info.tokenAmount.decimals,
+                isInitialized: true,
+                isNative: tokenInfo.info.isNative,
+                owner: new PublicKey(tokenInfo.info.owner),
+            };
+        });
+    });
+}
+/**
+ * Gets list of user's tokenMint token accounts
+ * @param tokenMint
+ * @param owner owner of the wallets
+ * @returns list of accounts with amount on them
+ */
+function getTokenAccountsWithBalance(connection, tokenMint, owner) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const walletsData = yield connection.getParsedTokenAccountsByOwner(new PublicKey(owner), { mint: new PublicKey(tokenMint) });
+        const wallets = walletsData.value;
+        return wallets.map((wallet) => {
+            const tokenInfo = wallet.account.data.parsed;
+            return {
+                address: wallet.pubkey,
+                mint: new PublicKey(tokenInfo.info.mint),
+                amount: new BN(tokenInfo.info.tokenAmount.amount),
+                decimals: tokenInfo.info.tokenAmount.decimals,
+                isInitialized: true,
+                isNative: tokenInfo.info.isNative,
+                owner: new PublicKey(tokenInfo.info.owner),
+            };
+        });
+    });
+}
+/**
+ * Builds transaction to transfer&wrap native sol from src wallet to dst wallet
+ * @param amount number of lamports to transfer and wrap
+ * @param transferFrom source native account
+ * @param transferTo destination wallet
+ * @returns transaction to transfer&wrap sol
+ */
+function buildReplenishWsolBalanceTransaction(amount, transferFrom, transferTo) {
+    transferFrom = new PublicKey(transferFrom);
+    transferTo = new PublicKey(transferTo);
+    const tx = new Transaction();
+    tx.add(SystemProgram.transfer({
+        fromPubkey: transferFrom,
+        toPubkey: transferTo,
+        lamports: new BN(amount).toNumber(),
+    }));
+    tx.add(
+    // sync native
+    new TransactionInstruction({
+        keys: [{ pubkey: transferTo, isSigner: false, isWritable: true }],
+        programId: TOKEN_PROGRAM_ID$1,
+        data: buffer.Buffer.from([17]),
+    }));
+    tx.feePayer = transferFrom;
+    return tx;
+}
+/**
+ * Builds transaction that wraps specified amount of lamports into spl, if account is missing will create it
+ * @param amount lamports to wrap, ATA will contain exact amount of lamports
+ * @param owner owner of created wallet
+ */
+function updateWsolBalance(connection, amount, owner) {
+    return __awaiter(this, void 0, void 0, function* () {
+        owner = new PublicKey(owner);
+        const tx = new Transaction();
+        const [wSolATA] = findAssociatedTokenAddress(owner, WRAPPED_SOL_MINT);
+        const existingATA = yield getAccountInfo(connection, wSolATA);
+        let amountToWrap = new BN(amount);
+        if (existingATA === null) {
+            tx.add(createAssociatedWalletInstruction(WRAPPED_SOL_MINT, wSolATA, owner, owner));
+        }
+        else {
+            const parsed = parseSplAccount(existingATA.data);
+            if (!parsed)
+                throw new Error("WSol account exists, but failed to decode its content");
+            const parsedAmount = new BN(parsed.amount.toString());
+            if (amountToWrap.lte(parsedAmount))
+                return null; // don't need to wrap
+            amountToWrap = amountToWrap.sub(parsedAmount);
+        }
+        const replenishTx = buildReplenishWsolBalanceTransaction(amountToWrap, owner, wSolATA);
+        tx.add(replenishTx);
+        return tx;
+    });
+}
+/**
+ * Checks existance of associated wallet for specified token
+ * @param mintAccount mint account of SPL-token
+ * @param originalWallet account of solana wallet
+ * @returns true if account exists
+ */
+function checkIfAssociatedWalletExists(connection, mintAccount, originalWallet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [walletAccount] = findAssociatedTokenAddress(originalWallet, mintAccount);
+        const accountData = yield getAccountInfo(connection, walletAccount);
+        return accountData !== null;
+    });
+}
+function getTransactionAccountsForSimulationDiff(connection, tx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const result = new Set();
+        if ("version" in tx) {
+            const ALTs = tx.message.addressTableLookups.map((alt) => alt.accountKey);
+            const fetchedALTs = yield connection.getMultipleAccountsInfo(ALTs);
+            const parsedALTs = fetchedALTs
+                .map((fetched, i) => fetched
+                ? new AddressLookupTableAccount({
+                    state: AddressLookupTableAccount.deserialize(fetched.data),
+                    key: ALTs[i],
+                })
+                : null)
+                .filter((x) => x != null);
+            const accGetter = tx.message.getAccountKeys({
+                addressLookupTableAccounts: parsedALTs,
+            });
+            const staticWritableOrSignerAccounts = [];
+            for (let idx = 0; idx < accGetter.staticAccountKeys.length; idx += 1) {
+                if (tx.message.isAccountSigner(idx) || tx.message.isAccountWritable(idx))
+                    staticWritableOrSignerAccounts.push(accGetter.staticAccountKeys[idx]);
+            }
+            for (const acc of [
+                ...staticWritableOrSignerAccounts,
+                ...((_b = (_a = accGetter.accountKeysFromLookups) === null || _a === void 0 ? void 0 : _a.writable) !== null && _b !== void 0 ? _b : []),
+            ]) {
+                result.add(acc.toBase58());
+            }
+        }
+        else {
+            const compiled = tx.compileMessage();
+            for (let idx = 0; idx < compiled.accountKeys.length; idx += 1) {
+                if (compiled.isAccountSigner(idx) || compiled.isAccountWritable(idx))
+                    result.add(compiled.staticAccountKeys[idx].toBase58());
+            }
+        }
+        return Array.from(result);
+    });
+}
+function parseMultipleAccounts(accounts) {
+    return accounts.map((account) => {
+        var _a, _b;
+        let parsedSplAccount;
+        if (account) {
+            const owner = new PublicKey(account.owner);
+            if (owner.equals(TOKEN_PROGRAM_ID$1) ||
+                owner.equals(TOKEN_2022_PROGRAM_ID)) {
+                if (account.data instanceof buffer.Buffer) {
+                    parsedSplAccount = parseSplAccount(account.data);
+                }
+                else if (account.data instanceof Array) {
+                    parsedSplAccount = parseSplAccount(buffer.Buffer.from(account.data[0], account.data[1]));
+                }
+            }
+        }
+        const parsedAccount = {
+            balance: (_a = account === null || account === void 0 ? void 0 : account.lamports) !== null && _a !== void 0 ? _a : 0,
+        };
+        if (parsedSplAccount) {
+            parsedAccount.spl = {
+                mint: parsedSplAccount.mint,
+                owner: parsedSplAccount.owner,
+                balance: (_b = parsedSplAccount.amount) !== null && _b !== void 0 ? _b : BigInt(0),
+            };
+        }
+        return parsedAccount;
+    });
+}
+function getSplDiff(pre, post) {
+    var _a, _b, _c, _d, _e, _f;
+    const preBalance = (_a = pre === null || pre === void 0 ? void 0 : pre.balance) !== null && _a !== void 0 ? _a : BigInt(0);
+    const postBalance = (_b = post === null || post === void 0 ? void 0 : post.balance) !== null && _b !== void 0 ? _b : BigInt(0);
+    return {
+        mint: (_c = pre === null || pre === void 0 ? void 0 : pre.mint) !== null && _c !== void 0 ? _c : post === null || post === void 0 ? void 0 : post.mint,
+        owner: (_d = pre === null || pre === void 0 ? void 0 : pre.owner) !== null && _d !== void 0 ? _d : post === null || post === void 0 ? void 0 : post.owner,
+        preBalance: (_e = pre === null || pre === void 0 ? void 0 : pre.balance) !== null && _e !== void 0 ? _e : 0,
+        postBalance: (_f = post === null || post === void 0 ? void 0 : post.balance) !== null && _f !== void 0 ? _f : 0,
+        diff: postBalance - preBalance,
+    };
+}
+function getTransactionDiff(connection, tx, txAccounts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const accountsStrings = txAccounts
+            ? txAccounts.map((acc) => acc.toBase58())
+            : yield getTransactionAccountsForSimulationDiff(connection, tx);
+        const accountsPubKeys = txAccounts !== null && txAccounts !== void 0 ? txAccounts : accountsStrings.map((key) => new PublicKey(key));
+        let [accountsInfo, simulatedTx] = yield Promise.all([
+            connection.getMultipleAccountsInfo(accountsPubKeys),
+            connection.simulateTransaction(tx, {
+                replaceRecentBlockhash: true,
+                accounts: {
+                    encoding: "base64",
+                    addresses: accountsStrings,
+                },
+            }),
+        ]);
+        if (simulatedTx.value.err !== null)
+            throw new Error(JSON.stringify({
+                err: simulatedTx.value.err,
+                logs: simulatedTx.value.logs,
+            }));
+        const simulatesInfo = simulatedTx.value.accounts;
+        const preBalances = parseMultipleAccounts(accountsInfo);
+        const postBalances = parseMultipleAccounts(simulatesInfo);
+        const balancesDiff = accountsPubKeys.reduce((map, pubKey, i) => {
+            var _a;
+            if ((_a = accountsInfo[i]) === null || _a === void 0 ? void 0 : _a.executable) {
+                return map;
+            }
+            const preBalance = preBalances[i];
+            const postBalance = postBalances[i];
+            const diff = {
+                pubKey: pubKey,
+                preBalance: preBalance.balance,
+                postBalance: postBalance.balance,
+                diff: postBalance.balance - preBalance.balance,
+            };
+            if (preBalance.spl || postBalance.spl) {
+                const splDiff = getSplDiff(preBalance.spl, postBalance.spl);
+                if (splDiff.diff) {
+                    diff.spl = splDiff;
+                }
+            }
+            if (diff.diff || diff.spl) {
+                map.set(pubKey.toString(), diff);
+            }
+            return map;
+        }, new Map());
+        return balancesDiff;
+    });
+}
 
-/** TODO: docs */
-struct$1([
-    u8$1('instruction'),
-    new COptionPublicKeyLayout('closeAuthority'),
-]);
+var spl = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	get AccountType () { return AccountType; },
+	getTokenInfo: getTokenInfo,
+	createAssociatedWalletInstruction: createAssociatedWalletInstruction,
+	parseSplAccount: parseSplAccount,
+	isWalletCorrectATA: isWalletCorrectATA,
+	getAccountWithType: getAccountWithType,
+	getNativeWalletBalance: getNativeWalletBalance,
+	getAssocSPLWalletBalance: getAssocSPLWalletBalance,
+	getSPLWalletBalance: getSPLWalletBalance,
+	getAllTokenAccountsWithBalances: getAllTokenAccountsWithBalances,
+	getTokenAccountsWithBalance: getTokenAccountsWithBalance,
+	buildReplenishWsolBalanceTransaction: buildReplenishWsolBalanceTransaction,
+	updateWsolBalance: updateWsolBalance,
+	checkIfAssociatedWalletExists: checkIfAssociatedWalletExists,
+	getTransactionAccountsForSimulationDiff: getTransactionAccountsForSimulationDiff,
+	parseMultipleAccounts: parseMultipleAccounts,
+	getSplDiff: getSplDiff,
+	getTransactionDiff: getTransactionDiff
+});
 
-/** The struct that represents the instruction data as it is read by the program */
-struct$1([
-    u8$1('instruction'),
-]);
+const deBridge = "DEbrdGj3HsRsAzx6uH4MKyREKxVAfBydijLUF3ygsFfh";
+const settings = "DeSetTwWhjZq6Pz9Kfdo1KoS5NqtsM6G8ERbX4SSCSft";
+const dlnSrc = "src5qyZHqTqecJV4aY6Cb6zDZLMDzrDKKezs22MPHr4";
+const dlnDst = "dst5MGcFPoBeREFAA5E3tU5ij8m5uVYwkzkSAbsLbNo";
+const dlnExecutor = "exe59FS5cojZkPJVDFDV8RnXCC7wd6yoBjsUtqH7Zai";
 
-/** TODO: docs */
-struct$1([
-    u8$1('instruction'),
-    publicKey$4('delegate'),
-]);
+var programs = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	deBridge: deBridge,
+	settings: settings,
+	dlnSrc: dlnSrc,
+	dlnDst: dlnDst,
+	dlnExecutor: dlnExecutor
+});
 
 var safeBuffer = {exports: {}};
 
@@ -28953,7 +29136,7 @@ function simulateTransaction(connection, tx, simulateConfig) {
         for (const [idx, simulatedAccountInfo] of ((_c = result.value.accounts) !== null && _c !== void 0 ? _c : []).entries()) {
             const accountAddress = addressesToGetDiffFor[idx];
             const oldAccountData = (_d = accountsToFetch.at(idx)) !== null && _d !== void 0 ? _d : null;
-            const oldParsedMaybeSpl = (oldAccountData === null || oldAccountData === void 0 ? void 0 : oldAccountData.owner.equals(TOKEN_PROGRAM_ID))
+            const oldParsedMaybeSpl = (oldAccountData === null || oldAccountData === void 0 ? void 0 : oldAccountData.owner.equals(TOKEN_PROGRAM_ID$1))
                 ? parseSplAccount(oldAccountData)
                 : null;
             const oldSolValue = (_e = oldAccountData === null || oldAccountData === void 0 ? void 0 : oldAccountData.lamports) !== null && _e !== void 0 ? _e : 0;
@@ -28970,7 +29153,7 @@ function simulateTransaction(connection, tx, simulateConfig) {
                 if (encoding !== "base64")
                     throw new Error("Expected bs64 account data");
                 const artificialAccountInfo = Object.assign(Object.assign({}, simulatedAccountInfo), { owner: new PublicKey(simulatedAccountInfo.owner), data: Buffer.from(rawData, "base64") });
-                newParsedMaybeSpl = artificialAccountInfo.owner.equals(TOKEN_PROGRAM_ID)
+                newParsedMaybeSpl = artificialAccountInfo.owner.equals(TOKEN_PROGRAM_ID$1)
                     ? parseSplAccount(artificialAccountInfo)
                     : null;
             }
@@ -29084,5 +29267,5 @@ var transaction = /*#__PURE__*/Object.freeze({
 	getErrorData: getErrorData
 });
 
-export { ASSOCIATED_TOKEN_PROGRAM_ID, DeBridgeResolver, TOKEN_2022_PROGRAM_ID, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID, WRAPPED_SOL_MINT, constants$1 as constants, crypto$1 as crypto, dlnDstResolver, dlnSrcResolver, findAssociatedTokenAddress, findAssociatedTokenAddressSync, getTokenMetadataAddress, helpers, interfaces, programs, spl, transaction as txs };
+export { ASSOCIATED_TOKEN_PROGRAM_ID, DeBridgeResolver, TOKEN_2022_PROGRAM_ID, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID$1 as TOKEN_PROGRAM_ID, WRAPPED_SOL_MINT, constants$1 as constants, crypto$1 as crypto, dlnDstResolver, dlnSrcResolver, findAssociatedTokenAddress, findAssociatedTokenAddressSync, getTokenMetadataAddress, helpers, interfaces, programs, spl, transaction as txs };
 //# sourceMappingURL=index.js.map