@metamask/delegation-toolkit
Version:
The Delegation Toolkit built on top of Viem - a library for interacting with DeleGator Smart Accounts
392 lines (326 loc) • 12.3 kB
JavaScript
;Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
var _chunkTJMYQ3DCcjs = require('./chunk-TJMYQ3DC.cjs');
var _chunk6AW64Z7Tcjs = require('./chunk-6AW64Z7T.cjs');
require('./chunk-XV2EBM2H.cjs');
var _chunkGTWYOVMEcjs = require('./chunk-GTWYOVME.cjs');
require('./chunk-TH3X773I.cjs');
var _chunkQWXIZ4QUcjs = require('./chunk-QWXIZ4QU.cjs');
var _chunkT6PSFUOZcjs = require('./chunk-T6PSFUOZ.cjs');
var _chunkSEFYSAJDcjs = require('./chunk-SEFYSAJD.cjs');
// src/toMetaMaskSmartAccount.ts
var _delegationabis = require('@metamask/delegation-abis');
var _accountabstraction = require('viem/account-abstraction');
// src/signatory.ts
var _viem = require('viem');
// src/signatures.ts
var signatureTypes = ["ECDSA"];
var aggregateSignature = ({
signatures
}) => {
if (signatures.length === 0) {
return "0x";
}
for (const { type } of signatures) {
if (!signatureTypes.includes(type)) {
throw new Error(`Invalid signature type: ${type}`);
}
}
const sortedSignatures = [...signatures].sort(
(a, b) => a.signer.localeCompare(b.signer)
);
return _viem.concat.call(void 0, sortedSignatures.map(({ signature }) => signature));
};
// src/signatory.ts
var EOA_STUB_SIGNATURE = "0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000011b";
var resolveSignatoryFromWalletConfig = (config) => {
return {
signMessage: config.walletClient.signMessage,
signTypedData: async (typedData) => {
return config.walletClient.signTypedData(typedData);
},
getStubSignature: async () => EOA_STUB_SIGNATURE
};
};
var resolveSignatoryFromAccountConfig = (config) => {
return {
signMessage: config.account.signMessage,
signTypedData: config.account.signTypedData,
getStubSignature: async () => EOA_STUB_SIGNATURE
};
};
var resolveHybridSignatory = (config) => {
if ("walletClient" in config) {
return resolveSignatoryFromWalletConfig(config);
} else if ("account" in config) {
const { signMessage: signMessage2, signTypedData: signTypedData2, getStubSignature: getStubSignature2 } = resolveSignatoryFromAccountConfig(config);
if (!signMessage2) {
throw new Error("Account does not support signMessage");
}
if (!signTypedData2) {
throw new Error("Account does not support signTypedData");
}
return {
signMessage: signMessage2,
signTypedData: signTypedData2,
getStubSignature: getStubSignature2
};
}
const { keyId, webAuthnAccount } = config;
if (webAuthnAccount.type !== "webAuthn") {
throw new Error("Account is not a webAuthn account");
}
const encodeSignature = ({ signature, webauthn }) => _chunkGTWYOVMEcjs.encodeDeleGatorSignature.call(void 0,
keyId,
signature,
webauthn.clientDataJSON,
webauthn.authenticatorData
);
const signMessage = async (args) => webAuthnAccount.signMessage(args).then(encodeSignature);
const signTypedData = async (typedDataDefinition) => webAuthnAccount.signTypedData(typedDataDefinition).then(encodeSignature);
const getStubSignature = async () => _chunkGTWYOVMEcjs.createDummyWebAuthnSignature.call(void 0, keyId);
return {
signMessage,
signTypedData,
getStubSignature
};
};
var resolveMultiSigSignatory = (config) => {
const resolvedSignatories = config.map((signatory) => {
let individualSignMessage;
let individualSignTypedData;
let address;
if ("walletClient" in signatory) {
const { signMessage: signMessage2, signTypedData: signTypedData2 } = resolveSignatoryFromWalletConfig(signatory);
individualSignMessage = signMessage2;
individualSignTypedData = signTypedData2;
address = signatory.walletClient.account.address;
} else {
const { signMessage: signMessage2, signTypedData: signTypedData2 } = resolveSignatoryFromAccountConfig(signatory);
if (!signMessage2) {
throw new Error("Account does not support signMessage");
}
if (!signTypedData2) {
throw new Error("Account does not support signTypedData");
}
individualSignMessage = signMessage2;
individualSignTypedData = signTypedData2;
address = signatory.account.address;
}
return {
address,
individualSignMessage,
individualSignTypedData
};
});
const signMessage = async (args) => {
const addressAndSignatures = resolvedSignatories.map(
async ({ individualSignMessage, address }) => ({
signature: await individualSignMessage(args),
signer: address,
type: "ECDSA"
})
);
const signatures = await Promise.all(addressAndSignatures);
return aggregateSignature({
signatures
});
};
const signTypedData = async (typedDataDefinition) => {
const addressAndSignatures = resolvedSignatories.map(
async ({ individualSignTypedData, address }) => ({
signature: await individualSignTypedData(typedDataDefinition),
signer: address,
type: "ECDSA"
})
);
const signatures = await Promise.all(addressAndSignatures);
return aggregateSignature({
signatures
});
};
const getStubSignature = async () => _viem.concat.call(void 0, resolvedSignatories.map(() => EOA_STUB_SIGNATURE));
return {
signMessage,
signTypedData,
getStubSignature
};
};
var resolveStateless7702Signatory = (config) => {
if ("walletClient" in config) {
return resolveSignatoryFromWalletConfig(config);
} else if ("account" in config) {
const { signMessage, signTypedData, getStubSignature } = resolveSignatoryFromAccountConfig(config);
if (!signMessage) {
throw new Error("Account does not support signMessage");
}
if (!signTypedData) {
throw new Error("Account does not support signTypedData");
}
return {
signMessage,
signTypedData,
getStubSignature
};
}
throw new Error("Invalid signatory config");
};
var resolveSignatory = (config) => {
const { implementation } = config;
if (implementation === "Hybrid" /* Hybrid */) {
return resolveHybridSignatory(config.signatory);
} else if (implementation === "MultiSig" /* MultiSig */) {
return resolveMultiSigSignatory(
config.signatory
);
} else if (implementation === "Stateless7702" /* Stateless7702 */) {
return resolveStateless7702Signatory(
config.signatory
);
}
throw new Error(`Implementation type '${implementation}' not supported`);
};
// src/toMetaMaskSmartAccount.ts
var ENTRYPOINT_VERSION = "0.7";
async function toMetaMaskSmartAccount(params) {
const {
client,
client: { chain },
implementation
} = params;
if (!chain) {
throw new Error("Chain not specified");
}
const signatory = resolveSignatory({
implementation,
signatory: params.signatory
});
const environment = _nullishCoalesce(params.environment, () => ( _chunkQWXIZ4QUcjs.getDeleGatorEnvironment.call(void 0, chain.id)));
let address, factoryData;
if (params.address) {
factoryData = void 0;
address = params.address;
} else {
if (implementation === "Stateless7702" /* Stateless7702 */) {
throw new Error("Stateless7702 does not support counterfactual accounts");
}
const accountData = await _chunkGTWYOVMEcjs.getCounterfactualAccountData.call(void 0, {
factory: environment.SimpleFactory,
implementations: environment.implementations,
implementation,
deployParams: params.deployParams,
deploySalt: params.deploySalt
});
address = accountData.address;
factoryData = accountData.factoryData;
}
const entryPoint = {
abi: _accountabstraction.entryPoint07Abi,
address: environment.EntryPoint,
version: ENTRYPOINT_VERSION
};
const { abi, contractName } = {
["Hybrid" /* Hybrid */]: {
contractName: "HybridDeleGator",
abi: _delegationabis.HybridDeleGator.abi
},
["MultiSig" /* MultiSig */]: {
contractName: "MultiSigDeleGator",
abi: _delegationabis.MultiSigDeleGator.abi
},
["Stateless7702" /* Stateless7702 */]: {
contractName: "EIP7702StatelessDeleGator",
abi: _delegationabis.EIP7702StatelessDeleGator.abi
}
}[implementation];
const getFactoryArgs = async () => {
if (factoryData === void 0) {
throw new Error(
"Deploy params were not provided, so factory args cannot be inferred"
);
}
return {
factoryData,
factory: environment.SimpleFactory
};
};
const signDelegation2 = async (delegationParams) => {
const { delegation, chainId } = delegationParams;
const delegationStruct = _chunkSEFYSAJDcjs.toDelegationStruct.call(void 0, {
...delegation,
signature: "0x"
});
const signature = signatory.signTypedData({
domain: {
chainId: _nullishCoalesce(chainId, () => ( chain.id)),
name: "DelegationManager",
version: "1",
verifyingContract: environment.DelegationManager
},
types: _chunkSEFYSAJDcjs.SIGNABLE_DELEGATION_TYPED_DATA,
primaryType: "Delegation",
message: delegationStruct
});
return signature;
};
const signUserOperation2 = async (userOpParams) => {
const { chainId } = userOpParams;
const packedUserOp = _accountabstraction.toPackedUserOperation.call(void 0, {
sender: address,
...userOpParams,
signature: "0x"
});
const signature = await signatory.signTypedData({
domain: {
chainId: _nullishCoalesce(chainId, () => ( chain.id)),
name: contractName,
version: "1",
verifyingContract: address
},
types: _chunkGTWYOVMEcjs.SIGNABLE_USER_OP_TYPED_DATA,
primaryType: "PackedUserOperation",
message: { ...packedUserOp, entryPoint: entryPoint.address }
});
return signature;
};
const getAddress = async () => address;
const getNonce = async () => _chunk6AW64Z7Tcjs.read.call(void 0, {
client,
entryPoint: environment.EntryPoint,
contractAddress: address,
key: 0n
});
const encodeCalls = async (calls) => _chunkGTWYOVMEcjs.encodeCallsForCaller.call(void 0, address, calls);
const smartAccount = await _accountabstraction.toSmartAccount.call(void 0, {
abi,
client,
entryPoint,
environment,
getAddress,
getFactoryArgs,
encodeCalls,
getNonce,
signUserOperation: signUserOperation2,
signDelegation: signDelegation2,
...signatory
});
if (implementation === "Stateless7702" /* Stateless7702 */) {
return {
...smartAccount,
isDeployed: async () => _chunkTJMYQ3DCcjs.isValid7702Implementation.call(void 0, {
client,
accountAddress: address,
environment
})
};
}
return smartAccount;
}
// src/actions/caveatEnforcerClient.ts
function createCaveatEnforcerClient({
client,
environment
}) {
return client.extend(_chunkTJMYQ3DCcjs.caveatEnforcerActions.call(void 0, { environment }));
}
exports.ANY_BENEFICIARY = _chunkSEFYSAJDcjs.ANY_BENEFICIARY; exports.BalanceChangeType = _chunkSEFYSAJDcjs.BalanceChangeType; exports.ExecutionMode = _chunkT6PSFUOZcjs.ExecutionMode; exports.Implementation = _chunkGTWYOVMEcjs.Implementation; exports.PREFERRED_VERSION = _chunkQWXIZ4QUcjs.PREFERRED_VERSION; exports.ROOT_AUTHORITY = _chunkSEFYSAJDcjs.ROOT_AUTHORITY; exports.actions = _chunkTJMYQ3DCcjs.actions_exports; exports.aggregateSignature = aggregateSignature; exports.contracts = _chunk6AW64Z7Tcjs.contracts_exports; exports.createCaveat = _chunkSEFYSAJDcjs.createCaveat; exports.createCaveatEnforcerClient = createCaveatEnforcerClient; exports.createDelegation = _chunkSEFYSAJDcjs.createDelegation; exports.createExecution = _chunkT6PSFUOZcjs.createExecution; exports.createOpenDelegation = _chunkSEFYSAJDcjs.createOpenDelegation; exports.getDeleGatorEnvironment = _chunkQWXIZ4QUcjs.getDeleGatorEnvironment; exports.redeemDelegations = _chunkQWXIZ4QUcjs.redeemDelegations; exports.signDelegation = _chunkSEFYSAJDcjs.signDelegation; exports.signUserOperation = _chunkGTWYOVMEcjs.signUserOperation; exports.toMetaMaskSmartAccount = toMetaMaskSmartAccount;
//# sourceMappingURL=index.cjs.map