@magicblock-labs/ephemeral-rollups-sdk 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.decodeEphemeralAta = decodeEphemeralAta;
 exports.encodeEphemeralAta = encodeEphemeralAta;
@@ -6,6 +39,7 @@ exports.decodeGlobalVault = decodeGlobalVault;
 exports.encodeGlobalVault = encodeGlobalVault;
 exports.deriveEphemeralAta = deriveEphemeralAta;
 exports.deriveVault = deriveVault;
+exports.deriveRentPda = deriveRentPda;
 exports.deriveVaultAta = deriveVaultAta;
 exports.deriveShuttleEphemeralAta = deriveShuttleEphemeralAta;
 exports.deriveShuttleAta = deriveShuttleAta;
@@ -13,11 +47,15 @@ exports.deriveShuttleWalletAta = deriveShuttleWalletAta;
 exports.initEphemeralAtaIx = initEphemeralAtaIx;
 exports.initVaultAtaIx = initVaultAtaIx;
 exports.initVaultIx = initVaultIx;
+exports.initRentPdaIx = initRentPdaIx;
 exports.transferToVaultIx = transferToVaultIx;
 exports.depositSplTokensIx = depositSplTokensIx;
 exports.delegateEphemeralAtaIx = delegateEphemeralAtaIx;
 exports.initShuttleEphemeralAtaIx = initShuttleEphemeralAtaIx;
 exports.delegateShuttleEphemeralAtaIx = delegateShuttleEphemeralAtaIx;
+exports.setupAndDelegateShuttleEphemeralAtaWithMergeIx = setupAndDelegateShuttleEphemeralAtaWithMergeIx;
+exports.depositAndDelegateShuttleEphemeralAtaWithMergeAndPrivateTransferIx = depositAndDelegateShuttleEphemeralAtaWithMergeAndPrivateTransferIx;
+exports.withdrawThroughDelegatedShuttleWithMergeIx = withdrawThroughDelegatedShuttleWithMergeIx;
 exports.mergeShuttleIntoAtaIx = mergeShuttleIntoAtaIx;
 exports.undelegateAndCloseShuttleEphemeralAtaIx = undelegateAndCloseShuttleEphemeralAtaIx;
 exports.withdrawSplIx = withdrawSplIx;
@@ -27,14 +65,19 @@ 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 web3_js_1 = require("@solana/web3.js");
+const blake2b_1 = require("@noble/hashes/blake2b");
+const ed25519_1 = require("@noble/curves/ed25519");
+const nacl = __importStar(require("tweetnacl"));
 const constants_js_1 = require("../../constants.js");
 const pda_js_1 = require("../../pda.js");
-const DEFAULT_PRIVATE_VALIDATOR = new web3_js_1.PublicKey("FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA");
+const transferQueue_js_1 = require("./transferQueue.js");
 const TOKEN_PROGRAM_ID = new web3_js_1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 const ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+const QUEUED_TRANSFER_FLAG_CREATE_IDEMPOTENT_ATA = 1 << 0;
 function getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
     if (!allowOwnerOffCurve && !web3_js_1.PublicKey.isOnCurve(owner)) {
         throw new Error("Owner public key is off-curve");
@@ -57,6 +100,66 @@ function createAssociatedTokenAccountIdempotentInstruction(payer, associatedToke
         data,
     });
 }
