@rhinestone/sdk 0.0.0-dev-20260204114155

package/dist/src/execution/compact.d.ts

@@ -0,0 +1,148 @@
+import { type Hex } from 'viem';
+import type { IntentOp, IntentOpElement } from '../orchestrator/types';
+declare const SCOPE_MULTICHAIN = 0;
+declare const RESET_PERIOD_ONE_WEEK = 6;
+declare const COMPACT_ADDRESS = "0x00000000000000171ede64904551eeDF3C6C9788";
+declare function getCompactTypedData(intentOp: IntentOp): {
+    readonly domain: {
+        readonly name: "The Compact";
+        readonly version: "1";
+        readonly chainId: number;
+        readonly verifyingContract: "0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f";
+    };
+    readonly types: {
+        readonly MultichainCompact: readonly [{
+            readonly name: "sponsor";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "expires";
+            readonly type: "uint256";
+        }, {
+            readonly name: "elements";
+            readonly type: "Element[]";
+        }];
+        readonly Element: readonly [{
+            readonly name: "arbiter";
+            readonly type: "address";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "commitments";
+            readonly type: "Lock[]";
+        }, {
+            readonly name: "mandate";
+            readonly type: "Mandate";
+        }];
+        readonly Lock: readonly [{
+            readonly name: "lockTag";
+            readonly type: "bytes12";
+        }, {
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly Mandate: readonly [{
+            readonly name: "target";
+            readonly type: "Target";
+        }, {
+            readonly name: "minGas";
+            readonly type: "uint128";
+        }, {
+            readonly name: "originOps";
+            readonly type: "Op";
+        }, {
+            readonly name: "destOps";
+            readonly type: "Op";
+        }, {
+            readonly name: "q";
+            readonly type: "bytes32";
+        }];
+        readonly Target: readonly [{
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "tokenOut";
+            readonly type: "Token[]";
+        }, {
+            readonly name: "targetChain";
+            readonly type: "uint256";
+        }, {
+            readonly name: "fillExpiry";
+            readonly type: "uint256";
+        }];
+        readonly Token: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly Op: readonly [{
+            readonly name: "vt";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "ops";
+            readonly type: "Ops[]";
+        }];
+        readonly Ops: readonly [{
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+    };
+    readonly primaryType: "MultichainCompact";
+    readonly message: {
+        readonly sponsor: `0x${string}`;
+        readonly nonce: bigint;
+        readonly expires: bigint;
+        readonly elements: {
+            arbiter: `0x${string}`;
+            chainId: bigint;
+            commitments: {
+                lockTag: `0x${string}`;
+                token: `0x${string}`;
+                amount: bigint;
+            }[];
+            mandate: {
+                target: {
+                    recipient: `0x${string}`;
+                    tokenOut: {
+                        token: `0x${string}`;
+                        amount: bigint;
+                    }[];
+                    targetChain: bigint;
+                    fillExpiry: bigint;
+                };
+                minGas: bigint;
+                originOps: import("../orchestrator/types").Op;
+                destOps: import("../orchestrator/types").Op;
+                q: `0x${string}`;
+            };
+        }[];
+    };
+};
+/**
+ * Get the compact digest for signing
+ * @param intentOp The intent operation
+ * @returns The digest hash
+ */
+declare function getCompactDigest(intentOp: IntentOp): Hex;
+/**
+ * Get the Permit2 digest for signing
+ * @param intentOp The intent operation
+ * @returns The digest hash
+ */
+declare function getPermit2Digest(element: IntentOpElement, nonce: bigint, expires: bigint): Hex;
+export { SCOPE_MULTICHAIN, RESET_PERIOD_ONE_WEEK, COMPACT_ADDRESS, getCompactTypedData, getCompactDigest, getPermit2Digest, };
+//# sourceMappingURL=compact.d.ts.map

package/dist/src/execution/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../execution/compact.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAA0C,MAAM,MAAM,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAGtE,QAAA,MAAM,gBAAgB,IAAI,CAAA;AAC1B,QAAA,MAAM,qBAAqB,IAAI,CAAA;AAE/B,QAAA,MAAM,eAAe,+CAA+C,CAAA;AAiDpE,iBAAS,mBAAmB,CAAC,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0C9C;AAED;;;;GAIG;AACH,iBAAS,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,GAAG,CAGjD;AAED;;;;GAIG;AACH,iBAAS,gBAAgB,CACvB,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,GAAG,CAGL;AAED,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,GACjB,CAAA"}

package/dist/src/execution/compact.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPACT_ADDRESS = exports.RESET_PERIOD_ONE_WEEK = exports.SCOPE_MULTICHAIN = void 0;
+exports.getCompactTypedData = getCompactTypedData;
+exports.getCompactDigest = getCompactDigest;
+exports.getPermit2Digest = getPermit2Digest;
+const viem_1 = require("viem");
+const permit2_1 = require("./permit2");
+const SCOPE_MULTICHAIN = 0;
+exports.SCOPE_MULTICHAIN = SCOPE_MULTICHAIN;
+const RESET_PERIOD_ONE_WEEK = 6;
+exports.RESET_PERIOD_ONE_WEEK = RESET_PERIOD_ONE_WEEK;
+const COMPACT_ADDRESS = '0x00000000000000171ede64904551eeDF3C6C9788';
+exports.COMPACT_ADDRESS = COMPACT_ADDRESS;
+// Define the typed data structure as const to preserve type safety
+const COMPACT_TYPED_DATA_TYPES = {
+    MultichainCompact: [
+        { name: 'sponsor', type: 'address' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'expires', type: 'uint256' },
+        { name: 'elements', type: 'Element[]' },
+    ],
+    Element: [
+        { name: 'arbiter', type: 'address' },
+        { name: 'chainId', type: 'uint256' },
+        { name: 'commitments', type: 'Lock[]' },
+        { name: 'mandate', type: 'Mandate' },
+    ],
+    Lock: [
+        { name: 'lockTag', type: 'bytes12' },
+        { name: 'token', type: 'address' },
+        { name: 'amount', type: 'uint256' },
+    ],
+    Mandate: [
+        { name: 'target', type: 'Target' },
+        { name: 'minGas', type: 'uint128' },
+        { name: 'originOps', type: 'Op' },
+        { name: 'destOps', type: 'Op' },
+        { name: 'q', type: 'bytes32' },
+    ],
+    Target: [
+        { name: 'recipient', type: 'address' },
+        { name: 'tokenOut', type: 'Token[]' },
+        { name: 'targetChain', type: 'uint256' },
+        { name: 'fillExpiry', type: 'uint256' },
+    ],
+    Token: [
+        { name: 'token', type: 'address' },
+        { name: 'amount', type: 'uint256' },
+    ],
+    Op: [
+        { name: 'vt', type: 'bytes32' },
+        { name: 'ops', type: 'Ops[]' },
+    ],
+    Ops: [
+        { name: 'to', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'data', type: 'bytes' },
+    ],
+};
+function getCompactTypedData(intentOp) {
+    const typedData = {
+        domain: {
+            name: 'The Compact',
+            version: '1',
+            chainId: Number(intentOp.elements[0].chainId),
+            verifyingContract: '0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f',
+        },
+        types: COMPACT_TYPED_DATA_TYPES,
+        primaryType: 'MultichainCompact',
+        message: {
+            sponsor: intentOp.sponsor,
+            nonce: BigInt(intentOp.nonce),
+            expires: BigInt(intentOp.expires),
+            elements: intentOp.elements.map((element) => ({
+                arbiter: element.arbiter,
+                chainId: BigInt(element.chainId),
+                commitments: element.idsAndAmounts.map((token) => ({
+                    lockTag: (0, viem_1.slice)((0, viem_1.toHex)(BigInt(token[0])), 0, 12),
+                    token: (0, viem_1.slice)((0, viem_1.toHex)(BigInt(token[0])), 12, 32),
+                    amount: BigInt(token[1]),
+                })),
+                mandate: {
+                    target: {
+                        recipient: element.mandate.recipient,
+                        tokenOut: element.mandate.tokenOut.map((token) => ({
+                            token: (0, viem_1.slice)((0, viem_1.toHex)(BigInt(token[0])), 12, 32),
+                            amount: BigInt(token[1]),
+                        })),
+                        targetChain: BigInt(element.mandate.destinationChainId),
+                        fillExpiry: BigInt(element.mandate.fillDeadline),
+                    },
+                    minGas: BigInt(element.mandate.minGas),
+                    originOps: element.mandate.preClaimOps,
+                    destOps: element.mandate.destinationOps,
+                    q: (0, viem_1.keccak256)(element.mandate.qualifier.encodedVal),
+                },
+            })),
+        },
+    };
+    return typedData;
+}
+/**
+ * Get the compact digest for signing
+ * @param intentOp The intent operation
+ * @returns The digest hash
+ */
+function getCompactDigest(intentOp) {
+    const typedData = getCompactTypedData(intentOp);
+    return (0, viem_1.hashTypedData)(typedData);
+}
+/**
+ * Get the Permit2 digest for signing
+ * @param intentOp The intent operation
+ * @returns The digest hash
+ */
+function getPermit2Digest(element, nonce, expires) {
+    const typedData = (0, permit2_1.getTypedData)(element, nonce, expires);
+    return (0, viem_1.hashTypedData)(typedData);
+}

package/dist/src/execution/error.d.ts

@@ -0,0 +1,55 @@
+declare class ExecutionError extends Error {
+    private readonly _message;
+    private readonly _context;
+    private readonly _errorType;
+    private readonly _traceId;
+    constructor(params?: {
+        message?: string;
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+    get message(): string;
+    get context(): any;
+    get errorType(): string;
+    get traceId(): string;
+}
+declare class SignerNotSupportedError extends ExecutionError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class OrderPathRequiredForIntentsError extends ExecutionError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class SessionChainRequiredError extends ExecutionError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class IntentFailedError extends ExecutionError {
+    constructor(params?: {
+        intentId?: string;
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class IntentStatusTimeoutError extends ExecutionError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare function isExecutionError(error: Error): error is ExecutionError;
+export { isExecutionError, ExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, IntentFailedError, IntentStatusTimeoutError, SignerNotSupportedError, };
+//# sourceMappingURL=error.d.ts.map

package/dist/src/execution/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../execution/error.ts"],"names":[],"mappings":"AAAA,cAAM,cAAe,SAAQ,KAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAK;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;IAQD,IAAI,OAAO,WAEV;IAED,IAAI,OAAO,QAEV;IAED,IAAI,SAAS,WAEZ;IAED,IAAI,OAAO,WAEV;CACF;AAED,cAAM,uBAAwB,SAAQ,cAAc;gBACtC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAOF;AAED,cAAM,gCAAiC,SAAQ,cAAc;gBAC/C,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,yBAA0B,SAAQ,cAAc;gBACxC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAOF;AAED,cAAM,iBAAkB,SAAQ,cAAc;gBAChC,MAAM,CAAC,EAAE;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,wBAAyB,SAAQ,cAAc;gBACvC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,iBAAS,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,cAAc,CAE/D;AAED,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,gCAAgC,EAChC,yBAAyB,EACzB,iBAAiB,EACjB,wBAAwB,EACxB,uBAAuB,GACxB,CAAA"}

package/dist/src/execution/error.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignerNotSupportedError = exports.IntentStatusTimeoutError = exports.IntentFailedError = exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.ExecutionError = void 0;
+exports.isExecutionError = isExecutionError;
+class ExecutionError extends Error {
+    _message;
+    _context;
+    _errorType;
+    _traceId;
+    constructor(params) {
+        super();
+        this._message = params?.message || 'ExecutionError';
+        this._context = params?.context || {};
+        this._errorType = params?.errorType || 'Unknown';
+        this._traceId = params?.traceId || '';
+    }
+    get message() {
+        return this._message;
+    }
+    get context() {
+        return this._context;
+    }
+    get errorType() {
+        return this._errorType;
+    }
+    get traceId() {
+        return this._traceId;
+    }
+}
+exports.ExecutionError = ExecutionError;
+class SignerNotSupportedError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: 'Sending a transaction is not supported for this type of signers. Use user operations instead.',
+            ...params,
+        });
+    }
+}
+exports.SignerNotSupportedError = SignerNotSupportedError;
+class OrderPathRequiredForIntentsError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: 'Order path is required when using intents',
+            ...params,
+        });
+    }
+}
+exports.OrderPathRequiredForIntentsError = OrderPathRequiredForIntentsError;
+class SessionChainRequiredError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: 'Specifying a chain is required when using multi-chain smart sessions',
+            ...params,
+        });
+    }
+}
+exports.SessionChainRequiredError = SessionChainRequiredError;
+class IntentFailedError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: 'Intent failed',
+            ...params,
+        });
+    }
+}
+exports.IntentFailedError = IntentFailedError;
+class IntentStatusTimeoutError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: 'Intent status polling timed out',
+            ...params,
+        });
+    }
+}
+exports.IntentStatusTimeoutError = IntentStatusTimeoutError;
+function isExecutionError(error) {
+    return error instanceof ExecutionError;
+}

