Velora SDK

The Velora SDK provides a lightweight and versatile interface for interacting with the Velora API.

Key characteristics:

• Versatility: Compatible with web3 or ethers without requiring them as direct dependencies. It also supports viem (which is used internally for utilities).
• Canonical: Designed to allow developers to import only the specific functions they need.
• Lightweight: The minimal variant is approximately 10KB Gzipped.

The writable.cork() method is used to buffer multiple small chunks written to a stream in rapid succession. Instead of immediately forwarding them to the destination, they are buffered until writable.uncork() is called. When uncorked, all buffered chunks are passed to writable._writev() (if implemented).

Note: Using cork() without implementing _writev() may negatively impact throughput.

// Note: This is a conceptual usage pattern for Writable streams
// writable.cork();
// writable.write(chunk1);
// writable.write(chunk2);
// writable.uncork();

The Web3Context provides mechanisms to manage context hierarchies and create new specialized objects that share the same underlying context.

• use(ContextRef, ...args): Creates a new object of type T (which must extend Web3Context) and automatically links it to the current context. This is the preferred way to initiate a global context and derive new objects from it.
• link(parentContext): Manually links the current context to another parentContext.
• fromContextObject(contextObject, ...args): A static method used to reconstruct a Web3Context instance from a Web3ContextObject.

// Using 'use' to create a new context-linked object
const newContext = web3Context.use(MyCustomContextClass, arg1, arg2);

External Delta Orders allow for complex DeFi strategies by delegating token handling to an external handler contract. While the Delta protocol manages the auction, settlement, and signature verification, the handler contract executes the specific logic (e.g., Aave flash loans, collateral/debt swaps).

Key differences from Standard Delta Orders:

• Required fields: handler (address of the contract) and data (protocol-specific bytes).
• Unsupported features: bridge field and cross-chain support are not available for External Orders.
• Supported features: beneficiary is supported (defaults to owner).

As with all Delta v2 orders, the Order is built by the server based on the route returned by getDeltaPrice. You sign the returned typed data and post it.

The NonPayableMethodObject<Inputs, Outputs> interface represents a contract method that does not require a value transfer (non-payable). It is used to interact with specific functions on a smart contract via the SDK.

To use this interface, you must provide the expected types for Inputs and Outputs as type parameters. The object contains the arguments required for the method call and provides several utility methods for transaction lifecycle management, such as encoding data, estimating gas, and sending the transaction.

// Example conceptual usage
const method: NonPayableMethodObject<[string, number], [boolean]> = {
  arguments: ['some-id', 123],
  // ... other properties and methods
};

The PassThrough class is a trivial implementation of a Transform stream that passes input bytes directly to the output without modification. While primarily used for testing and examples, it can serve as a building block for creating custom stream pipelines where you need a transparent bridge between a readable and a writable stream.

// Example conceptual usage of PassThrough
import { PassThrough } from 'stream';

const passThrough = new PassThrough();
// Input written to passThrough will be emitted by its readable side
passThrough.write('data');
passThrough.pipe(process.stdout);

Amounts are derived server-side from the quoted route. You can control them in two ways:

1. Using slippage (Recommended): Pass a slippage value in basis points (e.g., 50 for 0.5%) to the build method. The server computes the slippage-adjusted amount.
2. Using limitAmount: Pass an explicit limitAmount. The server uses this as the SELL destAmount (for 'SELL' side) or BUY srcAmount (for 'BUY' side) and as the expectedAmount.

// Using slippage
await deltaSDK.buildExternalDeltaOrder({
  route: deltaPrice.route,
  side: deltaPrice.side,
  // ...
  slippage: 50,
});

// Using explicit limitAmount
await deltaSDK.buildExternalDeltaOrder({
  route: deltaPrice.route,
  side: deltaPrice.side,
  // ...
  limitAmount: destAmountLimit,
});