+function createTransferInstruction(source, destination, owner, amount, multiSigners = [], programId = TOKEN_PROGRAM_ID) {
+    const data = Buffer.alloc(9);
+    data[0] = 3;
+    data.writeBigUInt64LE(amount, 1);
+    const keys = [
+        { pubkey: source, isSigner: false, isWritable: true },
+        { pubkey: destination, isSigner: false, isWritable: true },
+    ];
+    if (multiSigners.length === 0) {
+        keys.push({ pubkey: owner, isSigner: true, isWritable: false });
+    }
+    else {
+        keys.push({ pubkey: owner, isSigner: false, isWritable: false });
+        for (const signer of multiSigners) {
+            keys.push({ pubkey: signer, isSigner: true, isWritable: false });
+        }
+    }
+    return new web3_js_1.TransactionInstruction({
+        programId,
+        keys,
+        data,
+    });
+}
+function encryptEd25519Recipient(plaintext, recipient) {
+    const recipientX25519 = (0, ed25519_1.edwardsToMontgomeryPub)(recipient.toBytes());
+    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 decodeEphemeralAta(info) {
     if (info.data.length < 72) {
         throw new Error("Invalid EphemeralAta account data length");
@@ -95,6 +198,9 @@ function deriveEphemeralAta(owner, mint) {
 function deriveVault(mint) {
     return web3_js_1.PublicKey.findProgramAddressSync([mint.toBuffer()], constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID);
 }
+function deriveRentPda() {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("rent")], constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID);
+}
 function deriveVaultAta(mint, vault) {
     return getAssociatedTokenAddressSync(mint, vault, true);
 }
@@ -114,7 +220,7 @@ function deriveShuttleAta(shuttleEphemeralAta, mint) {
 function deriveShuttleWalletAta(mint, shuttleEphemeralAta) {
     return getAssociatedTokenAddressSync(mint, shuttleEphemeralAta, true);
 }
-function initEphemeralAtaIx(ephemeralAta, owner, mint, payer, bump) {
+function initEphemeralAtaIx(ephemeralAta, owner, mint, payer) {
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
         keys: [
@@ -124,13 +230,14 @@ function initEphemeralAtaIx(ephemeralAta, owner, mint, payer, bump) {
             { pubkey: mint, isSigner: false, isWritable: false },
             { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
         ],
-        data: Buffer.from([0, bump]),
+        data: Buffer.from([0]),
     });
 }
 function initVaultAtaIx(payer, vaultAta, vault, mint) {
     return createAssociatedTokenAccountIdempotentInstruction(payer, vaultAta, vault, mint);
 }
-function initVaultIx(vault, mint, payer, bump) {
+function initVaultIx(vault, mint, payer) {
+    const [vaultEphemeralAta] = deriveEphemeralAta(vault, mint);
     const vaultAta = deriveVaultAta(mint, vault);
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
@@ -138,6 +245,7 @@ function initVaultIx(vault, mint, payer, bump) {
             { pubkey: vault, isSigner: false, isWritable: true },
             { pubkey: payer, isSigner: true, isWritable: true },
             { pubkey: mint, isSigner: false, isWritable: false },
+            { pubkey: vaultEphemeralAta, isSigner: false, isWritable: true },
             { pubkey: vaultAta, isSigner: false, isWritable: true },
             { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
             {
@@ -147,7 +255,18 @@ function initVaultIx(vault, mint, payer, bump) {
             },
             { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
         ],
-        data: Buffer.from([1, bump]),
+        data: Buffer.from([1]),
+    });
+}
+function initRentPdaIx(payer, rentPda) {
+    return new web3_js_1.TransactionInstruction({
+        programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+        keys: [
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: rentPda, isSigner: false, isWritable: true },
+            { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.from([23]),
     });
 }
 function transferToVaultIx(ephemeralAta, vault, mint, sourceAta, vaultAta, owner, amount) {
@@ -162,16 +281,16 @@ function transferToVaultIx(ephemeralAta, vault, mint, sourceAta, vaultAta, owner
             { pubkey: owner, isSigner: true, isWritable: false },
             { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
         ],
-        data: Buffer.from([2, ...u64le(amount)]),
+        data: encodeAmountInstructionData(2, amount),
     });
 }
 function depositSplTokensIx(ephemeralAta, vault, mint, sourceAta, vaultAta, owner, amount) {
     return transferToVaultIx(ephemeralAta, vault, mint, sourceAta, vaultAta, owner, amount);
 }
-function delegateEphemeralAtaIx(payer, ephemeralAta, bump, validator) {
+function delegateEphemeralAtaIx(payer, ephemeralAta, validator) {
     const data = validator
-        ? Buffer.concat([Buffer.from([4, bump]), validator.toBuffer()])
-        : Buffer.from([4, bump]);
+        ? Buffer.concat([Buffer.from([4]), validator.toBuffer()])
+        : Buffer.from([4]);
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
         keys: [
@@ -203,16 +322,15 @@ function delegateEphemeralAtaIx(payer, ephemeralAta, bump, validator) {
         data,
     });
 }
-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 = Buffer.alloc(6);
+    const data = Buffer.alloc(5);
     data[0] = 11;
     data.writeUInt32LE(shuttleId, 1);
-    data[5] = bump;
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
         keys: [
@@ -233,10 +351,10 @@ function initShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shutt
         data,
     });
 }
-function delegateShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, bump, validator) {
+function delegateShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, validator) {
     const data = validator
-        ? Buffer.concat([Buffer.from([13, bump]), validator.toBuffer()])
-        : Buffer.from([13, bump]);
+        ? Buffer.concat([Buffer.from([13]), validator.toBuffer()])
+        : Buffer.from([13]);
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
         keys: [
@@ -269,6 +387,206 @@ function delegateShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, b
         data,
     });
 }
+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] = deriveRentPda();
+    const [vault] = deriveVault(mint);
+    const vaultAta = deriveVaultAta(mint, vault);
+    const data = validator ? Buffer.alloc(45) : Buffer.alloc(13);
+    data[0] = 24;
+    data.writeUInt32LE(shuttleId, 1);
+    data.writeBigUInt64LE(amount, 5);
+    if (validator) {
+        validator.toBuffer().copy(data, 13);
+    }
+    return new web3_js_1.TransactionInstruction({
+        programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+        keys: [
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: rentPda, isSigner: false, isWritable: true },
+            { pubkey: shuttleEphemeralAta, isSigner: false, isWritable: true },
+            { pubkey: shuttleAta, isSigner: false, isWritable: true },
+            { pubkey: shuttleWalletAta, isSigner: false, isWritable: true },
+            { pubkey: owner, isSigner: true, isWritable: false },
+            {
+                pubkey: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+                isSigner: false,
+                isWritable: false,
+            },
+            {
+                pubkey: (0, pda_js_1.delegateBufferPdaFromDelegatedAccountAndOwnerProgram)(shuttleAta, constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: (0, pda_js_1.delegationRecordPdaFromDelegatedAccount)(shuttleAta),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: (0, pda_js_1.delegationMetadataPdaFromDelegatedAccount)(shuttleAta),
+                isSigner: false,
+                isWritable: true,
+            },
+            { pubkey: constants_js_1.DELEGATION_PROGRAM_ID, isSigner: false, isWritable: false },
+            {
+                pubkey: ASSOCIATED_TOKEN_PROGRAM_ID,
+                isSigner: false,
+                isWritable: false,
+            },
+            { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+            { pubkey: destinationAta, isSigner: false, isWritable: true },
+            { pubkey: mint, isSigner: false, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: false },
+            { pubkey: sourceAta, isSigner: false, isWritable: true },
+            { pubkey: vaultAta, isSigner: false, isWritable: true },
+        ],
+        data,
+    });
+}
+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 (!Number.isInteger(split) || split <= 0 || split > 4294967295) {
+        throw new Error("split must fit in u32");
+    }
+    if (amount < 0n || minDelayMs < 0n || maxDelayMs < 0n) {
+        throw new Error("amount and delays 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");
+    }
+    const [rentPda] = deriveRentPda();
+    const [vault] = deriveVault(mint);
+    const vaultAta = deriveVaultAta(mint, vault);
+    const [queue] = (0, transferQueue_js_1.deriveTransferQueue)(mint);
+    const encryptedDestination = encryptEd25519Recipient(destinationOwner.toBytes(), 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(validator.toBytes()),
+        encodeLengthPrefixedBytes(encryptedDestination),
+        encodeLengthPrefixedBytes(encryptedSuffix),
+    ]);
+    return new web3_js_1.TransactionInstruction({
+        programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+        keys: [
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: rentPda, isSigner: false, isWritable: true },
+            { pubkey: shuttleEphemeralAta, isSigner: false, isWritable: true },
+            { pubkey: shuttleAta, isSigner: false, isWritable: true },
+            { pubkey: shuttleWalletAta, isSigner: false, isWritable: true },
+            { pubkey: owner, isSigner: true, isWritable: false },
+            {
+                pubkey: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+                isSigner: false,
+                isWritable: false,
+            },
+            {
+                pubkey: (0, pda_js_1.delegateBufferPdaFromDelegatedAccountAndOwnerProgram)(shuttleAta, constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: (0, pda_js_1.delegationRecordPdaFromDelegatedAccount)(shuttleAta),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: (0, pda_js_1.delegationMetadataPdaFromDelegatedAccount)(shuttleAta),
+                isSigner: false,
+                isWritable: true,
+            },
+            { pubkey: constants_js_1.DELEGATION_PROGRAM_ID, isSigner: false, isWritable: false },
+            {
+                pubkey: ASSOCIATED_TOKEN_PROGRAM_ID,
+                isSigner: false,
+                isWritable: false,
+            },
+            { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+            { pubkey: mint, isSigner: false, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: false },
+            { pubkey: sourceAta, isSigner: false, isWritable: true },
+            { pubkey: vaultAta, isSigner: false, isWritable: true },
+            { pubkey: queue, isSigner: false, isWritable: true },
+        ],
+        data,
+    });
+}
+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] = deriveRentPda();
+    const data = validator ? Buffer.alloc(45) : Buffer.alloc(13);
+    data[0] = 26;
+    data.writeUInt32LE(shuttleId, 1);
+    data.writeBigUInt64LE(amount, 5);
+    if (validator) {
+        validator.toBuffer().copy(data, 13);
+    }
+    return new web3_js_1.TransactionInstruction({
+        programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+        keys: [
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: rentPda, isSigner: false, isWritable: true },
+            { pubkey: shuttleEphemeralAta, isSigner: false, isWritable: true },
+            { pubkey: shuttleAta, isSigner: false, isWritable: true },
+            { pubkey: shuttleWalletAta, isSigner: false, isWritable: true },
+            { pubkey: owner, isSigner: true, isWritable: false },
+            {
+                pubkey: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
+                isSigner: false,
+                isWritable: false,
+            },
+            {
+                pubkey: (0, pda_js_1.delegateBufferPdaFromDelegatedAccountAndOwnerProgram)(shuttleAta, constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: (0, pda_js_1.delegationRecordPdaFromDelegatedAccount)(shuttleAta),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: (0, pda_js_1.delegationMetadataPdaFromDelegatedAccount)(shuttleAta),
+                isSigner: false,
+                isWritable: true,
+            },
+            { pubkey: constants_js_1.DELEGATION_PROGRAM_ID, isSigner: false, isWritable: false },
+            {
+                pubkey: ASSOCIATED_TOKEN_PROGRAM_ID,
+                isSigner: false,
+                isWritable: false,
+            },
+            { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+            { pubkey: ownerAta, isSigner: false, isWritable: true },
+            { pubkey: mint, isSigner: false, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
 function mergeShuttleIntoAtaIx(owner, destinationAta, shuttleEphemeralAta, shuttleWalletAta, mint) {
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
@@ -283,7 +601,10 @@ function mergeShuttleIntoAtaIx(owner, destinationAta, shuttleEphemeralAta, shutt
         data: Buffer.from([15]),
     });
 }
-function undelegateAndCloseShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta) {
+function undelegateAndCloseShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta, escrowIndex) {
+    const data = escrowIndex === undefined
+        ? Buffer.from([14])
+        : Buffer.from([14, escrowIndex]);
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
         keys: [
@@ -295,12 +616,12 @@ function undelegateAndCloseShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shu
             { pubkey: constants_js_1.MAGIC_CONTEXT_ID, isSigner: false, isWritable: true },
             { pubkey: constants_js_1.MAGIC_PROGRAM_ID, isSigner: false, isWritable: false },
         ],
-        data: Buffer.from([14]),
+        data,
     });
 }
 function withdrawSplIx(owner, mint, amount) {
     const [ephemeralAta] = deriveEphemeralAta(owner, mint);
-    const [vault, vaultBump] = deriveVault(mint);
+    const [vault] = deriveVault(mint);
     const vaultAta = deriveVaultAta(mint, vault);
     const userDestAta = getAssociatedTokenAddressSync(mint, owner);
     return new web3_js_1.TransactionInstruction({
@@ -314,7 +635,7 @@ function withdrawSplIx(owner, mint, amount) {
             { pubkey: userDestAta, isSigner: false, isWritable: true },
             { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
         ],
-        data: Buffer.from([3, ...u64le(amount), vaultBump]),
+        data: encodeAmountInstructionData(3, amount),
     });
 }
 function undelegateIx(owner, mint) {
@@ -352,7 +673,7 @@ function undelegateIx(owner, mint) {
         data: Buffer.from([5]),
     });
 }
-function createEataPermissionIx(ephemeralAta, payer, bump, flags = 0) {
+function createEataPermissionIx(ephemeralAta, payer, flags = 0) {
     const permission = (0, pda_js_1.permissionPdaFromAccount)(ephemeralAta);
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
@@ -363,10 +684,10 @@ function createEataPermissionIx(ephemeralAta, payer, bump, flags = 0) {
             { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
             { pubkey: constants_js_1.PERMISSION_PROGRAM_ID, isSigner: false, isWritable: false },
         ],
-        data: Buffer.from([6, bump, flags]),
+        data: Buffer.from([6, flags]),
     });
 }
-function resetEataPermissionIx(ephemeralAta, payer, bump, flags = 0) {
+function resetEataPermissionIx(ephemeralAta, payer, flags = 0) {
     const permission = (0, pda_js_1.permissionPdaFromAccount)(ephemeralAta);
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
@@ -376,10 +697,10 @@ function resetEataPermissionIx(ephemeralAta, payer, bump, flags = 0) {
             { pubkey: payer, isSigner: true, isWritable: false },
             { pubkey: constants_js_1.PERMISSION_PROGRAM_ID, isSigner: false, isWritable: false },
         ],
-        data: Buffer.from([9, bump, flags]),
+        data: Buffer.from([9, flags]),
     });
 }
