@magicblock-labs/ephemeral-rollups-kit 0.8.8 → 0.10.1

package/lib/instructions/ephemeral-spl-token-program/ephemeralAta.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEphemeralAtaEncoder = getEphemeralAtaEncoder;
 exports.getEphemeralAtaDecoder = getEphemeralAtaDecoder;
@@ -10,6 +43,7 @@ exports.getGlobalVaultCodec = getGlobalVaultCodec;
 exports.decodeGlobalVault = decodeGlobalVault;
 exports.deriveEphemeralAta = deriveEphemeralAta;
 exports.deriveVault = deriveVault;
+exports.deriveRentPda = deriveRentPda;
 exports.deriveVaultAta = deriveVaultAta;
 exports.deriveShuttleEphemeralAta = deriveShuttleEphemeralAta;
 exports.deriveShuttleAta = deriveShuttleAta;
@@ -17,10 +51,14 @@ exports.deriveShuttleWalletAta = deriveShuttleWalletAta;
 exports.initEphemeralAtaIx = initEphemeralAtaIx;
 exports.initVaultAtaIx = initVaultAtaIx;
 exports.initVaultIx = initVaultIx;
+exports.initRentPdaIx = initRentPdaIx;
 exports.transferToVaultIx = transferToVaultIx;
 exports.delegateIx = delegateIx;
 exports.initShuttleEphemeralAtaIx = initShuttleEphemeralAtaIx;
 exports.delegateShuttleEphemeralAtaIx = delegateShuttleEphemeralAtaIx;
+exports.setupAndDelegateShuttleEphemeralAtaWithMergeIx = setupAndDelegateShuttleEphemeralAtaWithMergeIx;
+exports.depositAndDelegateShuttleEphemeralAtaWithMergeAndPrivateTransferIx = depositAndDelegateShuttleEphemeralAtaWithMergeAndPrivateTransferIx;
+exports.withdrawThroughDelegatedShuttleWithMergeIx = withdrawThroughDelegatedShuttleWithMergeIx;
 exports.mergeShuttleIntoAtaIx = mergeShuttleIntoAtaIx;
 exports.undelegateAndCloseShuttleEphemeralAtaIx = undelegateAndCloseShuttleEphemeralAtaIx;
 exports.withdrawSplIx = withdrawSplIx;
@@ -30,15 +68,21 @@ exports.resetEataPermissionIx = resetEataPermissionIx;
 exports.delegateEataPermissionIx = delegateEataPermissionIx;
 exports.undelegateEataPermissionIx = undelegateEataPermissionIx;
 exports.delegateSpl = delegateSpl;
-exports.delegateSplIdempotent = delegateSplIdempotent;
-exports.delegatePrivateSpl = delegatePrivateSpl;
+exports.delegateSplWithPrivateTransfer = delegateSplWithPrivateTransfer;
+exports.transferSpl = transferSpl;
+exports.withdrawSpl = withdrawSpl;
 const kit_1 = require("@solana/kit");
 const system_1 = require("@solana-program/system");
+const blake2b_1 = require("@noble/hashes/blake2b");
+const ed25519_1 = require("@noble/curves/ed25519");
+const nacl = __importStar(require("tweetnacl"));
 const constants_1 = require("../../constants");
 const pda_1 = require("../../pda");
-const DEFAULT_PRIVATE_VALIDATOR = (0, kit_1.address)("FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA");
+const transferQueue_1 = require("./transferQueue");
+const U64_ENCODER = (0, kit_1.getU64Encoder)();
 const TOKEN_PROGRAM_ADDRESS = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const QUEUED_TRANSFER_FLAG_CREATE_IDEMPOTENT_ATA = 1 << 0;
 async function getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve = false) {
     const addressEncoder = (0, kit_1.getAddressEncoder)();
     const [ata] = await (0, kit_1.getProgramDerivedAddress)({
@@ -51,6 +95,55 @@ async function getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve = f
     });
     return ata;
 }
