@rhinestone/sdk 0.7.10 → 0.8.0

package/dist/src/orchestrator/utils.js

@@ -1,303 +0,0 @@
-import { domainSeparator, encodeAbiParameters, encodePacked, keccak256, zeroAddress, } from 'viem';
-import { HOOK_ADDRESS } from '../modules/index.js';
-import { BUNDLE_STATUS_COMPLETED, BUNDLE_STATUS_EXPIRED, BUNDLE_STATUS_FAILED, BUNDLE_STATUS_FILLED, BUNDLE_STATUS_PARTIALLY_COMPLETED, BUNDLE_STATUS_PENDING, BUNDLE_STATUS_PRECONFIRMED, BUNDLE_STATUS_UNKNOWN, } from './types.js';
-const MULTICHAIN_COMPACT_TYPEHASH = '0xee54591377b86e048be6b2fbd8913598a6270aed3415776321279495bf4efae5';
-const SEGMENT_TYPEHASH = '0x54ada5b33a7390e2883c985295cfa2dcd9bb46515ad10cbdfc22a7c73f9807db';
-const WITNESS_TYPEHASH = '0x78e29a727cef567e7d6dddf5bf7eedf0c84af60d4a57512c586c787aae731629';
-const EXECUTION_TYPEHASH = '0xa222cbaaad3b88446c3ca031429dafb24afdbda10c5dbd9882c294762857141a';
-var BundleStatusEnum;
-(function (BundleStatusEnum) {
-    BundleStatusEnum["PENDING"] = "PENDING";
-    BundleStatusEnum["EXPIRED"] = "EXPIRED";
-    BundleStatusEnum["PARTIALLY_COMPLETED"] = "PARTIALLY_COMPLETED";
-    BundleStatusEnum["PRECONFIRMED"] = "PRECONFIRMED";
-    BundleStatusEnum["COMPLETED"] = "COMPLETED";
-    BundleStatusEnum["FILLED"] = "FILLED";
-    BundleStatusEnum["FAILED"] = "FAILED";
-    BundleStatusEnum["UNKNOWN"] = "UNKNOWN";
-})(BundleStatusEnum || (BundleStatusEnum = {}));
-function getEmptyUserOp() {
-    return {
-        sender: zeroAddress,
-        nonce: 0n,
-        callData: '0x',
-        preVerificationGas: 0n,
-        maxFeePerGas: 0n,
-        maxPriorityFeePerGas: 0n,
-        verificationGasLimit: 0n,
-        callGasLimit: 0n,
-        signature: '0x',
-    };
-}
-function getOrderBundleHash(orderBundle) {
-    const notarizedChainId = Number(orderBundle.segments[0].chainId);
-    return hashMultiChainCompactWithDomainSeparator(orderBundle, getCompactDomainSeparator(notarizedChainId, HOOK_ADDRESS));
-}
-function convertBigIntFields(obj) {
-    if (obj === null || obj === undefined) {
-        return obj;
-    }
-    if (typeof obj === 'bigint') {
-        return obj.toString();
-    }
-    if (Array.isArray(obj)) {
-        return obj.map(convertBigIntFields);
-    }
-    if (typeof obj === 'object') {
-        const result = {};
-        for (const key in obj) {
-            if (Object.hasOwn(obj, key)) {
-                result[key] = convertBigIntFields(obj[key]);
-            }
-        }
-        return result;
-    }
-    return obj;
-}
-function parseCompactResponse(response) {
-    return {
-        sponsor: response.sponsor,
-        nonce: BigInt(response.nonce),
-        expires: BigInt(response.expires),
-        segments: response.segments.map((segment) => {
-            return {
-                arbiter: segment.arbiter,
-                chainId: BigInt(segment.chainId),
-                idsAndAmounts: segment.idsAndAmounts.map((idsAndAmount) => {
-                    return [BigInt(idsAndAmount[0]), BigInt(idsAndAmount[1])];
-                }),
-                witness: {
-                    recipient: segment.witness.recipient,
-                    tokenOut: segment.witness.tokenOut.map((tokenOut) => {
-                        return [BigInt(tokenOut[0]), BigInt(tokenOut[1])];
-                    }),
-                    depositId: BigInt(segment.witness.depositId),
-                    targetChain: BigInt(segment.witness.targetChain),
-                    fillDeadline: segment.witness.fillDeadline,
-                    execs: segment.witness.execs.map((exec) => {
-                        return {
-                            to: exec.to,
-                            value: BigInt(exec.value),
-                            data: exec.data,
-                        };
-                    }),
-                    userOpHash: segment.witness.userOpHash,
-                    maxFeeBps: segment.witness.maxFeeBps,
-                },
-            };
-        }),
-    };
-}
-function parseUseChainBalances(response) {
-    const result = {};
-    for (const chainIdStr in response) {
-        const chainId = Number(chainIdStr);
-        const chainData = response[chainIdStr];
-        result[chainId] = {};
-        for (const tokenAddress in chainData) {
-            const balanceStr = chainData[tokenAddress]?.balance;
-            result[chainId][tokenAddress] = BigInt(balanceStr);
-        }
-    }
-    return result;
-}
-function parseOrderCost(response) {
-    const tokensSpent = {};
-    for (const chainIdStr in response.tokensSpent) {
-        const chainId = Number(chainIdStr);
-        tokensSpent[chainId] = {};
-        const chainTokens = response.tokensSpent[chainIdStr];
-        for (const tokenAddress in chainTokens) {
-            const balanceStr = chainTokens[tokenAddress];
-            if (typeof balanceStr !== 'string') {
-                throw new Error(`Expected string balance for token ${tokenAddress} on chain ${chainId}`);
-            }
-            tokensSpent[chainId][tokenAddress] = BigInt(balanceStr);
-        }
-    }
-    const tokensReceived = response.tokensReceived.map((entry) => {
-        return {
-            tokenAddress: entry.tokenAddress,
-            hasFulfilled: entry.hasFulfilled,
-            amountSpent: BigInt(entry.amountSpent),
-            targetAmount: BigInt(entry.targetAmount),
-            fee: BigInt(entry.fee),
-        };
-    });
-    return {
-        hasFulfilledAll: true,
-        tokensSpent,
-        tokensReceived,
-    };
-}
-function parseInsufficientBalanceResult(response) {
-    if (!Array.isArray(response.tokenShortfall)) {
-        throw new Error('Expected tokenShortfall to be an array');
-    }
-    const tokenShortfall = response.tokenShortfall.map((entry) => {
-        return {
-            tokenAddress: entry.tokenAddress,
-            targetAmount: BigInt(entry.targetAmount),
-            amountSpent: BigInt(entry.amountSpent),
-            fee: BigInt(entry.fee),
-            tokenSymbol: entry.tokenSymbol,
-            tokenDecimals: entry.tokenDecimals,
-        };
-    });
-    const result = {
-        hasFulfilledAll: false,
-        tokenShortfall,
-        totalTokenShortfallInUSD: BigInt(response.totalTokenShortfallInUSD),
-    };
-    return result;
-}
-function parseOrderCostResult(response) {
-    if (typeof response.hasFulfilledAll !== 'boolean') {
-        throw new Error('Missing or invalid hasFulfilledAll field');
-    }
-    if (response.hasFulfilledAll) {
-        return parseOrderCost(response);
-    }
-    else {
-        return parseInsufficientBalanceResult(response);
-    }
-}
-function parsePendingBundleEvent(response) {
-    return {
-        type: response.type,
-        bundleId: BigInt(response.bundleId),
-        targetFillPayload: {
-            to: response.targetFillPayload.to,
-            data: response.targetFillPayload.data,
-            value: BigInt(response.targetFillPayload.value),
-            chainId: response.targetFillPayload.chainId,
-        },
-        acrossDepositEvents: response.acrossDepositEvents.map((event) => {
-            return {
-                message: event.message,
-                depositId: BigInt(event.depositId),
-                depositor: event.depositor,
-                recipient: event.recipient,
-                inputToken: event.inputToken,
-                inputAmount: BigInt(event.inputAmount),
-                outputToken: event.outputToken,
-                fillDeadline: event.fillDeadline,
-                outputAmount: BigInt(event.outputAmount),
-                quoteTimestamp: event.quoteTimestamp,
-                exclusiveRelayer: event.exclusiveRelayer,
-                destinationChainId: event.destinationChainId,
-                originClaimPayload: {
-                    to: event.originClaimPayload.to,
-                    data: event.originClaimPayload.data,
-                    value: BigInt(event.originClaimPayload.value),
-                    chainId: event.originClaimPayload.chainId,
-                },
-                exclusivityDeadline: event.exclusivityDeadline,
-            };
-        }),
-    };
-}
-function hashMultiChainCompactWithDomainSeparator(multiChainCompact, domainSeparator) {
-    return keccak256(encodePacked(['string', 'bytes32', 'bytes32'], [
-        '\x19\x01',
-        domainSeparator,
-        hashMultichainCompactWithoutDomainSeparator(multiChainCompact),
-    ]));
-}
-function hashMultichainCompactWithoutDomainSeparator(multiChainCompact) {
-    return keccak256(encodeAbiParameters([
-        { name: 'typehash', type: 'bytes32' },
-        { name: 'sponsor', type: 'address' },
-        { name: 'nonce', type: 'uint256' },
-        { name: 'expires', type: 'uint256' },
-        { name: 'segments', type: 'bytes32' },
-    ], [
-        MULTICHAIN_COMPACT_TYPEHASH,
-        multiChainCompact.sponsor,
-        multiChainCompact.nonce,
-        multiChainCompact.expires,
-        hashSegments([...multiChainCompact.segments]),
-    ]));
-}
-function hashSegments(segment) {
-    return keccak256(encodePacked(['bytes32[]'], [segment.map(hashSegment)]));
-}
-function hashSegment(segment) {
-    return keccak256(encodeAbiParameters([
-        { name: 'typehash', type: 'bytes32' },
-        { name: 'arbiter', type: 'address' },
-        { name: 'chainId', type: 'uint256' },
-        { name: 'idsAndAmounts', type: 'bytes32' },
-        { name: 'witness', type: 'bytes32' },
-    ], [
-        SEGMENT_TYPEHASH,
-        segment.arbiter,
-        segment.chainId,
-        hashIdsAndAmounts(segment.idsAndAmounts),
-        hashWitness(segment.witness),
-    ]));
-}
-function hashWitness(witness) {
-    return keccak256(encodeAbiParameters([
-        { name: 'typehash', type: 'bytes32' },
-        { name: 'recipient', type: 'address' },
-        { name: 'tokenOut', type: 'bytes32' },
-        { name: 'depositId', type: 'uint256' },
-        { name: 'targetChain', type: 'uint256' },
-        { name: 'fillDeadline', type: 'uint32' },
-        { name: 'execs', type: 'bytes32' }, // Assuming XchainExec[] is complex
-        { name: 'userOpHash', type: 'bytes32' },
-        { name: 'maxFeeBps', type: 'uint32' },
-    ], [
-        WITNESS_TYPEHASH,
-        witness.recipient,
-        hashIdsAndAmounts(witness.tokenOut),
-        witness.depositId,
-        witness.targetChain,
-        witness.fillDeadline,
-        hashExecutionArray(witness.execs),
-        witness.userOpHash,
-        witness.maxFeeBps,
-    ]));
-}
-function getCompactDomainSeparator(chainId, verifyingContract) {
-    return domainSeparator({
-        domain: getCompactDomain(chainId, verifyingContract),
-    });
-}
-function getCompactDomain(chainId, verifyingContract) {
-    return {
-        name: 'The Compact',
-        version: '0',
-        chainId: chainId,
-        verifyingContract: verifyingContract,
-    };
-}
-function hashIdsAndAmounts(idsAndAmounts) {
-    return keccak256(encodePacked(['uint256[2][]'], [idsAndAmounts]));
-}
-function hashExecutionArray(executionArray) {
-    const hashes = executionArray.map(hashExecution);
-    return keccak256(encodePacked(['bytes32[]'], [hashes]));
-}
-function hashExecution(execution) {
-    return keccak256(encodeAbiParameters([
-        { name: 'typehash', type: 'bytes32' },
-        { name: 'target', type: 'address' },
-        { name: 'value', type: 'uint256' },
-        { name: 'callData', type: 'bytes32' },
-    ], [
-        EXECUTION_TYPEHASH,
-        execution.to,
-        execution.value,
-        keccak256(execution.data),
-    ]));
-}
-function applyInjectedExecutions(orderPath) {
-    if (orderPath.injectedExecutions.length > 0) {
-        orderPath.orderBundle.segments[0].witness.execs =
-            orderPath.injectedExecutions.concat(orderPath.orderBundle.segments[0].witness.execs);
-    }
-    return orderPath.orderBundle;
-}
-export { BundleStatusEnum, getEmptyUserOp, getOrderBundleHash, convertBigIntFields, parseCompactResponse, parsePendingBundleEvent, hashMultichainCompactWithoutDomainSeparator, parseUseChainBalances, parseOrderCost, parseInsufficientBalanceResult, parseOrderCostResult, applyInjectedExecutions, };