-function delegateEataPermissionIx(payer, ephemeralAta, bump, validator) {
+function delegateEataPermissionIx(payer, ephemeralAta, validator) {
     const permission = (0, pda_js_1.permissionPdaFromAccount)(ephemeralAta);
     return new web3_js_1.TransactionInstruction({
         programId: constants_js_1.EPHEMERAL_SPL_TOKEN_PROGRAM_ID,
@@ -407,7 +728,7 @@ function delegateEataPermissionIx(payer, ephemeralAta, bump, validator) {
             { pubkey: constants_js_1.DELEGATION_PROGRAM_ID, isSigner: false, isWritable: false },
             { pubkey: validator, isSigner: false, isWritable: false },
         ],
-        data: Buffer.from([7, bump]),
+        data: Buffer.from([7]),
     });
 }
 function undelegateEataPermissionIx(owner, ephemeralAta) {
@@ -425,99 +746,241 @@ function undelegateEataPermissionIx(owner, ephemeralAta) {
         data: Buffer.from([8]),
     });
 }
-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 ?? initIfMissing;
+    const isPrivate = opts?.private ?? false;
     const instructions = [];
-    const [ephemeralAta, eataBump] = deriveEphemeralAta(owner, mint);
-    const [vault, vaultBump] = deriveVault(mint);
+    const [ephemeralAta] = deriveEphemeralAta(owner, mint);
+    const [vault] = deriveVault(mint);
+    const [vaultEphemeralAta] = deriveEphemeralAta(vault, mint);
     const vaultAta = deriveVaultAta(mint, vault);
     const ownerAta = 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), initVaultAtaIx(payer, vaultAta, vault, mint));
