@imtbl/sdk 0.6.0-alpha → 0.7.0-alpha.1

package/dist/orderbook.js

@@ -528,6 +528,21 @@ var OrderStatus;
     OrderStatus["EXPIRED"] = "EXPIRED";
 })(OrderStatus || (OrderStatus = {}));
 
+var TransactionPurpose;
+(function (TransactionPurpose) {
+    TransactionPurpose["APPROVAL"] = "APPROVAL";
+    TransactionPurpose["FULFILL_ORDER"] = "FULFILL_ORDER";
+})(TransactionPurpose || (TransactionPurpose = {}));
+var SignablePurpose;
+(function (SignablePurpose) {
+    SignablePurpose["CREATE_LISTING"] = "CREATE_LISTING";
+})(SignablePurpose || (SignablePurpose = {}));
+var ActionType;
+(function (ActionType) {
+    ActionType["TRANSACTION"] = "TRANSACTION";
+    ActionType["SIGNABLE"] = "SIGNABLE";
+})(ActionType || (ActionType = {}));
+
 /* eslint-disable */
 // TODO: Resolve these from seaport-js.
 // There is some bundling issue that is preventing this from working
@@ -604,12 +619,14 @@ function getOrderComponentsFromMessage(orderMessage) {
 
 // Add 20% more gas than estimate to prevent out of gas errors
 // This can always be overwritten by the user signing the transaction
-async function prepareTransaction(transactionMethods) {
-    const transaction = await transactionMethods.buildTransaction();
-    transaction.gasLimit = await transactionMethods.estimateGas();
-    transaction.gasLimit = transaction.gasLimit
-        .add(transaction.gasLimit.div(5));
-    return transaction;
+function prepareTransaction(transactionMethods) {
+    return async () => {
+        const transaction = await transactionMethods.buildTransaction();
+        transaction.gasLimit = await transactionMethods.estimateGas();
+        transaction.gasLimit = transaction.gasLimit
+            .add(transaction.gasLimit.div(5));
+        return transaction;
+    };
 }
 
 function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress) {
@@ -691,31 +708,39 @@ class Seaport {
         this.zoneContractAddress = zoneContractAddress;
     }
     async prepareSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
-        const { actions } = await this.createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry);
-        let approvalTransaction;
-        const approvalAction = actions
+        const { actions: seaportActions } = await this.createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry);
+        const listingActions = [];
+        const approvalAction = seaportActions
             .find((action) => action.type === 'approval');
         if (approvalAction) {
-            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
+            listingActions.push({
+                type: ActionType.TRANSACTION,
+                purpose: TransactionPurpose.APPROVAL,
+                buildTransaction: prepareTransaction(approvalAction.transactionMethods),
+            });
         }
-        const createAction = actions
+        const createAction = seaportActions
             .find((action) => action.type === 'create');
         if (!createAction) {
             throw new Error('No create order action found');
         }
         const orderMessageToSign = await createAction.getMessageToSign();
         const orderComponents = getOrderComponentsFromMessage(orderMessageToSign);
+        listingActions.push({
+            type: ActionType.SIGNABLE,
+            purpose: SignablePurpose.CREATE_LISTING,
+            message: await this.getTypedDataFromOrderComponents(orderComponents),
+        });
         return {
-            unsignedApprovalTransaction: approvalTransaction,
-            typedOrderMessageForSigning: await this.getTypedDataFromOrderComponents(orderComponents),
+            actions: listingActions,
             orderComponents,
             orderHash: this.getSeaportLib().getOrderHash(orderComponents),
         };
     }