package/dist/src/types.d.ts

@@ -1,113 +0,0 @@
-import type { Account, Address, Chain, Hex } from 'viem';
-import type { WebAuthnAccount } from 'viem/account-abstraction';
-interface AccountProviderConfig {
-    type: 'safe' | 'nexus';
-}
-interface OwnableValidatorConfig {
-    type: 'ecdsa';
-    accounts: Account[];
-    threshold?: number;
-}
-interface WebauthnValidatorConfig {
-    type: 'passkey';
-    account: WebAuthnAccount;
-}
-interface BundlerConfig {
-    type: 'pimlico';
-    apiKey: string;
-}
-type OwnerSet = OwnableValidatorConfig | WebauthnValidatorConfig;
-interface SudoPolicy {
-    type: 'sudo';
-}
-interface UniversalActionPolicy {
-    type: 'universal-action';
-    valueLimitPerUse?: bigint;
-    rules: [UniversalActionPolicyParamRule, ...UniversalActionPolicyParamRule[]];
-}
-interface UniversalActionPolicyParamRule {
-    condition: UniversalActionPolicyParamCondition;
-    calldataOffset: bigint;
-    usageLimit?: bigint;
-    referenceValue: Hex | bigint;
-}
-type UniversalActionPolicyParamCondition = 'equal' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'notEqual' | 'inRange';
-interface SpendingLimitsPolicy {
-    type: 'spending-limits';
-    limits: {
-        token: Address;
-        amount: bigint;
-    }[];
-}
-interface TimeFramePolicy {
-    type: 'time-frame';
-    validUntil: number;
-    validAfter: number;
-}
-interface UsageLimitPolicy {
-    type: 'usage-limit';
-    limit: bigint;
-}
-interface ValueLimitPolicy {
-    type: 'value-limit';
-    limit: bigint;
-}
-type Policy = SudoPolicy | UniversalActionPolicy | SpendingLimitsPolicy | TimeFramePolicy | UsageLimitPolicy | ValueLimitPolicy;
-interface Action {
-    target: Address;
-    selector: Hex;
-    policies?: [Policy, ...Policy[]];
-}
-interface Session {
-    owners: OwnerSet;
-    policies?: [Policy, ...Policy[]];
-    actions?: [Action, ...Action[]];
-    salt?: Hex;
-}
-interface RhinestoneAccountConfig {
-    account?: AccountProviderConfig;
-    owners: OwnerSet;
-    rhinestoneApiKey: string;
-    deployerAccount?: Account;
-    sessions?: Session[];
-    eoa?: Account;
-    provider?: {
-        type: 'alchemy';
-        apiKey: string;
-    };
-    bundler?: BundlerConfig;
-}
-interface Call {
-    to: Address;
-    data?: Hex;
-    value?: bigint;
-}
-/**
- * @deprecated Use the `Call` type instead.
- */
-type Execution = Call;
-interface TokenRequest {
-    address: Address;
-    amount: bigint;
-}
-interface SessionSignerSet {
-    type: 'session';
-    session: Session;
-}
-type SignerSet = SessionSignerSet;
-interface BaseTransaction {
-    calls: Call[];
-    tokenRequests: TokenRequest[];
-    gasLimit?: bigint;
-    signers?: SignerSet;
-}
-interface SameChainTransaction extends BaseTransaction {
-    chain: Chain;
-}
-interface CrossChainTransaction extends BaseTransaction {
-    sourceChain?: Chain;
-    targetChain: Chain;
-}
-type Transaction = SameChainTransaction | CrossChainTransaction;
-export type { RhinestoneAccountConfig, AccountProviderConfig, BundlerConfig, Transaction, Call, Execution, TokenRequest, OwnerSet, SignerSet, Session, Policy, UniversalActionPolicyParamCondition, };
-//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../types.ts"],"names":[],"mappings":"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"}