+        instructions.push(initVaultIx(vault, mint, payer), initVaultAtaIx(payer, vaultAta, vault, mint), delegateEphemeralAtaIx(payer, vaultEphemeralAta, validator));
     }
     instructions.push(transferToVaultIx(ephemeralAta, vault, mint, ownerAta, vaultAta, owner, amount));
-    instructions.push(delegateEphemeralAtaIx(payer, ephemeralAta, eataBump, validator));
+    if (isPrivate) {
+        instructions.push(createEataPermissionIx(ephemeralAta, payer));
+    }
+    instructions.push(delegateEphemeralAtaIx(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] = deriveEphemeralAta(owner, mint);
-    const [vault, vaultBump] = deriveVault(mint);
+    const [ephemeralAta] = deriveEphemeralAta(owner, mint);
+    const [vault] = deriveVault(mint);
+    const [vaultEphemeralAta] = deriveEphemeralAta(vault, mint);
     const vaultAta = deriveVaultAta(mint, vault);
     const ownerAta = getAssociatedTokenAddressSync(mint, owner);
-    const [shuttleEphemeralAta, shuttleBump] = deriveShuttleEphemeralAta(owner, mint, shuttleId);
-    const [shuttleAta, shuttleAtaBump] = deriveShuttleAta(shuttleEphemeralAta, mint);
+    const [shuttleEphemeralAta] = deriveShuttleEphemeralAta(owner, mint, shuttleId);
+    const [shuttleAta] = deriveShuttleAta(shuttleEphemeralAta, mint);
     const shuttleWalletAta = deriveShuttleWalletAta(mint, shuttleEphemeralAta);
     if (initVaultIfMissing) {
-        instructions.push(initVaultIx(vault, mint, payer, vaultBump), initVaultAtaIx(payer, vaultAta, vault, mint));
+        instructions.push(initVaultIx(vault, mint, payer), initVaultAtaIx(payer, vaultAta, vault, mint), delegateEphemeralAtaIx(payer, vaultEphemeralAta, validator));
     }
     if (initAtasIfMissing) {
-        instructions.push(createAssociatedTokenAccountIdempotentInstruction(payer, ownerAta, owner, mint), createAssociatedTokenAccountIdempotentInstruction(payer, shuttleWalletAta, shuttleEphemeralAta, mint));
+        instructions.push(createAssociatedTokenAccountIdempotentInstruction(payer, ownerAta, owner, mint));
     }
-    instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer, eataBump), createEataPermissionIx(ephemeralAta, payer, eataBump), delegateEphemeralAtaIx(payer, ephemeralAta, eataBump, validator), initShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta, owner, mint, shuttleId, shuttleBump));
+    if (initIfMissing) {
+        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer));
+    }
+    if (isPrivate) {
+        instructions.push(createEataPermissionIx(ephemeralAta, payer));
+    }
+    instructions.push(delegateEphemeralAtaIx(payer, ephemeralAta, validator));
     if (amount > 0n) {
-        instructions.push(depositSplTokensIx(shuttleAta, vault, mint, ownerAta, vaultAta, owner, amount));
+        instructions.push(setupAndDelegateShuttleEphemeralAtaWithMergeIx(payer, shuttleEphemeralAta, shuttleAta, owner, ownerAta, ownerAta, shuttleWalletAta, mint, shuttleId, amount, validator));
+    }
+    else {
+        instructions.push(initShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, shuttleWalletAta, owner, mint, shuttleId), delegateShuttleEphemeralAtaIx(payer, shuttleEphemeralAta, shuttleAta, validator));
     }
