@usearete/sdk 0.6.0 → 0.7.1

package/dist/index.cjs

@@ -4252,6 +4252,9 @@ function sortAccountsByDependency(accountMetas) {
                     deps.add(seed.accountName);
                 }
             }
+            if (meta.pdaConfig.program?.type === 'accountRef') {
+                deps.add(meta.pdaConfig.program.accountName);
+            }
         }
         pdaDeps.set(meta.name, deps);
     }
@@ -4345,9 +4348,19 @@ function resolveAccounts(accountMetas, args, options) {
     };
 }
 function resolveSingleAccount(meta, args, options, resolvedMap) {
+    const explicit = options.accounts?.[meta.name];
+    if (explicit !== undefined) {
+        validateAccountAddress(meta.name, explicit);
+        return {
+            name: meta.name,
+            address: explicit,
+            isSigner: meta.isSigner,
+            isWritable: meta.isWritable,
+        };
+    }
     switch (meta.category) {
         case 'signer':
-            return resolveSignerAccount(meta, options.accounts, options.wallet);
+            return resolveSignerAccount(meta, options.wallet);
         case 'known':
             return resolveKnownAccount(meta);
         case 'pda':
@@ -4358,8 +4371,22 @@ function resolveSingleAccount(meta, args, options, resolvedMap) {
             return null;
     }
 }
-function resolveSignerAccount(meta, accounts, wallet) {
-    const address = accounts?.[meta.name] ?? wallet?.publicKey;
+function validateAccountAddress(name, address) {
+    let decoded;
+    try {
+        decoded = decodeBase58(address);
+    }
+    catch {
+        throw new Error(`Invalid account override for "${name}": expected a base58 public key`);
+    }
+    if (decoded.length !== 32) {
+        throw new Error(`Invalid account override for "${name}": expected a 32-byte public key, got ${decoded.length} bytes`);
+    }
+}
+function resolveSignerAccount(meta, wallet) {
+    // An IDL only tells us that an account signs; it cannot prove that the
+    // account is the connected wallet. Wallet fallback is therefore opt-in.
+    const address = meta.signerKind === 'wallet' ? wallet?.publicKey : undefined;
     if (!address) {
         return null;
     }
@@ -4386,7 +4413,7 @@ function resolvePdaAccount(meta, args, resolvedMap, programId, resolve) {
         return null;
     }
     // Determine which program to derive against
-    const pdaProgramId = meta.pdaConfig.programId || programId;
+    const pdaProgramId = resolvePdaProgram(meta.pdaConfig, args, resolvedMap, programId, resolve);
     if (!pdaProgramId) {
         throw new Error('Cannot derive PDA for "' + meta.name + '": no programId specified. ' +
             'Either set pdaConfig.programId or pass programId in options.');
@@ -4433,6 +4460,24 @@ function resolvePdaAccount(meta, args, resolvedMap, programId, resolve) {
         isWritable: meta.isWritable,
     };
 }
+function resolvePdaProgram(config, args, resolvedMap, defaultProgramId, resolve) {
+    if (config.program?.type === 'accountRef') {
+        const account = resolvedMap[config.program.accountName];
+        if (!account) {
+            throw new Error('PDA program references unresolved account: ' + config.program.accountName);
+        }
+        return account.address;
+    }
+    if (config.program?.type === 'argRef') {
+        const value = getValueByPath(args, config.program.argName)
+            ?? getValueByPath(resolve, config.program.argName);
+        if (typeof value !== 'string' || value.length === 0) {
+            throw new Error('PDA program references missing or non-address argument: ' + config.program.argName);
+        }
+        return value;
+    }
+    return config.programId || defaultProgramId;
+}
 function resolveUserProvidedAccount(meta, accounts) {
     const address = accounts?.[meta.name];
     if (!address) {
@@ -5056,10 +5101,10 @@ function createInstructionHandler(config) {
  *
  * Keys matching a declared argument name are args; keys matching a declared
  * account name (with a string value) are account address overrides. This
- * applies to signer slots too, allowing explicit signer addresses to override
- * the wallet fallback. Anything else throws — a typo'd key silently dropped
+ * applies to signer slots too, allowing explicit signer addresses to fill or
+ * override those slots. Anything else throws — a typo'd key silently dropped
  * here would otherwise change the built instruction. `options.accounts` on
- * {@link BuildOptions} remains an unvalidated escape hatch for advanced callers.
+ * {@link BuildOptions} is the explicit override map and wins over merged params.
  */
 function splitParams(handler, params) {
     const argNameSet = new Set(handler.argNames);
@@ -5208,22 +5253,39 @@ function resolveSeeds(seeds, context) {
         }
     });
 }
-function pda(programId, ...seeds) {
+function resolveProgram(selector, context) {
+    if (typeof selector === 'string')
+        return context.programId ?? selector;
+    if (selector.type === 'accountRef') {
+        const address = context.accounts?.[selector.accountName];
+        if (!address)
+            throw new Error(`Missing account for PDA program: ${selector.accountName}`);
+        return address;
+    }
+    const value = getValueByPath(context.args, selector.argName)
+        ?? getValueByPath(context.resolve, selector.argName);
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`Missing argument for PDA program: ${selector.argName}`);
+    }
+    return value;
+}
+function pda(programSelector, ...seeds) {
     return {
         seeds,
-        programId,
+        programId: typeof programSelector === 'string' ? programSelector : undefined,
+        programSelector,
         program(newProgramId) {
             return pda(newProgramId, ...seeds);
         },
         async derive(context) {
             const resolvedSeeds = resolveSeeds(this.seeds, context);
-            const pid = context.programId ?? this.programId;
+            const pid = resolveProgram(this.programSelector, context);
             const [address] = await findProgramAddress(resolvedSeeds, pid);
             return address;
         },
         deriveSync(context) {
             const resolvedSeeds = resolveSeeds(this.seeds, context);
-            const pid = context.programId ?? this.programId;
+            const pid = resolveProgram(this.programSelector, context);
             const [address] = findProgramAddressSync(resolvedSeeds, pid);
             return address;
         },
@@ -5386,6 +5448,7 @@ function createPreparedTransactionBody(input) {
         name: input.name,
         instructions,
         requiredSignerAddresses: dedupe(input.requiredSignerAddresses ?? inferSignerAddresses(instructions)),
+        signers: [...new Set(input.signers ?? [])],
         errors: [...(input.errors ?? [])],
     };
 }
@@ -5401,6 +5464,7 @@ function createPreparedInstruction(input) {
         name: input.name,
         instructions: [input.instruction],
         requiredSignerAddresses: input.requiredSignerAddresses,
+        signers: input.signers,
         errors: input.errors,
     });
     return {
@@ -5431,6 +5495,10 @@ function createPreparedTransaction(input) {
         instructions: transactionParts.flatMap((part) => part.instructions),
         requiredSignerAddresses: input.requiredSignerAddresses
             ?? transactionParts.flatMap((part) => part.requiredSignerAddresses),
+        signers: [
+            ...transactionParts.flatMap((part) => part.signers),
+            ...(input.signers ?? []),
+        ],
         errors: input.errors ?? transactionParts.flatMap((part) => part.errors),
     });
     return {
@@ -5507,8 +5575,8 @@ function inferSignerAddress(value) {
     const publicKey = candidate.publicKey;
     return typeof publicKey?.toBase58 === 'function' ? publicKey.toBase58() : null;
 }
-function validateTransactionSigners(transaction, host, options) {
-    const signerAddresses = (options.signers ?? []).map(inferSignerAddress);
+function validateTransactionSigners(transaction, host, options, signers) {
+    const signerAddresses = signers.map(inferSignerAddress);
     const available = new Set(options.availableSignerAddresses ?? []);
     for (const address of options.signerRegistry?.addresses() ?? []) {
         available.add(address);
@@ -5594,15 +5662,16 @@ async function runOperationCallback(input, callbackErrors, onCallbackError) {
 async function executePreparedOperation(host, operation, options = {}) {
     const receipts = [];
     const callbackErrors = [];
-    const signers = [
-        ...new Set([
-            ...(options.signerRegistry?.values() ?? []),
-            ...(options.signers ?? []),
-        ]),
-    ];
     for (const [transactionIndex, transaction] of operation.plan.transactions.entries()) {
+        const signers = [
+            ...new Set([
+                ...(transaction.signers ?? []),
+                ...(options.signerRegistry?.values() ?? []),
+                ...(options.signers ?? []),
+            ]),
+        ];
         try {
-            validateTransactionSigners(transaction, host, options);
+            validateTransactionSigners(transaction, host, options, signers);
         }
         catch (cause) {
             throw new OperationExecutionError({