+function createTransferInstruction(source, destination, owner, amount) {
+    return {
+        accounts: [
+            { address: source, role: kit_1.AccountRole.WRITABLE },
+            { address: destination, role: kit_1.AccountRole.WRITABLE },
+            { address: owner, role: kit_1.AccountRole.READONLY_SIGNER },
+        ],
+        data: encodeAmountInstructionData(3, amount),
+        programAddress: TOKEN_PROGRAM_ADDRESS,
+    };
+}
+function encryptEd25519Recipient(plaintext, recipient) {
+    const recipientBytes = (0, kit_1.getAddressEncoder)().encode(recipient);
+    const recipientX25519 = (0, ed25519_1.edwardsToMontgomeryPub)(new Uint8Array(recipientBytes));
+    const ephemeral = nacl.box.keyPair();
+    const nonce = (0, blake2b_1.blake2b)(Buffer.concat([
+        Buffer.from(ephemeral.publicKey),
+        Buffer.from(recipientX25519),
+    ]), { dkLen: nacl.box.nonceLength });
+    const ciphertext = nacl.box(plaintext, nonce, recipientX25519, ephemeral.secretKey);
+    return Buffer.concat([
+        Buffer.from(ephemeral.publicKey),
+        Buffer.from(ciphertext),
+    ]);
+}
+function encodeLengthPrefixedBytes(bytes) {
+    if (bytes.length > 0xff) {
+        throw new Error("encrypted private transfer payload exceeds u8 length");
+    }
+    return Buffer.concat([Buffer.from([bytes.length]), Buffer.from(bytes)]);
+}
+function packPrivateTransferSuffix(minDelayMs, maxDelayMs, split, flags = 0) {
+    const suffix = Buffer.alloc(8 + 8 + 4 + 1);
+    suffix.writeBigUInt64LE(minDelayMs, 0);
+    suffix.writeBigUInt64LE(maxDelayMs, 8);
+    suffix.writeUInt32LE(split, 16);
+    suffix.writeUInt8(flags, 20);
+    return suffix;
+}
+function u32leBuffer(value) {
+    const out = Buffer.alloc(4);
+    out.writeUInt32LE(value, 0);
+    return out;
+}
+function u64leBuffer(value) {
+    const out = Buffer.alloc(8);
+    out.writeBigUInt64LE(value, 0);
+    return out;
+}
 function getEphemeralAtaEncoder() {
     return (0, kit_1.getStructEncoder)([
         ["owner", (0, kit_1.getAddressEncoder)()],
@@ -101,6 +194,13 @@ async function deriveVault(mint) {
     });
     return [vault, bump];
 }
+async function deriveRentPda() {
+    const [rentPda, bump] = await (0, kit_1.getProgramDerivedAddress)({
+        programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+        seeds: [new Uint8Array([114, 101, 110, 116])],
+    });
+    return [rentPda, bump];
+}
 async function deriveVaultAta(mint, vault) {
     return getAssociatedTokenAddressSync(mint, vault, true);
 }
@@ -137,7 +237,7 @@ async function deriveShuttleAta(shuttleEphemeralAta, mint) {
 async function deriveShuttleWalletAta(mint, shuttleEphemeralAta) {
     return getAssociatedTokenAddressSync(mint, shuttleEphemeralAta, true);
 }
-function initEphemeralAtaIx(ephemeralAta, owner, mint, payer, bump) {
+function initEphemeralAtaIx(ephemeralAta, owner, mint, payer) {
     return {
         accounts: [
             { address: ephemeralAta, role: kit_1.AccountRole.WRITABLE },
@@ -146,7 +246,7 @@ function initEphemeralAtaIx(ephemeralAta, owner, mint, payer, bump) {
             { address: mint, role: kit_1.AccountRole.READONLY },
             { address: system_1.SYSTEM_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
         ],
-        data: new Uint8Array([0, bump]),
+        data: new Uint8Array([0]),
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
@@ -164,12 +264,13 @@ function initVaultAtaIx(payer, vaultAta, vault, mint) {
         programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     };
 }
-function initVaultIx(vault, mint, payer, bump, vaultAta) {
+function initVaultIx(vault, mint, payer, vaultEphemeralAta, vaultAta) {
     return {
         accounts: [
             { address: vault, role: kit_1.AccountRole.WRITABLE },
             { address: payer, role: kit_1.AccountRole.WRITABLE_SIGNER },
             { address: mint, role: kit_1.AccountRole.READONLY },
+            { address: vaultEphemeralAta, role: kit_1.AccountRole.WRITABLE },
             { address: vaultAta, role: kit_1.AccountRole.WRITABLE },
             { address: TOKEN_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
             {
@@ -178,7 +279,18 @@ function initVaultIx(vault, mint, payer, bump, vaultAta) {
             },
             { address: system_1.SYSTEM_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
         ],
-        data: new Uint8Array([1, bump]),
+        data: new Uint8Array([1]),
+        programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+    };
+}
+function initRentPdaIx(payer, rentPda) {
+    return {
+        accounts: [
+            { address: payer, role: kit_1.AccountRole.WRITABLE_SIGNER },
+            { address: rentPda, role: kit_1.AccountRole.WRITABLE },
+            { address: system_1.SYSTEM_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
+        ],
+        data: new Uint8Array([23]),
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
@@ -193,27 +305,25 @@ function transferToVaultIx(ephemeralAta, vault, mint, sourceAta, vaultAta, owner
             { address: owner, role: kit_1.AccountRole.READONLY_SIGNER },
             { address: TOKEN_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
         ],
-        data: new Uint8Array([2, ...u64le(amount)]),
+        data: encodeAmountInstructionData(2, amount),
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
-async function delegateIx(payer, ephemeralAta, bump, validator) {
+async function delegateIx(payer, ephemeralAta, validator) {
     const delegateBuffer = await (0, pda_1.delegateBufferPdaFromDelegatedAccountAndOwnerProgram)(ephemeralAta, constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID);
     const delegationRecord = await (0, pda_1.delegationRecordPdaFromDelegatedAccount)(ephemeralAta);
     const delegationMetadata = await (0, pda_1.delegationMetadataPdaFromDelegatedAccount)(ephemeralAta);
     const encoder = (0, kit_1.getAddressEncoder)();
     let data;
     if (validator) {
-        data = new Uint8Array(34);
+        data = new Uint8Array(33);
         data[0] = 4;
-        data[1] = bump;
         const validatorBytes = encoder.encode(validator);
-        data.set(validatorBytes, 2);
+        data.set(validatorBytes, 1);
     }
     else {
-        data = new Uint8Array(2);
+        data = new Uint8Array(1);
         data[0] = 4;
-        data[1] = bump;
     }
     return {
         accounts: [
@@ -230,16 +340,15 @@ async function delegateIx(payer, ephemeralAta, bump, validator) {
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
-function initShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta, owner, mint, shuttleId, bump) {
+function initShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta, owner, mint, shuttleId) {
     if (!Number.isInteger(shuttleId) ||
         shuttleId < 0 ||
         shuttleId > 4294967295) {
         throw new Error("shuttleId must fit in u32");
     }
-    const data = new Uint8Array(6);
+    const data = new Uint8Array(5);
     data[0] = 11;
     new DataView(data.buffer).setUint32(1, shuttleId, true);
-    data[5] = bump;
     return {
         accounts: [
             { address: payer, role: kit_1.AccountRole.WRITABLE_SIGNER },
@@ -259,22 +368,20 @@ function initShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shutt
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
-async function delegateShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, bump, validator) {
+async function delegateShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, validator) {
     const delegateBuffer = await (0, pda_1.delegateBufferPdaFromDelegatedAccountAndOwnerProgram)(shuttleAta, constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID);
     const delegationRecord = await (0, pda_1.delegationRecordPdaFromDelegatedAccount)(shuttleAta);
     const delegationMetadata = await (0, pda_1.delegationMetadataPdaFromDelegatedAccount)(shuttleAta);
     const addressEncoder = (0, kit_1.getAddressEncoder)();
     let data;
     if (validator) {
-        data = new Uint8Array(34);
+        data = new Uint8Array(33);
         data[0] = 13;
-        data[1] = bump;
-        data.set(addressEncoder.encode(validator), 2);
+        data.set(addressEncoder.encode(validator), 1);
     }
     else {
-        data = new Uint8Array(2);
+        data = new Uint8Array(1);
         data[0] = 13;
-        data[1] = bump;
     }
     return {
         accounts: [
@@ -292,6 +399,172 @@ async function delegateShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttle
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
+async function setupAndDelegateShuttleEphemeralAtaWithMergeIx(payer, shuttleEphemeralAta, shuttleAta, owner, sourceAta, destinationAta, shuttleWalletAta, mint, shuttleId, amount, validator) {
+    if (!Number.isInteger(shuttleId) ||
+        shuttleId < 0 ||
+        shuttleId > 4294967295) {
+        throw new Error("shuttleId must fit in u32");
+    }
+    const [rentPda] = await deriveRentPda();
+    const [vault] = await deriveVault(mint);
+    const vaultAta = await deriveVaultAta(mint, vault);
+    const delegateBuffer = await (0, pda_1.delegateBufferPdaFromDelegatedAccountAndOwnerProgram)(shuttleAta, constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID);
+    const delegationRecord = await (0, pda_1.delegationRecordPdaFromDelegatedAccount)(shuttleAta);
+    const delegationMetadata = await (0, pda_1.delegationMetadataPdaFromDelegatedAccount)(shuttleAta);
+    const addressEncoder = (0, kit_1.getAddressEncoder)();
+    const data = new Uint8Array(validator ? 45 : 13);
+    const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    data[0] = 24;
+    dataView.setUint32(1, shuttleId, true);
+    dataView.setBigUint64(5, amount, true);
+    if (validator) {
+        data.set(addressEncoder.encode(validator), 13);
+    }
+    return {
+        accounts: [
+            { address: payer, role: kit_1.AccountRole.WRITABLE_SIGNER },
+            { address: rentPda, role: kit_1.AccountRole.WRITABLE },
+            { address: shuttleEphemeralAta, role: kit_1.AccountRole.WRITABLE },
+            { address: shuttleAta, role: kit_1.AccountRole.WRITABLE },
+            { address: shuttleWalletAta, role: kit_1.AccountRole.WRITABLE },
+            { address: owner, role: kit_1.AccountRole.READONLY_SIGNER },
+            { address: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
+            { address: delegateBuffer, role: kit_1.AccountRole.WRITABLE },
+            { address: delegationRecord, role: kit_1.AccountRole.WRITABLE },
+            { address: delegationMetadata, role: kit_1.AccountRole.WRITABLE },
+            { address: constants_1.DELEGATION_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
+            {
+                address: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+                role: kit_1.AccountRole.READONLY,
+            },
+            { address: system_1.SYSTEM_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
+            { address: destinationAta, role: kit_1.AccountRole.WRITABLE },
+            { address: mint, role: kit_1.AccountRole.READONLY },
+            { address: TOKEN_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
+            { address: vault, role: kit_1.AccountRole.READONLY },
+            { address: sourceAta, role: kit_1.AccountRole.WRITABLE },
+            { address: vaultAta, role: kit_1.AccountRole.WRITABLE },
+        ],
+        data,
+        programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+    };
+}
+async function depositAndDelegateShuttleEphemeralAtaWithMergeAndPrivateTransferIx(payer, shuttleEphemeralAta, shuttleAta, owner, sourceAta, destinationOwner, shuttleWalletAta, mint, shuttleId, amount, minDelayMs, maxDelayMs, split, validator) {
+    if (!Number.isInteger(shuttleId) ||
+        shuttleId < 0 ||
+        shuttleId > 4294967295) {
+        throw new Error("shuttleId must fit in u32");
+    }
+    if (amount < 0n) {
+        throw new Error("amount must be non-negative");
+    }
+    if (minDelayMs < 0n || maxDelayMs < 0n) {
+        throw new Error("delay values must be non-negative");
+    }
+    if (maxDelayMs < minDelayMs) {
+        throw new Error("maxDelayMs must be greater than or equal to minDelayMs");
+    }
+    if (validator == null) {
+        throw new Error("validator is required for encrypted private transfers");
+    }
+    if (!Number.isInteger(split) || split <= 0 || split > 4294967295) {
+        throw new Error("split must fit in u32 and be positive");
+    }
+    const [rentPda] = await deriveRentPda();
+    const [vault] = await deriveVault(mint);
+    const vaultAta = await deriveVaultAta(mint, vault);
+    const [queue] = await (0, transferQueue_1.deriveTransferQueue)(mint);
+    const delegateBuffer = await (0, pda_1.delegateBufferPdaFromDelegatedAccountAndOwnerProgram)(shuttleAta, constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID);
+    const delegationRecord = await (0, pda_1.delegationRecordPdaFromDelegatedAccount)(shuttleAta);
+    const delegationMetadata = await (0, pda_1.delegationMetadataPdaFromDelegatedAccount)(shuttleAta);
+    const addressEncoder = (0, kit_1.getAddressEncoder)();
+    const encryptedDestination = encryptEd25519Recipient(new Uint8Array(addressEncoder.encode(destinationOwner)), validator);
+    const encryptedSuffix = encryptEd25519Recipient(packPrivateTransferSuffix(minDelayMs, maxDelayMs, split, QUEUED_TRANSFER_FLAG_CREATE_IDEMPOTENT_ATA), validator);
+    const data = Buffer.concat([
+        Buffer.from([25]),
+        u32leBuffer(shuttleId),
+        u64leBuffer(amount),
+        encodeLengthPrefixedBytes(new Uint8Array(addressEncoder.encode(validator))),
+        encodeLengthPrefixedBytes(encryptedDestination),
+        encodeLengthPrefixedBytes(encryptedSuffix),
+    ]);
+    return {
+        accounts: [
+            { address: payer, role: kit_1.AccountRole.WRITABLE_SIGNER },
+            { address: rentPda, role: kit_1.AccountRole.WRITABLE },
+            { address: shuttleEphemeralAta, role: kit_1.AccountRole.WRITABLE },
+            { address: shuttleAta, role: kit_1.AccountRole.WRITABLE },
+            { address: shuttleWalletAta, role: kit_1.AccountRole.WRITABLE },
+            { address: owner, role: kit_1.AccountRole.READONLY_SIGNER },
+            { address: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
+            { address: delegateBuffer, role: kit_1.AccountRole.WRITABLE },
+            { address: delegationRecord, role: kit_1.AccountRole.WRITABLE },
+            { address: delegationMetadata, role: kit_1.AccountRole.WRITABLE },
+            { address: constants_1.DELEGATION_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
+            {
+                address: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+                role: kit_1.AccountRole.READONLY,
+            },
+            { address: system_1.SYSTEM_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
+            { address: mint, role: kit_1.AccountRole.READONLY },
+            { address: TOKEN_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
+            { address: vault, role: kit_1.AccountRole.READONLY },
+            { address: sourceAta, role: kit_1.AccountRole.WRITABLE },
+            { address: vaultAta, role: kit_1.AccountRole.WRITABLE },
+            { address: queue, role: kit_1.AccountRole.WRITABLE },
+        ],
+        data,
+        programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+    };
+}
+async function withdrawThroughDelegatedShuttleWithMergeIx(payer, shuttleEphemeralAta, shuttleAta, owner, ownerAta, shuttleWalletAta, mint, shuttleId, amount, validator) {
+    if (!Number.isInteger(shuttleId) ||
+        shuttleId < 0 ||
+        shuttleId > 4294967295) {
+        throw new Error("shuttleId must fit in u32");
+    }
+    if (amount < 0n) {
+        throw new Error("amount must be non-negative");
+    }
+    const [rentPda] = await deriveRentPda();
+    const delegateBuffer = await (0, pda_1.delegateBufferPdaFromDelegatedAccountAndOwnerProgram)(shuttleAta, constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID);
+    const delegationRecord = await (0, pda_1.delegationRecordPdaFromDelegatedAccount)(shuttleAta);
+    const delegationMetadata = await (0, pda_1.delegationMetadataPdaFromDelegatedAccount)(shuttleAta);
+    const addressEncoder = (0, kit_1.getAddressEncoder)();
+    const data = new Uint8Array(validator ? 45 : 13);
+    const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    data[0] = 26;
+    dataView.setUint32(1, shuttleId, true);
+    dataView.setBigUint64(5, amount, true);
+    if (validator) {
+        data.set(addressEncoder.encode(validator), 13);
+    }
+    return {
+        accounts: [
+            { address: payer, role: kit_1.AccountRole.WRITABLE_SIGNER },
+            { address: rentPda, role: kit_1.AccountRole.WRITABLE },
+            { address: shuttleEphemeralAta, role: kit_1.AccountRole.WRITABLE },
+            { address: shuttleAta, role: kit_1.AccountRole.WRITABLE },
+            { address: shuttleWalletAta, role: kit_1.AccountRole.WRITABLE },
+            { address: owner, role: kit_1.AccountRole.READONLY_SIGNER },
+            { address: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
+            { address: delegateBuffer, role: kit_1.AccountRole.WRITABLE },
+            { address: delegationRecord, role: kit_1.AccountRole.WRITABLE },
+            { address: delegationMetadata, role: kit_1.AccountRole.WRITABLE },
+            { address: constants_1.DELEGATION_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
+            {
+                address: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+                role: kit_1.AccountRole.READONLY,
+            },
+            { address: system_1.SYSTEM_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
+            { address: ownerAta, role: kit_1.AccountRole.WRITABLE },
+            { address: mint, role: kit_1.AccountRole.READONLY },
+            { address: TOKEN_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
+        ],
+        data,
+        programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+    };
+}
 function mergeShuttleIntoAtaIx(owner, ownerAta, shuttleEphemeralAta, shuttleWalletAta, mint) {
     return {
         accounts: [
@@ -306,7 +579,14 @@ function mergeShuttleIntoAtaIx(owner, ownerAta, shuttleEphemeralAta, shuttleWall
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
-function undelegateAndCloseShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta) {
+function undelegateAndCloseShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta, escrowIndex) {
+    if (escrowIndex !== undefined &&
+        (!Number.isInteger(escrowIndex) || escrowIndex < 0 || escrowIndex > 0xff)) {
+        throw new Error("escrowIndex must fit in u8");
+    }
+    const data = escrowIndex === undefined
+        ? new Uint8Array([14])
+        : new Uint8Array([14, escrowIndex]);
     return {
         accounts: [
             { address: payer, role: kit_1.AccountRole.WRITABLE_SIGNER },
@@ -317,13 +597,13 @@ function undelegateAndCloseShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shu
             { address: constants_1.MAGIC_CONTEXT_ID, role: kit_1.AccountRole.WRITABLE },
             { address: constants_1.MAGIC_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
         ],
-        data: new Uint8Array([14]),
+        data,
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
 async function withdrawSplIx(owner, mint, amount) {
     const [ephemeralAta] = await deriveEphemeralAta(owner, mint);
-    const [vault, vaultBump] = await deriveVault(mint);
+    const [vault] = await deriveVault(mint);
     const vaultAta = await deriveVaultAta(mint, vault);
     const userDestAta = await getAssociatedTokenAddressSync(mint, owner);
     return {
@@ -336,7 +616,7 @@ async function withdrawSplIx(owner, mint, amount) {
             { address: userDestAta, role: kit_1.AccountRole.WRITABLE },
             { address: TOKEN_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
         ],
-        data: new Uint8Array([3, ...u64le(amount), vaultBump]),
+        data: encodeAmountInstructionData(3, amount),
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
@@ -370,7 +650,7 @@ async function undelegateIx(owner, mint) {
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
-async function createEataPermissionIx(ephemeralAta, payer, bump, flags = 0) {
+async function createEataPermissionIx(ephemeralAta, payer, flags = 0) {
     const permission = await (0, pda_1.permissionPdaFromAccount)(ephemeralAta);
     return {
         accounts: [
@@ -380,11 +660,11 @@ async function createEataPermissionIx(ephemeralAta, payer, bump, flags = 0) {
             { address: system_1.SYSTEM_PROGRAM_ADDRESS, role: kit_1.AccountRole.READONLY },
             { address: constants_1.PERMISSION_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
         ],
-        data: new Uint8Array([6, bump, flags]),
+        data: new Uint8Array([6, flags]),
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
-async function resetEataPermissionIx(ephemeralAta, payer, bump, flags = 0) {
+async function resetEataPermissionIx(ephemeralAta, payer, flags = 0) {
     const permission = await (0, pda_1.permissionPdaFromAccount)(ephemeralAta);
     return {
         accounts: [
@@ -393,11 +673,11 @@ async function resetEataPermissionIx(ephemeralAta, payer, bump, flags = 0) {
             { address: payer, role: kit_1.AccountRole.READONLY_SIGNER },
             { address: constants_1.PERMISSION_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
         ],
-        data: new Uint8Array([9, bump, flags]),
+        data: new Uint8Array([9, flags]),
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
-async function delegateEataPermissionIx(payer, ephemeralAta, bump, validator) {
+async function delegateEataPermissionIx(payer, ephemeralAta, validator) {
     const permission = await (0, pda_1.permissionPdaFromAccount)(ephemeralAta);
     return {
         accounts: [
@@ -421,7 +701,7 @@ async function delegateEataPermissionIx(payer, ephemeralAta, bump, validator) {
             { address: constants_1.DELEGATION_PROGRAM_ID, role: kit_1.AccountRole.READONLY },
             { address: validator, role: kit_1.AccountRole.READONLY },
         ],
-        data: new Uint8Array([7, bump]),
+        data: new Uint8Array([7]),
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
@@ -440,98 +720,242 @@ async function undelegateEataPermissionIx(owner, ephemeralAta) {
         programAddress: constants_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
     };
 }
-async function delegateSpl(owner, mint, amount, opts) {
+function randomShuttleId() {
+    const cryptoObj = globalThis?.crypto;
+    if (cryptoObj?.getRandomValues !== undefined) {
+        const buf = new Uint32Array(1);
+        cryptoObj.getRandomValues(buf);
+        return buf[0];
+    }
+    return Math.floor(Math.random() * 4294967296);
+}
+async function buildDelegateSplInstructions(owner, mint, amount, opts) {
     const payer = opts?.payer ?? owner;
     const validator = opts?.validator;
     const initIfMissing = opts?.initIfMissing ?? true;
     const initVaultIfMissing = opts?.initVaultIfMissing ?? false;
+    const isPrivate = opts?.private ?? false;
     const instructions = [];
-    const [ephemeralAta, eataBump] = await deriveEphemeralAta(owner, mint);
-    const [vault, vaultBump] = await deriveVault(mint);
+    const [ephemeralAta] = await deriveEphemeralAta(owner, mint);
+    const [vault] = await deriveVault(mint);
+    const [vaultEphemeralAta] = await deriveEphemeralAta(vault, mint);
     const vaultAta = await deriveVaultAta(mint, vault);
     const ownerAta = await getAssociatedTokenAddressSync(mint, owner);
     if (initIfMissing) {
-        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer, eataBump));
+        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer));
     }
     if (initVaultIfMissing) {
-        instructions.push(initVaultIx(vault, mint, payer, vaultBump, vaultAta), initVaultAtaIx(payer, vaultAta, vault, mint));
+        instructions.push(initVaultIx(vault, mint, payer, vaultEphemeralAta, vaultAta), initVaultAtaIx(payer, vaultAta, vault, mint), await delegateIx(payer, vaultEphemeralAta, validator));
     }
     instructions.push(transferToVaultIx(ephemeralAta, vault, mint, ownerAta, vaultAta, owner, amount));
-    instructions.push(await delegateIx(payer, ephemeralAta, eataBump, validator));
+    if (isPrivate) {
+        instructions.push(await createEataPermissionIx(ephemeralAta, payer));
+    }
+    instructions.push(await delegateIx(payer, ephemeralAta, validator));
     return instructions;
 }
-async function delegateSplIdempotent(owner, mint, amount, opts) {
+async function buildIdempotentDelegateSplInstructions(owner, mint, amount, opts) {
     const payer = opts?.payer ?? owner;
     const validator = opts?.validator;
+    const initIfMissing = opts?.initIfMissing ?? true;
     const initVaultIfMissing = opts?.initVaultIfMissing ?? false;
     const initAtasIfMissing = opts?.initAtasIfMissing ?? false;
-    const randomShuttleId = () => {
-        const cryptoObj = globalThis?.crypto;
-        if (cryptoObj?.getRandomValues !== undefined) {
-            const buf = new Uint32Array(1);
-            cryptoObj.getRandomValues(buf);
-            return buf[0];
-        }
-        return Math.floor(Math.random() * 4294967296);
-    };
+    const isPrivate = opts?.private ?? false;
     const shuttleId = opts?.shuttleId ?? randomShuttleId();
     const instructions = [];
-    const [ephemeralAta, eataBump] = await deriveEphemeralAta(owner, mint);
-    const [vault, vaultBump] = await deriveVault(mint);
+    const [ephemeralAta] = await deriveEphemeralAta(owner, mint);
+    const [vault] = await deriveVault(mint);
+    const [vaultEphemeralAta] = await deriveEphemeralAta(vault, mint);
     const vaultAta = await deriveVaultAta(mint, vault);
     const ownerAta = await getAssociatedTokenAddressSync(mint, owner);
-    const [shuttleEphemeralAta, shuttleBump] = await deriveShuttleEphemeralAta(owner, mint, shuttleId);
-    const [shuttleAta, shuttleAtaBump] = await deriveShuttleAta(shuttleEphemeralAta, mint);
+    const [shuttleEphemeralAta] = await deriveShuttleEphemeralAta(owner, mint, shuttleId);
+    const [shuttleAta] = await deriveShuttleAta(shuttleEphemeralAta, mint);
     const shuttleWalletAta = await deriveShuttleWalletAta(mint, shuttleEphemeralAta);
     if (initVaultIfMissing) {
-        instructions.push(initVaultIx(vault, mint, payer, vaultBump, vaultAta), initVaultAtaIx(payer, vaultAta, vault, mint));
+        instructions.push(initVaultIx(vault, mint, payer, vaultEphemeralAta, vaultAta), initVaultAtaIx(payer, vaultAta, vault, mint), await delegateIx(payer, vaultEphemeralAta, validator));
     }
     if (initAtasIfMissing) {
-        instructions.push(initVaultAtaIx(payer, ownerAta, owner, mint), initVaultAtaIx(payer, shuttleWalletAta, shuttleEphemeralAta, mint));
+        instructions.push(initVaultAtaIx(payer, ownerAta, owner, mint));
+    }
+    if (initIfMissing) {
+        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer));
+    }
+    if (isPrivate) {
+        instructions.push(await createEataPermissionIx(ephemeralAta, payer));
     }
-    instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer, eataBump), await createEataPermissionIx(ephemeralAta, payer, eataBump), await delegateIx(payer, ephemeralAta, eataBump, validator), initShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta, owner, mint, shuttleId, shuttleBump));
+    instructions.push(await delegateIx(payer, ephemeralAta, validator));
     if (amount > 0n) {
-        instructions.push(transferToVaultIx(shuttleAta, vault, mint, ownerAta, vaultAta, owner, amount));
+        instructions.push(await setupAndDelegateShuttleEphemeralAtaWithMergeIx(payer, shuttleEphemeralAta, shuttleAta, owner, ownerAta, ownerAta, shuttleWalletAta, mint, shuttleId, amount, validator));
+    }
+    else {
+        instructions.push(initShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta, owner, mint, shuttleId), await delegateShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, validator));
     }
-    instructions.push(await delegateShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleAtaBump, validator));
     return instructions;
 }
-async function delegatePrivateSpl(owner, mint, amount, opts) {
+async function delegateSpl(owner, mint, amount, opts) {
+    if (opts?.idempotent === false) {
+        return buildDelegateSplInstructions(owner, mint, amount, opts);
+    }
+    return buildIdempotentDelegateSplInstructions(owner, mint, amount, opts);
+}
+async function delegateSplWithPrivateTransfer(owner, mint, amount, opts) {
     const payer = opts?.payer ?? owner;
-    const validator = opts?.validator ?? DEFAULT_PRIVATE_VALIDATOR;
+    const validator = opts?.validator;
     const initIfMissing = opts?.initIfMissing ?? true;
     const initVaultIfMissing = opts?.initVaultIfMissing ?? false;
-    const permissionFlags = opts?.permissionFlags ?? 0;
-    const delegatePermission = opts?.delegatePermission ?? false;
+    const initAtasIfMissing = opts?.initAtasIfMissing ?? false;
+    const initTransferQueueIfMissing = opts?.initTransferQueueIfMissing ?? false;
+    const shuttleId = opts?.shuttleId ?? randomShuttleId();
+    const minDelayMs = opts?.minDelayMs ?? 0n;
+    const maxDelayMs = opts?.maxDelayMs ?? minDelayMs;
+    const split = opts?.split ?? 1;
     const instructions = [];
-    const [ephemeralAta, eataBump] = await deriveEphemeralAta(owner, mint);
-    const [vault, vaultBump] = await deriveVault(mint);
+    const [ephemeralAta] = await deriveEphemeralAta(owner, mint);
+    const [vault] = await deriveVault(mint);
+    const [vaultEphemeralAta] = await deriveEphemeralAta(vault, mint);
     const vaultAta = await deriveVaultAta(mint, vault);
+    const [queue] = await (0, transferQueue_1.deriveTransferQueue)(mint);
     const ownerAta = await getAssociatedTokenAddressSync(mint, owner);
+    const [shuttleEphemeralAta] = await deriveShuttleEphemeralAta(owner, mint, shuttleId);
+    const [shuttleAta] = await deriveShuttleAta(shuttleEphemeralAta, mint);
+    const shuttleWalletAta = await deriveShuttleWalletAta(mint, shuttleEphemeralAta);
+    if (initVaultIfMissing) {
+        instructions.push(initVaultIx(vault, mint, payer, vaultEphemeralAta, vaultAta), initVaultAtaIx(payer, vaultAta, vault, mint), await delegateIx(payer, vaultEphemeralAta, validator));
+    }
+    if (initTransferQueueIfMissing) {
+        instructions.push((0, transferQueue_1.initTransferQueueIx)(payer, queue, mint));
+    }
+    if (initAtasIfMissing) {
+        instructions.push(initVaultAtaIx(payer, ownerAta, owner, mint));
+    }
     if (initIfMissing) {
-        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer, eataBump));
+        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer));
+    }
+    instructions.push(await delegateIx(payer, ephemeralAta, validator), await depositAndDelegateShuttleEphemeralAtaWithMergeAndPrivateTransferIx(payer, shuttleEphemeralAta, shuttleAta, owner, ownerAta, owner, shuttleWalletAta, mint, shuttleId, amount, minDelayMs, maxDelayMs, split, validator));
+    return instructions;
+}
+async function transferSpl(from, to, mint, amount, opts) {
+    const payer = opts.payer ?? from;
+    const validator = opts.validator;
+    const initIfMissing = opts.initIfMissing ?? false;
+    const initAtasIfMissing = opts.initAtasIfMissing ?? false;
+    const initVaultIfMissing = opts.initVaultIfMissing ?? false;
+    const shuttleId = opts.shuttleId ?? randomShuttleId();
+    const minDelayMs = opts.privateTransfer?.minDelayMs ?? 0n;
+    const maxDelayMs = opts.privateTransfer?.maxDelayMs ?? minDelayMs;
+    const split = opts.privateTransfer?.split ?? 1;
+    const fromAta = await getAssociatedTokenAddressSync(mint, from);
+    const toAta = await getAssociatedTokenAddressSync(mint, to);
+    if (opts.fromBalance === "ephemeral") {
+        switch (opts.visibility) {
+            case "private":
+                if (opts.toBalance === "base") {
+                    const [queue] = await (0, transferQueue_1.deriveTransferQueue)(mint);
+                    const [vault] = await deriveVault(mint);
+                    const vaultAta = await deriveVaultAta(mint, vault);
+                    return [
+                        (0, transferQueue_1.depositAndQueueTransferIx)(queue, vault, mint, fromAta, vaultAta, toAta, from, amount, minDelayMs, maxDelayMs, split),
+                    ];
+                }
+                if (opts.toBalance === "ephemeral") {
+                    return [createTransferInstruction(fromAta, toAta, from, amount)];
+                }
+                break;
+            case "public":
+                if (opts.toBalance === "ephemeral") {
+                    return [createTransferInstruction(fromAta, toAta, from, amount)];
+                }
+                break;
+        }
     }
+    const instructions = [];
     if (initVaultIfMissing) {
-        instructions.push(initVaultIx(vault, mint, payer, vaultBump, vaultAta), initVaultAtaIx(payer, vaultAta, vault, mint));
+        const [vault] = await deriveVault(mint);
+        const [vaultEphemeralAta] = await deriveEphemeralAta(vault, mint);
+        const vaultAta = await deriveVaultAta(mint, vault);
+        instructions.push(initVaultIx(vault, mint, payer, vaultEphemeralAta, vaultAta), initVaultAtaIx(payer, vaultAta, vault, mint), await delegateIx(payer, vaultEphemeralAta, validator));
     }
-    instructions.push(transferToVaultIx(ephemeralAta, vault, mint, ownerAta, vaultAta, owner, amount));
-    instructions.push(await delegateIx(payer, ephemeralAta, eataBump, validator));
-    instructions.push(await createEataPermissionIx(ephemeralAta, payer, eataBump, permissionFlags));
-    if (delegatePermission) {
-        instructions.push(await delegateEataPermissionIx(payer, ephemeralAta, eataBump, validator));
+    if (opts.fromBalance === "base" && initAtasIfMissing) {
+        instructions.push(initVaultAtaIx(payer, fromAta, from, mint));
+    }
+    switch (opts.visibility) {
+        case "private":
+            if (opts.fromBalance === "base" && opts.toBalance === "base") {
+                const [shuttleEphemeralAta] = await deriveShuttleEphemeralAta(from, mint, shuttleId);
+                const [shuttleAta] = await deriveShuttleAta(shuttleEphemeralAta, mint);
+                const shuttleWalletAta = await deriveShuttleWalletAta(mint, shuttleEphemeralAta);
+                return [
+                    ...instructions,
+                    await depositAndDelegateShuttleEphemeralAtaWithMergeAndPrivateTransferIx(payer, shuttleEphemeralAta, shuttleAta, from, fromAta, to, shuttleWalletAta, mint, shuttleId, amount, minDelayMs, maxDelayMs, split, validator),
+                ];
+            }
+            if (opts.fromBalance === "base" && opts.toBalance === "ephemeral") {
+                if (initIfMissing) {
+                    const [toEphemeralAta] = await deriveEphemeralAta(to, mint);
+                    instructions.push(initVaultAtaIx(payer, toAta, to, mint), initEphemeralAtaIx(toEphemeralAta, to, mint, payer), await delegateIx(payer, toEphemeralAta, validator));
+                }
+                const [shuttleEphemeralAta] = await deriveShuttleEphemeralAta(from, mint, shuttleId);
+                const [shuttleAta] = await deriveShuttleAta(shuttleEphemeralAta, mint);
+                const shuttleWalletAta = await deriveShuttleWalletAta(mint, shuttleEphemeralAta);
+                return [
+                    ...instructions,
+                    await setupAndDelegateShuttleEphemeralAtaWithMergeIx(payer, shuttleEphemeralAta, shuttleAta, from, fromAta, toAta, shuttleWalletAta, mint, shuttleId, amount, validator),
+                ];
+            }
+            break;
+        case "public":
+            if (opts.fromBalance === "base" && opts.toBalance === "base") {
+                return [
+                    ...instructions,
+                    createTransferInstruction(fromAta, toAta, from, amount),
+                ];
+            }
+            break;
+    }
+    throw new Error(`transferSpl route not implemented: visibility=${opts.visibility}, fromBalance=${opts.fromBalance}, toBalance=${opts.toBalance}`);
+}
+async function buildIdempotentWithdrawSplInstructions(owner, mint, amount, opts) {
+    const payer = opts?.payer ?? owner;
+    const validator = opts?.validator;
+    const initIfMissing = opts?.initIfMissing ?? true;
+    const initAtasIfMissing = opts?.initAtasIfMissing ?? false;
+    const shuttleId = opts?.shuttleId ?? randomShuttleId();
+    const instructions = [];
+    const [ephemeralAta] = await deriveEphemeralAta(owner, mint);
+    const ownerAta = await getAssociatedTokenAddressSync(mint, owner);
+    const [shuttleEphemeralAta] = await deriveShuttleEphemeralAta(owner, mint, shuttleId);
+    const [shuttleAta] = await deriveShuttleAta(shuttleEphemeralAta, mint);
+    const shuttleWalletAta = await deriveShuttleWalletAta(mint, shuttleEphemeralAta);
+    if (initAtasIfMissing) {
+        instructions.push(initVaultAtaIx(payer, ownerAta, owner, mint));
     }
+    if (initIfMissing) {
+        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer));
+    }
+    instructions.push(await delegateIx(payer, ephemeralAta, validator), await withdrawThroughDelegatedShuttleWithMergeIx(payer, shuttleEphemeralAta, shuttleAta, owner, ownerAta, shuttleWalletAta, mint, shuttleId, amount, validator));
     return instructions;
 }
-function u64le(n) {
-    if (n < 0n || n > 0xffffffffffffffffn) {
-        throw new Error("amount out of range for u64");
+async function withdrawSpl(owner, mint, amount, opts) {
+    if (opts?.idempotent === false) {
+        const instructions = [];
+        if (opts?.initAtasIfMissing === true) {
+            const payer = opts.payer ?? owner;
+            const ownerAta = await getAssociatedTokenAddressSync(mint, owner);
+            instructions.push(initVaultAtaIx(payer, ownerAta, owner, mint));
+        }
+        instructions.push(await withdrawSplIx(owner, mint, amount));
+        return instructions;
     }
-    const bytes = new Array(8).fill(0);
-    let x = n;
-    for (let i = 0; i < 8; i++) {
-        bytes[i] = Number(x & 0xffn);
-        x >>= 8n;
+    return buildIdempotentWithdrawSplInstructions(owner, mint, amount, opts);
+}
+function encodeAmountInstructionData(discriminator, amount, ...suffix) {
+    const amountBytes = U64_ENCODER.encode(amount);
+    const data = new Uint8Array(1 + amountBytes.length + suffix.length);
+    data[0] = discriminator;
+    data.set(amountBytes, 1);
+    if (suffix.length > 0) {
+        data.set(suffix, 1 + amountBytes.length);
     }
-    return bytes;
+    return data;
 }
 //# sourceMappingURL=ephemeralAta.js.map