-    instructions.push(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] = deriveEphemeralAta(owner, mint);
-    const [vault, vaultBump] = deriveVault(mint);
+    const [ephemeralAta] = deriveEphemeralAta(owner, mint);
+    const [vault] = deriveVault(mint);
+    const [vaultEphemeralAta] = deriveEphemeralAta(vault, mint);
     const vaultAta = deriveVaultAta(mint, vault);
+    const [queue] = (0, transferQueue_js_1.deriveTransferQueue)(mint);
     const ownerAta = getAssociatedTokenAddressSync(mint, owner);
+    const [shuttleEphemeralAta] = deriveShuttleEphemeralAta(owner, mint, shuttleId);
+    const [shuttleAta] = deriveShuttleAta(shuttleEphemeralAta, mint);
+    const shuttleWalletAta = deriveShuttleWalletAta(mint, shuttleEphemeralAta);
+    if (initVaultIfMissing) {
+        instructions.push(initVaultIx(vault, mint, payer), initVaultAtaIx(payer, vaultAta, vault, mint), delegateEphemeralAtaIx(payer, vaultEphemeralAta, validator));
+    }
+    if (initTransferQueueIfMissing) {
+        instructions.push((0, transferQueue_js_1.initTransferQueueIx)(payer, queue, mint));
+    }
+    if (initAtasIfMissing) {
+        instructions.push(createAssociatedTokenAccountIdempotentInstruction(payer, ownerAta, owner, mint));
+    }
     if (initIfMissing) {
-        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer, eataBump));
+        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer));
+    }
+    instructions.push(delegateEphemeralAtaIx(payer, ephemeralAta, validator), 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 = getAssociatedTokenAddressSync(mint, from);
+    const toAta = getAssociatedTokenAddressSync(mint, to);
+    if (opts.fromBalance === "ephemeral") {
+        switch (opts.visibility) {
+            case "private":
+                if (opts.toBalance === "base") {
+                    const [queue] = (0, transferQueue_js_1.deriveTransferQueue)(mint);
+                    const [vault] = deriveVault(mint);
+                    const vaultAta = deriveVaultAta(mint, vault);
+                    return [
+                        (0, transferQueue_js_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));
-        instructions.push(initVaultAtaIx(payer, vaultAta, vault, mint));
+        const [vault] = deriveVault(mint);
+        const [vaultEphemeralAta] = deriveEphemeralAta(vault, mint);
+        const vaultAta = deriveVaultAta(mint, vault);
+        instructions.push(initVaultIx(vault, mint, payer), initVaultAtaIx(payer, vaultAta, vault, mint), delegateEphemeralAtaIx(payer, vaultEphemeralAta, validator));
     }
-    instructions.push(transferToVaultIx(ephemeralAta, vault, mint, ownerAta, vaultAta, owner, amount));
-    instructions.push(delegateEphemeralAtaIx(payer, ephemeralAta, eataBump, validator));
-    instructions.push(createEataPermissionIx(ephemeralAta, payer, eataBump, permissionFlags));
-    if (delegatePermission) {
-        instructions.push(delegateEataPermissionIx(payer, ephemeralAta, eataBump, validator));
+    if (opts.fromBalance === "base" && initAtasIfMissing) {
+        instructions.push(createAssociatedTokenAccountIdempotentInstruction(payer, fromAta, from, mint));
+    }
+    switch (opts.visibility) {
+        case "private":
+            if (opts.fromBalance === "base" && opts.toBalance === "base") {
+                const [shuttleEphemeralAta] = deriveShuttleEphemeralAta(from, mint, shuttleId);
+                const [shuttleAta] = deriveShuttleAta(shuttleEphemeralAta, mint);
+                const shuttleWalletAta = deriveShuttleWalletAta(mint, shuttleEphemeralAta);
+                return [
+                    ...instructions,
+                    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] = deriveEphemeralAta(to, mint);
+                    instructions.push(createAssociatedTokenAccountIdempotentInstruction(payer, toAta, to, mint), initEphemeralAtaIx(toEphemeralAta, to, mint, payer), delegateEphemeralAtaIx(payer, toEphemeralAta, validator));
+                }
+                const [shuttleEphemeralAta] = deriveShuttleEphemeralAta(from, mint, shuttleId);
+                const [shuttleAta] = deriveShuttleAta(shuttleEphemeralAta, mint);
+                const shuttleWalletAta = deriveShuttleWalletAta(mint, shuttleEphemeralAta);
+                return [
+                    ...instructions,
+                    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] = deriveEphemeralAta(owner, mint);
+    const ownerAta = getAssociatedTokenAddressSync(mint, owner);
+    const [shuttleEphemeralAta] = deriveShuttleEphemeralAta(owner, mint, shuttleId);
+    const [shuttleAta] = deriveShuttleAta(shuttleEphemeralAta, mint);
+    const shuttleWalletAta = deriveShuttleWalletAta(mint, shuttleEphemeralAta);
+    if (initAtasIfMissing) {
+        instructions.push(createAssociatedTokenAccountIdempotentInstruction(payer, ownerAta, owner, mint));
     }
+    if (initIfMissing) {
+        instructions.push(initEphemeralAtaIx(ephemeralAta, owner, mint, payer));
+    }
+    instructions.push(delegateEphemeralAtaIx(payer, ephemeralAta, validator), 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 = getAssociatedTokenAddressSync(mint, owner);
+            instructions.push(createAssociatedTokenAccountIdempotentInstruction(payer, ownerAta, owner, mint));
+        }
+        instructions.push(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 data = Buffer.alloc(1 + 8 + suffix.length);
+    data[0] = discriminator;
+    data.writeBigUInt64LE(amount, 1);
+    if (suffix.length > 0) {
+        data.set(suffix, 9);
     }
-    return bytes;
+    return data;
 }
 //# sourceMappingURL=ephemeralAta.js.map