-    async fulfilOrder(order, account) {
+    async fulfillOrder(order, account) {
         const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
         const seaportLib = this.getSeaportLib(order);
-        const { actions } = await seaportLib.fulfillOrders({
+        const { actions: seaportActions } = await seaportLib.fulfillOrders({
             accountAddress: account,
             fulfillOrderDetails: [{
                     order: {
@@ -725,28 +750,33 @@ class Seaport {
                     extraData: order.protocol_data.operator_signature,
                 }],
         });
-        let approvalTransaction;
-        const approvalAction = actions
+        const fulfillmentActions = [];
+        const approvalAction = seaportActions
             .find((action) => action.type === 'approval');
         if (approvalAction) {
-            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
+            fulfillmentActions.push({
+                type: ActionType.TRANSACTION,
+                buildTransaction: prepareTransaction(approvalAction.transactionMethods),
+                purpose: TransactionPurpose.APPROVAL,
+            });
         }
-        const fulfillmentAction = actions
+        const fulfilOrderAction = seaportActions
             .find((action) => action.type === 'exchange');
-        if (!fulfillmentAction) {
+        if (!fulfilOrderAction) {
             throw new Error('No exchange action found');
         }
-        const fulfillmentTransaction = await prepareTransaction(fulfillmentAction.transactionMethods);
-        return {
-            unsignedApprovalTransaction: approvalTransaction,
-            unsignedFulfillmentTransaction: fulfillmentTransaction,
-        };
+        fulfillmentActions.push({
+            type: ActionType.TRANSACTION,
+            buildTransaction: prepareTransaction(fulfilOrderAction.transactionMethods),
+            purpose: TransactionPurpose.FULFILL_ORDER,
+        });
+        return { actions: fulfillmentActions };
     }
     async cancelOrder(order, account) {
         const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
         const seaportLib = this.getSeaportLib(order);
         const cancellationTransaction = await seaportLib.cancelOrders([orderComponents], account);
-        return prepareTransaction(cancellationTransaction);
+        return prepareTransaction(cancellationTransaction)();
     }
     mapImmutableOrderToSeaportOrderComponents(order) {
         const orderCounter = order.protocol_data.counter;
@@ -910,9 +940,9 @@ function getOrderbookConfig(environment) {
     switch (environment) {
         case Environment.SANDBOX:
             return {
-                seaportContractAddress: '0x474989C4D25DD41B0B9b1ECb4643B9Fe25f83B19',
-                zoneContractAddress: '0x6FeDb4949E5b452700A8a8956999a7E05B6770F3',
-                apiEndpoint: 'https://api.sandbox.immutable.com',
+                seaportContractAddress: '0x410000346E270aDbC89b2b688177d3AE76348dE9',
+                zoneContractAddress: '0x979C2aCA989A56554Eb63E01e576E3179Cdad5A0',
+                apiEndpoint: 'https://order-book-mr.sandbox.imtbl.com',
                 chainName: TESTNET_CHAIN_NAME,
                 provider: new providers.JsonRpcProvider('https://rpc.testnet.immutable.com'),
             };
@@ -1954,7 +1984,7 @@ class Orderbook {
         if (orderResult.result.status !== OrderStatus.ACTIVE) {
             throw new Error(`Cannot fulfil order that is not active. Current status: ${orderResult.result.status}`);
         }
-        return this.seaport.fulfilOrder(orderResult.result, takerAddress);
+        return this.seaport.fulfillOrder(orderResult.result, takerAddress);
     }
     /**
      * Get an unsigned cancel order transaction. Orders can only be cancelled by
@@ -1978,6 +2008,4 @@ class Orderbook {
     }
 }
 
-const module = 'orderbook';
-
-export { Orderbook, module };
+export { ActionType, Orderbook, SignablePurpose, TransactionPurpose };

package/dist/passport.js

@@ -1457,7 +1457,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.6.0-alpha' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.7.0-alpha.1' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -1513,7 +1513,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.6.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.7.0-alpha.1',
 });
 /**
  * Sets `sdkVersion` at the time of build

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imtbl/sdk",
   "description": "Immutable Unified SDK",
-  "version": "0.6.0-alpha",
+  "version": "0.7.0-alpha.1",
   "author": "Immutable",
   "browser": "./dist/index.browser.js",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",