package/dist/src/types.js

@@ -1 +0,0 @@
-export {};

package/dist/test/modules/validators/smart-sessions.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=smart-sessions.test.d.ts.map

package/dist/test/modules/validators/smart-sessions.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"smart-sessions.test.d.ts","sourceRoot":"","sources":["../../../../../test/modules/validators/smart-sessions.test.ts"],"names":[],"mappings":""}

package/dist/test/modules/validators/smart-sessions.test.js

@@ -1,20 +0,0 @@
-import { privateKeyToAccount } from 'viem/accounts';
-import { expect, test } from 'vitest';
-import { getPermissionId } from '../../../src/modules/validators/smart-sessions.js';
-test('getPermissionId', () => {
-    const accountA = privateKeyToAccount('0x2be89d993f98bbaab8b83f1a2830cb9414e19662967c7ba2a0f43d2a9125bd6d');
-    const accountB = privateKeyToAccount('0x39e2fec1a04c088f939d81de8f1abebdebf899a6cfb9968f9b663a7afba8301b');
-    expect(getPermissionId({
-        owners: {
-            type: 'ecdsa',
-            accounts: [accountA, accountB],
-        },
-    })).toBe('0xa16d89135da22ae1b97b6ac6ebc047dce282640bbbf56059958d96527b720344');
-    expect(getPermissionId({
-        owners: {
-            type: 'ecdsa',
-            accounts: [accountA, accountB],
-        },
-        salt: '0x97340e1cfff3319c76ef22b2bc9d3231071d550125d68c9d4a8972823f166320',
-    })).toBe('0x85ff7cd77e7e0f8fbc2e42c86cdb948e4c79ac5a5e4595def4c38d7ed804eef9');
-});