package/dist/src/execution/index.d.ts

@@ -0,0 +1,41 @@
+import { type Address, type Chain, type Hex } from 'viem';
+import type { UserOperationReceipt } from 'viem/_types/account-abstraction';
+import type { IntentOpStatus, SplitIntentsInput } from '../orchestrator';
+import type { SettlementLayer } from '../orchestrator/types';
+import type { CalldataInput, CallInput, RhinestoneAccountConfig, RhinestoneConfig, SignerSet, SourceAssetInput, Sponsorship, TokenRequest, TokenSymbol, Transaction, UserOperationTransaction } from '../types';
+import { ExecutionError, IntentFailedError, IntentStatusTimeoutError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError } from './error';
+import type { TransactionResult, UserOperationResult } from './utils';
+interface TransactionStatus {
+    fill: {
+        hash: Hex | undefined;
+        chainId: number;
+    };
+    claims: {
+        hash: Hex | undefined;
+        chainId: number;
+    }[];
+}
+declare function sendTransaction(config: RhinestoneAccountConfig, transaction: Transaction): Promise<TransactionResult>;
+declare function sendUserOperation(config: RhinestoneAccountConfig, transaction: UserOperationTransaction): Promise<UserOperationResult>;
+declare function sendTransactionInternal(config: RhinestoneConfig, sourceChains: Chain[] | undefined, targetChain: Chain, options: {
+    callInputs?: CallInput[];
+    gasLimit?: bigint;
+    initialTokenRequests?: TokenRequest[];
+    recipient?: RhinestoneAccountConfig | Address;
+    signers?: SignerSet;
+    sponsored?: Sponsorship;
+    settlementLayers?: SettlementLayer[];
+    sourceAssets?: SourceAssetInput;
+    lockFunds?: boolean;
+    feeAsset?: Address | TokenSymbol;
+}): Promise<TransactionResult>;
+declare function sendUserOperationInternal(config: RhinestoneConfig, chain: Chain, callInputs: CalldataInput[], signers?: SignerSet): Promise<UserOperationResult>;
+declare function waitForExecution(config: RhinestoneConfig, result: TransactionResult | UserOperationResult, acceptsPreconfirmations: boolean): Promise<TransactionStatus | UserOperationReceipt>;
+declare function getPortfolio(config: RhinestoneConfig, onTestnets: boolean): Promise<import("../orchestrator").Portfolio>;
+declare function getIntentStatus(apiKey: string | undefined, endpointUrl: string | undefined, intentId: bigint): Promise<TransactionStatus & {
+    status: IntentOpStatus['status'];
+}>;
+declare function splitIntents(apiKey: string | undefined, endpointUrl: string | undefined, input: SplitIntentsInput): Promise<import("../orchestrator").SplitIntentsResult>;
+export { sendTransaction, sendTransactionInternal, sendUserOperation, sendUserOperationInternal, waitForExecution, getPortfolio, getIntentStatus, splitIntents, isExecutionError, ExecutionError, IntentFailedError, IntentStatusTimeoutError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError, };
+export type { TransactionStatus, TransactionResult, UserOperationResult };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/execution/index.d.ts.map

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